एक दो आयामी एसटीडी :: वेक्टर की शुरुआत

Question

तो, मेरे पास निम्नलिखित हैं:

std::vector< std::vector <int> > fog;

और मैं इसे बहुत भोलेपन से शुरू कर रहा हूं:

    for(int i=0; i<A_NUMBER; i++)
    {
            std::vector <int> fogRow;
            for(int j=0; j<OTHER_NUMBER; j++)
            {
                 fogRow.push_back( 0 );
            }
            fog.push_back(fogRow);
    }

और यह बहुत गलत लगता है ... क्या इस तरह एक वेक्टर को शुरू करने का एक और तरीका है?

Comments

यदि आप से अधिक स्थान की आवश्यकता नहीं है, तो मैं 2d वेक्टर के लिए 1d वेक्टर कार्यान्वयन की सिफारिश करूंगा std::vector<int>::max_size()। यहाँ

— andre

यह अच्छा होता अगर कम से कम एक उत्तर में आंतरिक वेक्टर की नकल करना शामिल नहीं होता: मेमसेसी मेम्पी (और कॉलक और भी बेहतर होता अगर ऑपरेटर नया इनलाइन होता)।

— मार्क ग्लिससे

Answer 1

उस std::vector::vector(count, value)निर्माता का उपयोग करें जो प्रारंभिक आकार और डिफ़ॉल्ट मान स्वीकार करता है:

std::vector<std::vector<int> > fog(
    A_NUMBER,
    std::vector<int>(OTHER_NUMBER)); // Defaults to zero initial value

यदि शून्य के अलावा कोई मान, 4उदाहरण के लिए कहें , तो डिफ़ॉल्ट होना आवश्यक था:

std::vector<std::vector<int> > fog(
    A_NUMBER,
    std::vector<int>(OTHER_NUMBER, 4));

मुझे यह भी उल्लेख करना चाहिए कि यूनिफ़ॉर्म इनिशियलाइज़ेशन को C ++ 11 में पेश किया गया था, जो कि vector, और अन्य कंटेनरों के उपयोग की अनुमति देता है {}:

std::vector<std::vector<int> > fog { { 1, 1, 1 },
                                    { 2, 2, 2 } };

Comments

क्या होगा यदि मैं के std :: vector <std :: vector <int>>रूप में भंडारण वर्ग बनाते हैं static?

— स्ट्राइकरैप्स

Answer 2

मान लें कि आप 2D वेक्टर को आरंभ करना चाहते हैं, m * n, जिसका प्रारंभिक मान 0 है

हम ऐसा कर सकते थे

#include<iostream>
int main(){ 
    int m = 2, n = 5;

    vector<vector<int>> vec(m, vector<int> (n, 0));

    return 0;
}

Comments

बस इसी जवाब की वजह से 'अच्छा जवाब' कमाया। अन्य लोगों ने पहले से ही एक ही उत्तर दिया था, लेकिन जो लोग इसे अपवोट करते हैं, वे इस पद पर आते ही मेरे जैसे हो सकते हैं, कि हम यह नहीं पहचान पाए कि कुछ अन्य उत्तर वास्तव में एक ही उत्तर हैं। मुझे लगता है कि यह तीन कारण हो सकता है: 1) इस कोड को कॉपी किया जा सकता है, चिपकाया जा सकता है, और तुरंत 2 चला जा सकता है) std::यह अधिक लंबा हो जाता है और लोगों को छोटा और सीधा उत्तर पसंद आ सकता है; 3) चर भ्रमित करने वालों का लंबा नामकरण शुरुआती। मैं एक शुरुआत भी कर रहा हूं, वास्तव में यह नहीं जानता कि हमें कितना महत्वपूर्ण चाहिए std::, एक कोड की आवश्यकता है , इसलिए मुझे पता है कि प्रत्येक चर क्या करता है

— जेसन

Answer 3

इसमें कोई appendविधि नहीं है std::vector, लेकिन यदि आप वेक्टर युक्त A_NUMBERवैक्टर बनाना चाहते हैं int, जिनमें से प्रत्येक में other_numberशून्य हैं, तो आप यह कर सकते हैं:

std::vector<std::vector<int>> fog(A_NUMBER, std::vector<int>(OTHER_NUMBER));

Answer 4

सामान्य सिंटैक्स, जैसा कि पहले से ही दर्शाया गया है:

std::vector<std::vector<int> > v (A_NUMBER, std::vector <int> (OTHER_NUMBER, DEFAULT_VALUE))  

यहां, वेक्टर 'v' को दो आयामी सरणी के रूप में देखा जा सकता है, 'A_NUMBER' पंक्तियों के साथ, स्तंभों के 'OTHER_NUMBER' के साथ उनके प्रारंभिक मान 'DEFAULT_VALUE' पर सेट किए जाते हैं।

यह भी इस तरह लिखा जा सकता है:

std::vector <int> line(OTHER_NUMBER, DEFAULT_VALUE)
std::vector<std::vector<int> > v(A_NUMBER, line)

2-डी वेक्टर में इनपुट मानों को 2-डी सरणी में इनपुट मान के समान है:

for(int i = 0; i < A_NUMBER; i++) {
     for(int j = 0; j < OTHER_NUMBER; j++) {
         std::cin >> v[i][j]
     }
}

अन्य उत्तरों में उदाहरण पहले ही बताए जा चुके हैं ....!

Answer 5

मुझे लगता है कि इसे करने का सबसे आसान तरीका है:

std::vector<std::vector<int>>v(10,std::vector<int>(11,100));

10 बाहरी या वैश्विक वेक्टर का आकार है, जो मुख्य एक है, और 11 आंतरिक प्रकार के आंतरिक वेक्टर का आकार है, और प्रारंभिक मान 100 से शुरू होते हैं! यह स्टैक पर मेरी पहली मदद है, मुझे लगता है कि यह किसी की मदद करता है।

Answer 6

मान लीजिए आप एन पंक्तियों और मीटर स्तंभ प्रत्येक के मूल्य 'के साथ एक दो आयामी पूर्णांक वेक्टर प्रारंभ करना चाहते हैं VAL ' है

इसे लिखें

std::vector<vector<int>> arr(n, vector<int>(m,VAL));

यह वैल एक पूर्णांक प्रकार चर या स्थिर हो सकता है जैसे कि 100

Answer 7

दिए गए डिफ़ॉल्ट मान के साथ द्वि-आयामी वेक्टर को आरंभ करने के लिए फिल्ड कंस्ट्रक्टर का उपयोग करने के लिए अनुशंसित दृष्टिकोण है:

std::vector<std::vector<int>> fog(M, std::vector<int>(N, default_value));

जहाँ, M और N आपके 2D वेक्टर के आयाम हैं।

Answer 8

के साथ c++ STLआरंभ करने के लिए मेरा कोड5*3 2-D vectorzero

#include <iostream>
using namespace std;
#include <vector>
int main()
{// if we wnt to initialise a 2 D vector with 0;

    vector<vector<int>> v1(5, vector<int>(3,0));

    for(int i=0;i<v1.size();i++) 
{
        for(int j=0;j<v1[i].size();j++)

           cout<<v1[i][j]<<" ";

            cout<<endl;
    }
}