nun habe ich eine frage:
wie kann ich einen array erstellen welches automatisch immer wieder verlängert wird?

bis jetzt sieht die eingabe fkt so aus

int test[9];

    for(int i=0;i<9;i++)
    {
            cin>> test[i];
    }
...

wie kann ich das array so verändern das es dynamisch immer länger wird?

mfg

Dynamisch kannst du ein Array auch mit realloc vergrößern, das ist weder so schön noch so komfortabel und gegen Programmierfehler geschützt wie std::vector::push_back.

Beispiel:

#include <iostream>
#include <vector>
int main()
{
    std::vector<int> zahlen;
    std::cout << zahlen.size(); // ausgabe: 0
    // hinzufügen
    zahlen.push_back(45);
    zahlen.push_back(42);
    std::cout << zahlen.size(); // ausgabe: 2
}

oder kann man das irgendwie so programmieren,das es bis man z.b. enter drück alles einließt was man hinschreibt leerzeichen würde dann nächstes element bedeuten

an pushback hatte ich auch schon gedacht,nur da is die eingabe nicht so kompfortabel,da ich nach jedem wert enter drücken muss,oder?

Das ist doch bei Deinem Code oben genauso, und das hat nichts mit dem Datencontainer zu tun sondern mit der C++-Eingabe.

man kann bei der eingabe von mir die werte alle nacheinander getrennt mit leerzeichen eingeben

Ja, und wieso soll das bei der Verwendung von 'std::vector' bitte nicht mehr gehen?

bis jetzt hab ichs so

for(int i=0;i<4;i++)
{
    cin>> wert;

    zahlen.push_back(wert);
}

nur die anzahl der durchläufe müsste dynamisch sein
kann mir da wer helfen?

mfg

hab da schon ne fkt gefunden die eventuell helfen könnte
GetAsyncKeyState(int vKey)

die Zahl in klammern steht für enter
VK_RETURN (0D)
ENTER key

hab das jetzt so eingebunden

while(GetAsyncKeyState() != 0D )
{
      cin >> wert;
    zahlen.push_back(wert);
}

nur meckert der compiler da bei der fkt

mfg

Die einfachste Variante ist wohl, einen String einzulesen und auseinanderzunehmen:

int main() {
    string line;
    getline(cin, line);

    stringstream sstr;
    sstr << line;

    int zahl;
    vector<int> zahlen;

    while (sstr >> zahl)
        zahlen.push_back(zahl);
}

#include<string>
#include<stringstream>

//eine zeile bis <Enter> einlesen
std::string str;
std::getline(std::cin,str);

//Die eingelesene Zeile in einen anderen stream packen
std::stringstream stream;
stream<<str;

//und nun aus diesem stream lesen
while (stream >> wert)
    zahlen.push_back(zahl);

@Konrad rofl. identisch

mfg

Der Header heißt komischerweise <sstream>.

da vertue ich mich ohne compiler immer :). Gibt auch einen header <strstream> für die Klasse strstream, und damit ist für mich die verwirrung komplett

mal noch nee kleine informative frage
warum werden die eingelesenen werte in einen anderen string kopiert?

und warum steht einmal im quelltext std:: davor und einmal nicht?

mfg

int tmp;
vector v;

while (cin >> tmp)
{
   v.push_back(tmp);
   char c = cin.get();
   if (c == '\n') break;
   else cin.putback(c);
}

sollte statt des stringstreams auch reichen.

mfg

hab das jetzt mal so versucht,das man so lange neue zeilen eingeben kann bis der wert 999 eingegebene wird
nur das is ja keine richtige lösung
wie kann ich es machen das die eingabe beendet wird wenn ich zum beispiel e drücke oder wenn ich enter drücke und vorher keinen wert eingegeben habe

int tmp;

while(tmp != 999)
{
while (cin >> tmp)
{
   m1 >> tmp; //ist von meiner überladenen >> fkt,der wert wird dort direkt in ne zeile geschrieben
   char c = cin.get();
   if (c == '\n')
   {
   m1 >> nz; //auch vom überladenen operator,erstelt einen neuen zeilenvektor
   break;
}
   else cin.putback(c);
}
}

vll hat noch wer ne gute idee für den abbruch

EDIT
hab selber noch eine

while(tmp != NULL && c != '\n')

falls das NULL nicht geht kann mir wer sagen was da stehen muss wenn noch kein wert eingegeben wurde

mfg

mal noch nee kleine informative frage
warum werden die eingelesenen werte in einen anderen string kopiert?

Wie du festgestellt hast, terminiert

while(cin>>wert)
{...}

nicht so ohne weiteres. das liegt daran, dass cin solange einliest, wie wir daten erfragen, und solange wir daten erfragen, bittet cin um Benutzereingaben. Wie du gemerkt hast, ist das nicht so toll, der standardweg um dies abzubrechen ist nämlich das zeichen '\0' einzugeben. Dies ist das End of file zeichen. liest cin das, setzt es das eof flag, und die schleife bricht ab.

Wir umgehen diesen mechanismus jetzt, indem wir einfach nur eine ganze zeile bis zum '\n' zeichen einlesen, also bis der benutzer das erste mal enter drückt.
das funktioniert mit getline. Danach kopieren wir diesen string in einen stringstream und stringstream bricht ab, sobald der interne stringpuffer leer ist(also der ganze zeicheninhalt ausgelesen wurde). Deshalb kopieren wir den string

und warum steht einmal im quelltext std:: davor und einmal nicht?

Ich hab std:: angegeben weil ich kein

using namespace std;

in meinem Code hab, und deswegen den namespace separat angebe(und ich machs ausserdem aus gewohnheit).

Nebenbei ist die Lösung mit

if (c == '\n')

nicht ganz so sicher, da du dann davon abhängst, dass der nutzer nahc der letzten zahl sofort <Enter> drückt, und nicht vorher zb noch <Leerzeichen>.
Würdest du das zum Beispiel später mit einer Datei machen(also daten aus der datei lesen), dann hättest du das Problem, dass unter Windows am Ende jeder Zeile ein "\r\n" steht, und nicht nur '\n'.

zu deiner Frage:
Wenn du einfach nur bei einer "999" abbrechen willst, reicht doch einfach

int tmp;
cin>>tmp;
while(tmp!=999)
{
    //tu was mit tmp
    //...
    cin>>tmp;
}

oder wenn die Schleife abbrechen soll, wenn der benutzer einfach nur was anderes als eine zahl eingibt:

while(cin>>tmp)
{
    //tu was mit tmp
}

also dein ursprungscode

999 würde da gehen ist aber nicht sehr sinnvoll falls mal ein user 999 verwenden will

gibt es nicht ne andere möglichkeit...z.b. ne bedingung wenn der verctor 0 elemte hat u man enter drück dann bricht es die eingabe ab

int help=1;

while(help != 0)
{
    string line;               
    getline(cin, line);

    stringstream sstr;
    sstr << line;

    double wert;
    vector<double> zeile;

    while (sstr >> wert)
    {
        zeile.push_back(wert);
    }

help=zeile.size();
}

mfg

EDIT:
nach einigen testen bin ich nun drauf gekommen,das die string methode doch kommazahlen lesen kann,nur leider kann sie nur zahlen mit insgesamt max 6 stellen länge auslesen...kann man die fkt irgendwie noch verbessern das sie z.b. auch zahlen mit 10 stellen oder mehr auslesen kann

mfg