मुझे a.txt में १००, २००, ३०० योग करना है

a.txt

2323|A|5|0|2|100
2424|B|6|1|3|200
2525|C|7|2|4|300

इसलिए मैंने इस फ़ाइल को खोला, और गेटलाइन (), और टोकनयुक्त का उपयोग करके लाइन से लाइन को पढ़ा।

main.cpp

for (std::string each; std::getline(split, each, split_char); tokens.push_back(each)) {
        for (int i = 0; i < tokens.size(); i++) {
                std::cout << tokens[i] << std::endl;
                tokens.pop_back();
        }
}

जैसा कि अपेक्षित था, वह कोड सभी चीजों में से एक ही छपा। इसलिए मैंने मूल्यों का योग करने के लिए टोकन इंडेक्स का उपयोग करने के बारे में सोचा। लेकिन मेरे कोड में त्रुटि है। "वेक्टर सबस्क्रिप्ट सीमा से बाहर" या कोई संकलन नहीं।

पहले प्रयास करें

for (std::string each; std::getline(split, each, split_char); tokens.push_back(each)) {
        for (int i = 0; i < tokens.size(); i++) {
                std::cout << tokens[i] << std::endl;
                tokens.pop_back();

                std::cout << tokens[5] << std::endl;
                std::cout << tokens[11] << std::endl;
                std::cout << tokens[17] << std::endl;

                int a = 0;
                int b = 0;
                int c = 0;
                int sum = 0;

                a = stoi(tokens[5]);
                b = stoi(tokens[11]);
                c = stoi(tokens[17]);

                sum = (a + b + c);
                std::cout << sum << std::endl;      
        }
}

दूसरा प्रयास

for (std::string each; std::getline(split, each, split_char); tokens.push_back(each)) {
    if(tokens.size() > 4) {
        for (int k = 0; k < ((tokens.size() - 5) / 6) + 1; k++) {
                int sum = 0;
                int change = 0;
                int j = 0;
                j = 6 * k + 5;
                change = stoi(tokens[j]);
                sum += change;
                std::cout << sum << std::endl;
                tokens.pop_back();
        }
    }
}

मुझे योग मूल्य क्या करना चाहिए? और मैं सोच रहा हूं कि "आकार" को छोड़कर टोकन। आकार () का अर्थ है क्योंकि कथन के लिए दूसरा हमेशा एक त्रुटि प्राप्त करता है यदि मैं बिल्कुल सही नहीं कर रहा हूं

c++
0
serin 23 अक्टूबर 2020, 19:07

2 जवाब

सबसे बढ़िया उत्तर

आप tokens वेक्टर को संशोधित कर रहे हैं, जबकि आप इसके माध्यम से लूप कर रहे हैं। ऐसा मत करो। आप इसके size() को प्रभावित कर रहे हैं, जिसके कारण आप सीमा से बाहर जाने में सक्षम हैं।

आप कहते हैं कि आपको प्रत्येक पंक्ति के केवल अंतिम टोकन का योग करना होगा। लेकिन वह नहीं है जो आपका कोड करने की कोशिश कर रहा है। आंतरिक for लूप की बिल्कुल भी आवश्यकता नहीं है। बस प्रत्येक पंक्ति को एक स्थानीय tokens वेक्टर में विभाजित करें और फिर अंतिम टोकन प्राप्त करने के लिए tokens.back() का उपयोग करें, जैसे:

std::string line;
int sum = 0;

while (std::getline(inFile, line))
{
    std::istringstream iss(line);
    std::vector<std::string> tokens;
    std::string token;

    while (std::getline(iss, token, '|')) {
        tokens.push_back(token);
    }

    // use tokens as needed...

    token = tokens.back();
    sum += std::stoi(token);
}

std::cout << sum << std::endl;      

लाइव डेमो

1
Remy Lebeau 23 अक्टूबर 2020, 19:55

मैं अपने कोड को थोड़ा अलग तरीके से तैयार करना चाहता हूं।

मुख्य फ़ंक्शन में सब कुछ करने और करने के बजाय अपने कोड को विभाजित करें ताकि आप प्रत्येक पंक्ति को पढ़ सकें और सत्यापित कर सकें कि यह सही है:

#include <iostream>                                                                                    
#include <string>                                                                                      
                                                                                                       
// A structure representing the data we want to parse.                                                 
struct DataLine                                                                                        
{                                                                                                      
    int     v1;                                                                                        
    char    c;                                                                                         
    int     v2;                                                                                        
    int     v3;                                                                                        
    int     v4;                                                                                        
    int     v5;                                                                                        
                                                                                                       
    // An input operator that will read one line of data.                                              
    // If the data is valid will update the variable we are reading into.                              
    friend std::istream& operator>>(std::istream& str, DataLine& data)                                 
    {                                                                                                  
        DataLine    tmp;                                                                               
        char        s[5];                                                                              
        std::string extra;                                                                             
                                                                                                       
        if (   str >> tmp.v1 >> s[0] && s[0] == '|'                                                    
            && str >> tmp.c  >> s[1] && s[1] == '|'                                                    
            && str >> tmp.v2 >> s[2] && s[2] == '|'                                                    
            && str >> tmp.v3 >> s[3] && s[3] == '|'                                                    
            && str >> tmp.v4 >> s[4] && s[4] == '|'                                                    
            && str >> tmp.v5                                                                           
            && std::getline(str, extra) && extra.empty())                                              
        {                                                                                              
            // all the data was read and the line was valid.                                           
            // update the correct variable.                                                            
            swap(tmp, data);                                                                           
        }                                                                                              
        else {                                                                                         
            // there was an issue.                                                                     
            // set the stream to bad so that reading will stop.                                        
            str.setstate(std::ios::badbit);                                                            
        }                                                                                              
        return str;                                                                                    
    }                                                                                                  
    // Standard swap method.                                                                           
    friend void swap(DataLine& lhs, DataLine& rhs) noexcept                                            
    {                                                                                                  
        using std::swap;                                                                               
        swap(lhs.v1, rhs.v1);                                                                          
        swap(lhs.c , rhs.c );                                                                          
        swap(lhs.v2, rhs.v2);                                                                          
        swap(lhs.v3, rhs.v3);                                                                          
        swap(lhs.v4, rhs.v4);                                                                          
        swap(lhs.v5, rhs.v5);                                                                          
    }                                                                                                  
};                                                                                                     

फिर डेटा को पढ़ने के लिए आप जिस लूप का उपयोग करते हैं, वह वास्तव में लागू करने के लिए तुच्छ हो जाता है।

int main()                                                                                             
{                                                                                                   
    DataLine    data;                                                                               
    int         sum = 0;                                                                            
    // Now we can read the data in a simple loop.                                                   
    while(std::cin >> data) {                                                                       
        sum += data.v5;                                                                             
    }                                                                                               
    std::cout << "Sum: " << sum << "\n";                                                            
}     
1
Martin York 23 अक्टूबर 2020, 19:33