Wie kann ich meinen Stack nicht überlaufen lassen?

Question

Ich erwarte, dass die Ausgabe:

acej

, die mit diesem Algorithmus funktioniert gut, aber es ist ein Problem, mit dem Ergebnis ausgibt und dieses Problem verursacht Stapel überlaufen.

Wie behebe ich es?

#include <iostream> 
#include <vector> 

std::vector<char> charAt(std::vector<char> str) 
{ 
    std::vector<char> result; 
    result.resize(str.size()); 

    for (int i = 0; i < str.size(); i++) 
    { 
     if (i % 2 == 0) 
     { 
      for (int j = 0; j < str.size(); j++) 
      { 
       if (result[j] == '\0') 
       { 
        result[j] = str[i]; 
        break; 
       } 
      } 
     } 
    } 
    return result; 
} 

std::ostream& operator<<(std::ostream& stream, std::vector<char> vector) 
{ 
    stream << "Vector: " << vector << std::endl; 
    return stream; 
} 

int main() { 
    std::vector<char> foo = { 'a', 'b','c','d','e','f','j' }; 
    std::vector<char> bar = charAt(foo); 
    std::cout << bar << std::endl; 
} 

Answer 1

Werfen wir einen genaueren Blick auf die Ausgabe Betreiber nehmen:

std::ostream& operator<<(std::ostream& stream, std::vector<char> vector) 
{ 
    stream << "Vector: " << vector << std::endl; 
    return stream; 
} 

Es heißt, wenn Sie die Ausgabe ein std::vector<char>. Es wird dann eine std::vector<char> ausgeben, die einen rekursiven Aufruf verursacht, und so weiter im Unendlichen (oder bis Sie einen Stapelüberlauf bekommen).

Was Ihr Ausgabeoperator benötigt, ist Iterieren über den Vektor und jedes Element ausgeben.

---

Zu einem nicht verwandten Hinweis, übergeben Sie nicht den Vektor nach Wert für die Funktion. Statt eine konstante Referenz verwenden:

std::ostream& operator<<(std::ostream& stream, std::vector<char> const& vector) { ... } 

Answer 2

Nun, Ihr operator<< ist nicht nur nutzlos (da es tut nichts anderes als die gleiche Codezeile wickeln, die Sie in main sowieso), aber es ist auch selbst rekursiv aufrufen, so dass Sie erhalten ein SO schließlich:

std::ostream& operator<<(std::ostream& stream, std::vector<char> vector) 
{ 
    stream << "Vector: " << vector << std::endl; 
         \__________/ 
           ^
           | 
          recursion right here 
    return stream; 
} 

Sie wahrscheinlich auch so etwas wie

std::ostream& operator<<(std::ostream& stream, std::vector<char> vector) 
{ 
    stream << "Vector: " << std::endl; 
    for(size_t i = 0; i < vector.size(); ++i) 
     stream << vector[i] << " "; 
    stream << std::endl; 
    return stream; 
} 

möchten Ihre charAt b könnte e verbessert:

std::vector<char> charAt(const std::vector<char> & str) 
{ 
    std::vector<char> result; 

    for (size_t i = 0; i < str.size(); i++) 
    { 
     if (i % 2 == 0) 
     { 
      result.push_back(str[i]); 
     } 
    } 
    return result; 
} 

Answer 3

Haben Sie die Absicht, stattdessen std::string zu verwenden und verwendet falsche STL-Container.

#include <iostream> 

std::string charAt(std::string str) 
{ 
    std::string result; 
    result.resize(str.size()); 

    for (int i = 0; i < str.size(); i++) 
    { 
     if (i % 2 == 0) 
     { 
      for (int j = 0; j < str.size(); j++) 
      { 
       if (result[j] == '\0') 
       { 
        result[j] = str[i]; 
        break; 
       } 
      } 
     } 
    } 
    return result; 
} 

int main() { 
    std::string foo = { 'a', 'b', 'c', 'd', 'e', 'f', 'j' }; 
    std::string bar = charAt(foo); 
    std::cout << bar << std::endl; 
} 

Ausgabe

acej