2017-02-15 3 views
0

Ich versuche eine Funktion zu schreiben, die zwei Vektoren benötigt und sie abwechselnd miteinander kombiniert (dh v1 = 1,2,3 v2 = 4,5,6 würde v3 = 1,4 ergeben) , 2,5,3,6). Problem ist, wenn ich meine Funktion ausführe, bekomme ich einen Fehler, der besagt, dass die Vektor-Iteratoren nicht kompatibel sind. Aus meiner Forschung geht hervor, dass es etwas mit meiner Verwendung der Funktionen .begin() und .end() zu tun hat, aber da ich erst seit ein paar Monaten hier bin, weiß ich nicht, wie ich es beheben kann es. Hinweis: das push_back on NULL soll ein leeres Leerzeichen in dem Vektor belassen.Iteratoren Inkompatibler Fehler

Hier ist der Code:

void merge(vector<double> x, vector<double> y, vector<double>& merged) { 
    auto xStart = x.begin(); 
    auto yStart = y.begin();   

    while (xStart != x.end() && yStart != x.end()) { 
     merged.push_back(*xStart); 
     merged.push_back(*yStart); 
     ++xStart; 
     ++yStart; 
    } 
    if (xStart != x.end()) { 
     while (xStart!= x.end()) { 
      merged.push_back(*xStart); 
      merged.push_back(NULL); 
      ++xStart; 
     } 
    } 
    if (yStart != y.end()) { 
     while (yStart != y.end()) { 
      merged.push_back(*yStart); 
      merged.push_back(NULL); 
      ++yStart; 
     } 
    } 
} 
+0

'YStart! = X.end () '->' yStart! = y.end() ' –

+0

Wenn Sie Ihren Code unter einem Debugger ausführen, würden Sie feststellen, dass der Debugger die Zeile con angezeigt hat taining den Fehler –

+0

'push_back (NULL)' ist ein Fehler (kann nicht kompilieren auf neueren Compilern), verwenden Sie stattdessen 'push_back (0.0)'. Und wenn "(X) while (X)" überflüssig ist, könntest du direkt in das 'while' gehen. –

Antwort

1

Es ist ein Tippfehler

while (xStart != x.end() && yStart != x.end()) { 
             ^^^^^^ 

Es muss

while (xStart != x.end() && yStart != y.end()) { 
             ^^^^^^^ 

Und diese Aussage

merged.push_back(NULL); 
sein

macht keinen Sinn.

Auch ist es viel besser, die Funktion wie

void merge(const vector<double> &x, const vector<double> &y, vector<double>& merged); 

hier zu erklären, ist ein demonstratives Programm

#include <iostream> 
#include <vector> 

template <typename T> 
void merge(const std::vector<T> &x, 
      const std::vector<T> &y, 
      std::vector<T> &merged) 
{ 
    merged.reserve(merged.size() + x.size() + y.size()); 

    auto xStart = x.begin(); 
    auto yStart = y.begin();   

    for (; xStart != x.end() && yStart != y.end(); ++xStart, ++yStart) 
    { 
     merged.push_back(*xStart); 
     merged.push_back(*yStart); 
    } 


    for (; xStart != x.end(); ++xStart) 
    { 
     merged.push_back(*xStart); 
    } 

    for (; yStart != y.end(); ++yStart) 
    { 
     merged.push_back(*yStart); 
    } 
} 

int main() 
{ 
    std::vector<int> v1 = { 0, 2, 4, 6, 8 }; 
    std::vector<int> v2 = { 1, 3, 5, 7, 9 }; 

    std::vector<int> merged; 

    merge(v1, v2, merged); 

    for (int x : merged) std::cout << x << ' '; 
    std::cout << std::endl; 

    return 0; 
} 

Sein Ausgang ist

0 1 2 3 4 5 6 7 8 9 
+0

Danke für Ihre Hilfe! Nur aus Neugier, warum schickt man sie als Konstanten besser zur Funktion? – Sandweiche

+0

@Sandweiche Sie werden durch konstante Referenzen übergeben. Dies ermöglicht 1) das Erstellen von Kopien der Vektoren zu vermeiden und 2) sicherzustellen, dass die Quellvektoren in der Funktion nicht verändert werden. –

+0

Ich vermute, dass der ursprüngliche Code versuchte, den kürzeren Vektor, z. '{1, 2, 3} + {4} = {1, 4, 2, 0, 3, 0}' –