सी ++

Question

में एक बहुत बड़ी 2 डी सरणी के आसपास कैसे काम करें I 800x800 आकार की 2 डी int सरणी बनाने की आवश्यकता है। लेकिन ऐसा करने से एक ढेर ओवरफ्लो (हा हा) बनाता है।

मैं सी ++ में नया हूं, तो क्या मुझे वैक्टर के वेक्टर की तरह कुछ करना चाहिए? और बस एक कक्षा में 2 डी सरणी encapsulate?

विशेष रूप से, यह सरणी एक ग्राफिक्स प्रोग्राम में मेरा zbuffer है। मुझे स्क्रीन पर प्रत्येक पिक्सेल के लिए एक जेड वैल्यू स्टोर करने की आवश्यकता है (इसलिए 800x800 का बड़ा आकार)।

धन्यवाद!

Answer 1

आपको लगभग 2.5 मेग्स की आवश्यकता है, इसलिए केवल ढेर का उपयोग ठीक होना चाहिए। आपको एक वेक्टर की आवश्यकता नहीं है जब तक कि आपको इसका आकार बदलने की आवश्यकता न हो। "2 डी" हीप सरणी का उपयोग करने के उदाहरण के लिए C++ FAQ Lite देखें।

int *array = new int[800*800]; 

(काम पूरा हो जाने delete[] के लिए यह मत भूलना।)

Answer 2

आप वैक्टर का एक वेक्टर कर सकता है, लेकिन है कि कुछ भूमि के ऊपर होगा। ज़ेड-बफर के लिए 800 * 800 = 640000 आकार की सरणी बनाने के लिए अधिक सामान्य विधि होगी। इस प्रकार

const int width = 800; 
const int height = 800; 
unsigned int* z_buffer = new unsigned int[width*height]; 

तब पिक्सल का उपयोग:

unsigned int z = z_buffer[y*width+x]; 

Answer 3

मैं 800 * 800 का एक भी आयाम सरणी बना सकता है। यह 800 अलग वैक्टर आवंटित करने के बजाय, इस तरह के एक आवंटन का उपयोग करने के लिए शायद अधिक कुशल है।

int *ary=new int[800*800]; 

फिर, शायद उस वर्ग में जो 2 डी सरणी की तरह कार्य करता है उसे समाहित करता है।

class _2DArray 
{ 
    public: 
    int *operator[](const size_t &idx) 
    { 
    return &ary[idx*800]; 
    } 
    const int *operator[](const size_t &idx) const 
    { 
    return &ary[idx*800]; 
    } 
}; 

अमूर्त यहाँ दिखाया गया है छेद, उदा का एक बहुत, यदि आप एक "पंक्ति" के अंत अतीत बाहर का उपयोग क्या होता है? "प्रभावशाली सी ++" पुस्तक में सी ++ में अच्छे बहु आयामी सरणी लिखने की एक अच्छी अच्छी चर्चा है।

Answer 4

वहाँ ऐसा करने का रास्ता की तरह सी है:

const int xwidth = 800; 
const int ywidth = 800; 
int* array = (int*) new int[xwidth * ywidth]; 
// Check array is not NULL here and handle the allocation error if it is 
// Then do stuff with the array, such as zero initialize it 
for(int x = 0; x < xwidth; ++x) 
{ 
    for(int y = 0; y < ywidth; ++y) 
    { 
     array[y * xwidth + x] = 0; 
    } 
} 
// Just use array[y * xwidth + x] when you want to access your class. 

// When you're done with it, free the memory you allocated with 
delete[] array; 

आप एक आसान बात के साथ एक वर्ग के अंदर y * xwidth + x संपुटित सकता है और विधि सेट ([] ऑपरेटर ओवरलोडिंग के साथ संभवतः यदि आप और अधिक उन्नत में हो रही शुरू करना चाहते हैं सी ++)। मैं धीरे-धीरे यह प्राप्त करने की अनुशंसा करता हूं कि यदि आप अभी सी ++ से शुरू कर रहे हैं और एन-आयाम सरणी के लिए पुनः उपयोग करने योग्य पूरी तरह से क्लास टेम्पलेट्स बनाना शुरू नहीं करते हैं जो आपको शुरू होने पर ही भ्रमित कर देगा।

जैसे ही आप ग्राफिक्स काम में आते हैं, आपको पता चलेगा कि अतिरिक्त कक्षा कॉल होने का ओवरहेड आपके कोड को धीमा कर सकता है। हालांकि इस बारे में चिंता न करें जब तक कि आपका आवेदन पर्याप्त तेज़ न हो और आप इसे अनावश्यक जटिलता के साथ शुरुआत में उपयोग करना अधिक कठिन बनाने के बजाय, यह कहां खो जाएंगे, यह दिखाने के लिए प्रोफ़ाइल कर सकते हैं।

मुझे पता चला कि सी ++ लाइट अकसर किये गए सवाल इस तरह की जानकारी के लिए बहुत अच्छे थे।विशेष रूप से अपने प्रश्न का जवाब है:

http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.16

Answer 5

ठीक है, क्या नियाल रयान शुरू कर दिया पर निर्माण, अगर प्रदर्शन एक मुद्दा है, तो आप इस एक कदम और आगे गणित के अनुकूलन और एक वर्ग में इस encapsulating द्वारा ले जा सकते हैं।

तो हम कुछ गणित के साथ शुरू करेंगे। याद रखें कि 800 के रूप में 2 की शक्तियों में लिखा जा सकता है:

:

int index = y << 9 + y << 8 + y << 5 + x; 

तो अगर हम एक अच्छा वर्ग पर हम पाते हैं में सब कुछ संपुटित:

800 = 512 + 256 + 32 = 2^5 + 2^8 + 2^9 

के रूप में तो हम अपने को संबोधित समारोह लिख सकते हैं

class ZBuffer 
{ 
public: 
    const int width = 800; 
    const int height = 800; 

    ZBuffer() 
    { 
     for(unsigned int i = 0, *pBuff = zbuff; i < width * height; i++, pBuff++) 
      *pBuff = 0; 
    } 

    inline unsigned int getZAt(unsigned int x, unsigned int y) 
    { 
     return *(zbuff + y << 9 + y << 8 + y << 5 + x); 
    } 

    inline unsigned int setZAt(unsigned int x, unsigned int y, unsigned int z) 
    { 
     *(zbuff + y << 9 + y << 8 + y << 5 + x) = z; 
    } 
private: 
    unsigned int zbuff[width * height]; 
}; 

Answer 6

प्रत्येक पोस्ट अब तक प्रोग्रामर के लिए स्मृति प्रबंधन छोड़ देता है। यह से बचा जा सकता है और बचा जाना चाहिए। ReaperUnreal जो मैं करता हूं उसके करीब है, सिवाय इसके कि मैं एक सरणी के बजाय वेक्टर का उपयोग करता हूं और आयाम टेम्पलेट पैरामीटर भी बनाता हूं और एक्सेस फ़ंक्शंस को बदलता हूं - और ओह सिर्फ आईएनएनएसएचओ चीजों को थोड़ा सा साफ़ करें:

template <class T, size_t W, size_t H> 
class Array2D 
{ 
public: 
    const int width = W; 
    const int height = H; 
    typedef typename T type; 

    Array2D() 
     : buffer(width*height) 
    { 
    } 

    inline type& at(unsigned int x, unsigned int y) 
    { 
     return buffer[y*width + x]; 
    } 

    inline const type& at(unsigned int x, unsigned int y) const 
    { 
     return buffer[y*width + x]; 
    } 

private: 
    std::vector<T> buffer; 
}; 

अब आप ठीक ढेर पर इस 2-डी सरणी आवंटित कर सकते हैं:

void foo() 
{ 
    Array2D<int, 800, 800> zbuffer; 

    // Do something with zbuffer... 
} 

मुझे आशा है कि इस मदद करता है!

संपादित करें: Array2D::buffer से हटाए गए सरणी विनिर्देश। एंड्रियास को पकड़ने के लिए धन्यवाद!

Answer 7

एक बात आप कर सकते हैं कुलपति के साथ ध्वज यह है करने के लिए ढेर आकार बदल (यदि आप वास्तव में स्टैक पर सरणी चाहते हैं) है [/ एफ] (http://msdn.microsoft.com/en-us/library/tdkhxaks(VS.80).aspx)।

लेकिन समाधान आप शायद चाहते हैं ढेर में के बजाय ढेर पर स्मृति डाल करने के लिए, कि आप vectors के vector का उपयोग करना चाहिए के लिए प्रत्येक तत्व 800 int रों की एक vector है और आप बचाता है।

निम्न पंक्ति एक 800 की vector तत्वों वाणी, मैन्युअल रूप से मेमोरी को प्रबंधित करने से।

std::vector<std::vector<int> > arr(800, std::vector<int>(800)); 

दो समापन कोण ब्रैकेट्स (> >) के बीच की जगह पर ध्यान दें, ताकि इसे शिफ्ट दाएं ऑपरेटर से अलग कर दिया जा सके (जिसे C++0x में अब आवश्यकता नहीं होगी)।

Answer 8

केविन के उदाहरण अच्छा है, तथापि:

std::vector<T> buffer[width * height]; 

std::vector<T> buffer; 

होना चाहिए यह आप निश्चित रूप से पर के बजाय ऑपरेटर-भार के जोड़ सकता है() थोड़ा विस्तार - कार्य:

const T &operator()(int x, int y) const 
{ 
    return buffer[y * width + x]; 
} 

और

T &operator()(int x, int y) 
{ 
    return buffer[y * width + x]; 
} 

उदाहरण:

int main() 
{ 
    Array2D<int, 800, 800> a; 
    a(10, 10) = 50; 
    std::cout << "A(10, 10)=" << a(10, 10) << std::endl; 
    return 0; 
} 

Answer 9

या आप की तरह कुछ की कोशिश कर सकते: यह भी करने के लिए

boost::shared_array<int> zbuffer(new int[width*height]); 

तुम अब भी सक्षम होना चाहिए:

++zbuffer[0]; 

नहीं स्मृति के प्रबंधन के बारे में अधिक चिंताएं, देखभाल करने के लिए कोई कस्टम वर्ग नहीं है, और चारों ओर फेंकना आसान है।

Answer 10

यदि आप केवल एक उदाहरण की आवश्यकता है, तो आप स्थिर स्टोरेज (फ़ाइल के दायरे में, या static क्वालीफायर को फ़ंक्शन स्कोप में जोड़ें) पर सरणी आवंटित कर सकते हैं।

int array[800][800]; 

void fn() 
{ 
    static int array[800][800]; 
} 

इस तरह यह ढेर पर नहीं जाएगा, और आपको गतिशील स्मृति से निपटने की आवश्यकता नहीं है।