Wie man zu einem Vektor cin

Sie lesen also nur eine einzelne Ganzzahl und schieben sie in Ihren Vektor. Da Sie wahrscheinlich mehrere ganze Zahlen speichern möchten, benötigen Sie eine Schleife. Zum Beispiel ersetzen

cin >> input;
V.Push_back(input);

mit

while (cin >> input)
    V.Push_back(input);

Was dabei geschieht, ist, solange es Eingaben gibt, die man packen muss, kontinuierlich von Cin zu ziehen; Die Schleife wird fortgesetzt, bis cin EOF findet oder versucht, einen nicht ganzzahligen Wert einzugeben. Die Alternative ist die Verwendung eines Sentinel-Werts. Dies verhindert jedoch, dass Sie diesen Wert tatsächlich eingeben. Ex:

while ((cin >> input) && input != 9999)
    V.Push_back(input);

liest, bis Sie versuchen, 9999 einzugeben (oder einen der anderen Zustände, die cin ungültig machen). An diesem Punkt wird die Schleife beendet.

Bei anderen Antworten können Sie eine bestimmte Nummer nicht zulassen oder den Benutzer anweisen, etwas Nicht-Numerisches einzugeben, um die Eingabe zu beenden. Eine bessere Lösung ist vielleicht die Verwendung von std::getline(), um eine Zeile der Eingabe zu lesen, und dann mit std::istringstream alle Zahlen aus dieser Zeile in den Vektor einlesen.

#include <iostream>
#include <sstream>
#include <vector>

int main(int argc, char** argv) {

    std::string line;
    int number;
    std::vector<int> numbers;

    std::cout << "Enter numbers separated by spaces: ";
    std::getline(std::cin, line);
    std::istringstream stream(line);
    while (stream >> number)
        numbers.Push_back(number);

    write_vector(numbers);

}

Ihre write_vector()-Implementierung kann auch durch einen idiomatischeren Aufruf des std::copy()-Algorithmus ersetzt werden, um die Elemente in einen std::ostream_iterator nach std::cout zu kopieren:

#include <algorithm>
#include <iterator>

template<class T>
void write_vector(const std::vector<T>& vector) {
    std::cout << "Numbers you entered: ";
    std::copy(vector.begin(), vector.end(),
        std::ostream_iterator<T>(std::cout, " "));
    std::cout << '\n';
}

Sie können auch std::copy() und ein paar praktische Iteratoren verwenden, um die Werte ohne explizite Schleife in den Vektor zu übernehmen:

std::copy(std::istream_iterator<int>(stream),
    std::istream_iterator<int>(),
    std::back_inserter(numbers));

Aber das ist wahrscheinlich übertrieben.

Dafür brauchst du eine Schleife. Also mach das:

while (cin >> input) //enter any non-integer to end the loop!
{
   V.Push_back(input);
}

Oder verwenden Sie diese idiomatische Version:

#include <iterator> //for std::istream_iterator 

std::istream_iterator<int> begin(std::cin), end;
std::vector<int> v(begin, end);
write_vector(v);

Sie könnten auch Ihren write_vector verbessern:

 #include <algorithm> //for std::copy

template <typename T>
void write_vector(const vector<T>& v)
{
   cout << "The numbers in the vector are: " << endl;
   std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
}

sie haben 2 Möglichkeiten:

Wenn Sie wissen, wie groß der Vektor sein wird (in Ihrem Fall/Beispiel scheint es, dass Sie es wissen):

vector<int> V(size)
for(int i =0;i<size;i++){
    cin>>V[i];
 }

wenn dies nicht der Fall ist und Sie es nicht in Ihren Programmfluss bringen können, dann:

int helper;
while(cin>>helper){
    V.Push_back(helper);
}

One-Liner zum Einlesen einer fixed Anzahl von Zahlen in einen Vektor (C++ 11)

#include <algorithm>
#include <iterator>
#include <iostream>
#include <vector>
#include <cstddef>

int main()
{
    const std::size_t LIMIT{5};
    std::vector<int> collection;

    std::generate_n(std::back_inserter(collection), LIMIT,
        []()
        {
            return *(std::istream_iterator<int>(std::cin));
        }
    );

    return 0;
}

Sie brauchen eine zweite ganze Zahl.

int i,n;
vector<int> V;
cout << "Enter the amount of numbers you want to evaluate: ";
cin >> i;
cout << "Enter your numbers to be evaluated: " << endl;
while (V.size() < i && cin >> n){
  V.Push_back(n);
}
write_vector(V);
return 0;

cin ist auf Leerzeichen begrenzt. Wenn Sie also versuchen, "1 2 3 4 5" in eine einzelne Ganzzahl zu konvertieren, weisen Sie der Ganzzahl nur 1 zu. Eine bessere Option ist, Ihre Eingabe und Push_back in eine Schleife zu packen Lassen Sie es auf einen Sentinel-Wert testen, und rufen Sie auf diesem Sentinel-Wert Ihre Schreibfunktion auf. sowie

int input;
cout << "Enter your numbers to be evaluated, and 10000 to quit: " << endl;
while(input != 10000) {
    cin >> input;
   V.Push_back(input);
}
write_vector(V);

Sie können dies einfach mit Hilfe von for loop tun
-> Fragen Sie zur Laufzeit nach einem Benutzer (wie viele Eingaben er eingeben möchte) und die gleichen Arrays behandeln.

int main() {
        int sizz,input;
        std::vector<int> vc1;

        cout<< "How many Numbers you want to enter : ";
        cin >> sizz;
        cout << "Input Data : " << endl;
        for (int i = 0; i < sizz; i++) {//for taking input form the user
            cin >> input;
            vc1.Push_back(input);
        }
        cout << "print data of vector : " << endl;
        for (int i = 0; i < sizz; i++) {
            cout << vc1[i] << endl;
        }
     }

#include<iostream>
#include<vector>
#include<string>
using namespace std;
int main()
{
    vector<string>V;
    int num;
    cin>>num;
    string input;
    while (cin>>input && num != 0) //enter any non-integer to end the loop!
{
    //cin>>input;
   V.Push_back(input);
   num--;
   if(num==0)
   {
   vector<string>::iterator it;
    for(it=V.begin();it!=V.end();it++)
        cout<<*it<<endl;
   };

}
return 0;

};

Sie möchten wahrscheinlich mehr Zahlen einlesen, nicht nur eine Dazu benötigen Sie eine Schleife

int main()
{
  int input = 0;
  while(input != -1){
    vector<int> V;
    cout << "Enter your numbers to be evaluated: " << endl;
    cin >> input;
    V.Push_back(input);
    write_vector(V);
  }
  return 0;
}

Beachten Sie, dass es in dieser Version nicht möglich ist, die Zahl -1 hinzuzufügen, da es sich um das "Endsignal" handelt. Geben Sie die Nummern so oft ein, wie Sie möchten. Sie werden abgebrochen, wenn Sie -1 eingeben.

#include<iostream>
#include<vector>
#include<sstream>
using namespace std;

int main()
{
    vector<string> v;
    string line,t;
    getline(cin,line);
    istringstream iss(line);
    while(iss>>t)
        v.Push_back(t);

    vector<string>::iterator it;
    for(it=v.begin();it!=v.end();it++)
        cout<<*it<<endl;
    return 0;
}

In diesem Fall sieht Ihre while-Schleife so aus 

int i = 0;
int a = 0;
while (i < n){
  cin >> a;
  V.Push_back(a);
  ++i;
}

Das anfängliche size() von V ist 0, während int n zufällige Werte enthält, da Sie es nicht initialisieren. 

V.size() < n ist wahrscheinlich falsch. </ S>

Dumme mich vermisst den "Enter the amount of numbers you want to evaluate: "

Wenn Sie eine n eingeben, die zu diesem Zeitpunkt kleiner als V.size() ist, wird die Schleife beendet.

Fügen Sie einfach eine weitere Variable hinzu.

int temp;
while (cin >> temp && V.size() < n){
    V.Push_back(temp);
}

wäre einfacher, wenn Sie die Größe des Vektors durch Eingabe einer Eingabe angeben:

int main()
{
  int input,n;
  vector<int> V;
  cout<<"Enter the number of inputs: ";
  cin>>n;
  cout << "Enter your numbers to be evaluated: " << endl;
  for(int i=0;i<n;i++){
  cin >> input;
  V.Push_back(input);
  }
  write_vector(V);
  return 0;
}