Ich bin neu in C++, habe vor ein kleines Programm zu schreiben und bin jetzt grade dabei mich Schritt für Schritt vor zu arbeiten.

Dabei bin ich auf zwei unerwartete Probleme gestoßen^^:

Wenn ich mein Array mit Zahlen vollschreibe, wie kann ich das in meiner Konsolenanwendung direkt zur Kontrolle ausgeben lassen? Oder muss ich mir da immer eine Schleife bauen, die mir jedes Element einzeln ausspuckt?

Und:

Wie kann ich die Array-Länge über eine Abfrage bestimmen?
Scheinbar (wenn ich den Kompilerfehler richtig interpretiere) muss die Länge des Arrays schon beim kompilieren bestimmt sein, muss ich also erst ein Array erstellen und dann nachträglich die Länge ändern?
Wenn das so ist, wie geht das denn?

Gruß Panda

Wenn ich mein Array mit Zahlen vollschreibe, wie kann ich das in meiner Konsolenanwendung direkt zur Kontrolle ausgeben lassen? Oder muss ich mir da immer eine Schleife bauen, die mir jedes Element einzeln ausspuckt?

Ja, entweder eine Schleife oder du nutzt std::copy und std::ostream_iterator.
Letzteres wäre:

#include <algorithm> // std::copy
#include <iterator>  // std::ostream_iterator
...
// Gebe alle Elemente vom Typ int von array bis array + num_elem auf std::cout aus, getrennt durch Leerzeichen
std::copy(array, array + num_elem, std::ostream_iterator<int>(std::cout, ' '));

Wie kann ich die Array-Länge über eine Abfrage bestimmen?
Scheinbar (wenn ich den Kompilerfehler richtig interpretiere) muss die Länge des Arrays schon beim kompilieren bestimmt sein, muss ich also erst ein Array erstellen und dann nachträglich die Länge ändern?
Wenn das so ist, wie geht das denn?

Das ist richtig, entweder du frickelst da manuell herum, indem du dir mit new[] dynamisch Speicher holst (nicht zu empfehlen, wenn dir dein Buch/Tutorial/whatever sagt, dass du das so machen musst, hol dir ein anderes!).
Oder du nimmst std::vector.
Aus

int array[5];

wird

std::vector<int> array(5);

(#include <vector> erforderlich)
Einen vector kannst du sogar dynamisch in der Größe anpassen (std::vector<T>::resize).

Wie kann ich die Array-Länge über eine Abfrage bestimmen?

STL-Container haben die Methode size() , die die Anzahl der momentan enthaltenen Elemente zurückgibt.
Bei dynamischen Containern (fast alle) wie vector , deque , list , usw. ist die Größe auch zur Laufzeit veränderbar. Da kannst du dann bspw. bequem per

c.push_back( i );

Ein Element dranhängen, oder per

c.pop_back();

Das letzte löschen.

muss die Länge des Arrays schon beim kompilieren bestimmt sein

Ja, bei echten Arrays schon*. Daher nimmt sich jeder, der ein dynamisches braucht, einen STL-Container.

~*: Bald - in circa einem Jahr nicht mehr. Aber dieses Geheimnis verrate ich dir nicht. Da musst du dich selbst informieren.~ :p

@Nathan: Da fehlen bei ostream_iterator noch die Template-Argumente.

Upps, vergessen.

#include <algorithm> // std::copy
#include <iterator> // std::ostream_iterator
...
// Gebe alle Element von array bis array + num_elem auf std::cout aus, getrennt durch Leerzeichen
std::copy(array, array + num_elem, std::ostream_iterator(std::cout, ' '));

Warum so kompliziert? Seit C++11 gibt es sogenannte "range based loop":

#include <iostream>

int main()
{
   int test[10] = {1,2,3,4,5,6,7,8,9,10};

   for(int& a: test)
   std::cout << a << " ";
   return 0;
}

Wie kann ich die Array-Länge über eine Abfrage bestimmen?

Garnicht, da ein Array auf dem Stack gespeichert wird und die Größe daher zur Kompilierzeit bekannt sein muss.Um also dynamischen Speicher zu bekommen musst du alles auf dem Heap speichern.Dies erreichst du mit "new".Die STL bietet dir allerdings nützliche Templateklassen(z.B. vector) wo du dich nicht darum kümmern musst(intern wird mit "new" gearbeitet).Bei weiteren Fragen stehe ich gerne zur Verfügung.

#include <iostream>

int main()
{
   int test[10] = {1,2,3,4,5,6,7,8,9,10};
   
   for(int& a: test)
   std::cout << a << " ";
   return 0;
}

Ich habe vergessen zu erwähnen, dass wenn du mit Containern arbeitest, dass du bei der for-Schleife mit auto arbeiten solltest, da dir das das Leben vereinfacht

#include <algorithm> // std::copy
#include <iterator> // std::ostream_iterator
...
// Gebe alle Element von array bis array + num_elem auf std::cout aus, getrennt durch Leerzeichen
std::copy(array, array + num_elem, std::ostream_iterator(std::cout, ' '));

Warum so kompliziert? Seit C++11 gibt es sogenannte "range based loop":

Falls der TE noch kein C++11 Support hat, wollte ich ihn nicht mit Lösungen verwirren, die bei ihm nicht funktionieren.

Taulinator schrieb:

#include <algorithm> // std::copy
#include <iterator> // std::ostream_iterator
...
// Gebe alle Element von array bis array + num_elem auf std::cout aus, getrennt durch Leerzeichen
std::copy(array, array + num_elem, std::ostream_iterator(std::cout, ' '));

Warum so kompliziert? Seit C++11 gibt es sogenannte "range based loop":

Falls der TE noch kein C++11 Support hat, wollte ich ihn nicht mit Lösungen verwirren, die bei ihm nicht funktionieren.

T'schuldigung mein Fehler...Solltest du es dennoch mit einer Schleife machen:

(Bei einem array ist die größe ja bekannt)

#include <iostream>
int main()
{
int test [9] = {1,2,3,4,5,6,7,8,9};

for(int i = 0;i<9;i++)
std::cout << test[i] << " ";
}

Solltest du es mit vector/list o.ä. machen:

#include <vector>
#include <iostream>

main()
{
int eingabe;
std::vector<int> test;
for(int i = 0; i < 10;i++)
{
std::cin >> eingabe;
test.push_back(eingabe);
}
for(std::vector<int>::iterator i = test.begin();i!=test.end();i++)
std::cout << *i;
}

muss die Länge des Arrays schon beim kompilieren bestimmt sein

Ja, bei echten Arrays schon*. Daher nimmt sich jeder, der ein dynamisches braucht, einen STL-Container.

~*: Bald - in circa einem Jahr nicht mehr. Aber dieses Geheimnis verrate ich dir nicht. Da musst du dich selbst informieren.~ :p

Sprichst du von VLA's? Ich denke, die sind totaler Schrott?

PS: std::array gibts auch noch

for(std::size_t i = 0; i != test.size();i++)
    std::cout << test[i];
}

so viel schöner zu lesen als Iterator-Syntax...

Bei vector bevorzuge ich (pr c++11)

for(std::size_t i = 0; i != test.size();i++)
    std::cout << test[i];
}

so viel schöner zu lesen als Iterator-Syntax...

Daher empfehle ich wärmstens, wenn C++11 akzeptiert wird, "auto" zu benutzen.

vector test;
for(auto i: test)
cout << i;

EDIT: Sorry hab mich beeilt habs jetzt verbessert

otze schrieb:

Bei vector bevorzuge ich (pr c++11)

for(std::size_t i = 0; i != test.size();i++)
    std::cout << test[i];
}

so viel schöner zu lesen als Iterator-Syntax...

Daher empfehle ich wärmstens, wenn C++11 akzeptiert wird, "auto" zu benutzen.

for(auto i : vector.begin())
cout << i*;

Ähm...

Daher empfehle ich wärmstens, wenn C++11 akzeptiert wird, "auto" zu benutzen.

vector test;
for(auto i: test)
cout << i;

EDIT: Sorry hab mich beeilt habs jetzt verbessert

Danke für die vielen Antworten, soweit funktionierts jetzt. Bin noch etwas am rumtüfteln.

Aber was ist denn "auto"?
Sieht ja toll aus, aber was tut es? ^^

Also fast überall, wo du initialisierst (das fast kann man doch eigentlich streichen, oder?).

auto i = 0; // int
auto f = 3.14f; // float
auto d = 3.14 // double
auto lolo = 25ll;
auto it = vec.begin(); // vector::iterator
auto s = std::sqrt(16.0);

auto fn = [](int i) {return std::vector<std::thread>(i, std::thread([](){for(auto i = 0; i < 10; ++i){std::cout << i << std::endl;}}))};

auto v = fn();

auto it = vec.begin(); // vector::iterator

Bzw. const_iterator , falls vec const ist.

struct Foo;
Foo &bla(); //Rückgabetyp Foo &
auto f = bla(); //f hat aber den Typ Foo und nicht Foo &

Hab noch eine Frage:

Und zwar möchte nach irgendeiner Regel einen Vektor füllen. Sagen wir mal mit 2er Potenzen.
Dann möchte ich den Inhalt des Vektors in einen anderen kopieren und um eine bestimmte Weite verschieben. Also z.B.:

[V1]: 1 2 4 8 16
[V2]: 4 8 16 0 0 oder 0 0 1 2 4

Ich kann mir ja für jeden Fall, also Weite <0 oder 0<, eine eigene Schleife bauen (das hab ich jetzt auch gemacht), aber das sieht ziemlich beknackt aus.

Worauf das am Ende vorerst hinauslaufen soll:

Ein oder mehrere Vektoren werden mit einer relativ beliebigen Anzahl an Werten gefüllt.
Dabei pendeln zwei Bereiche irgendwo in einem niedrigen Bereich und der dritte, mittlere enthält relativ hohe Zahlen.
Z.B.:

[V1]: 3 6 3 1 4 60 60 60 60 3 4 6 7 5

Jetzt soll die Stelle gefunden werden an dem die hohen Zahlen anfangen.

Dann kommt ein zweiter Vektor mit fast zufälligen Zahlen:

[V2]: 3 8 2 60 60 60 60 4 3 7 2 4 9 1

Jetzt möchte ich den Inhalt des V2 um 2 Stellen nach rechts verschieben damit die hohen Bereiche übereinanderliegen. Und die dadurch entstehenden Lücken mit 0 auffüllen.

Gibts da einfachere Möglichkeiten als meine Schleifenbastellei? ^^

int offset = 2;
for (size_t i = 0; i < V1.size() && i < V2.size() + offset; i++){
    tuwas(V1[i], V2[i + offset]);
}

Das mit den Ranges ist etwas anstrengend, da wird öfter mal der Index falsch sein. Du kannst dir auch mit einer Hilfsfunktion helfen:

template<class T>
T getData(const vector<T> &v, int index){ //gibt entweder v[index] zurück oder 0 wenn der Wert nicht existiert
    if (index >= 0 && index < v.size())
        return v[index];
    return 0;
}

//und dann direkt:
for (int i = 0; i < max(V1.size(), V2.size()); i++){
    tuwas(getData(V1, i), getData(V2, i + offset)); //hier darf i ein ungültiger Index sein
}

Sieht aus wie der Anfang einer Korrelationsanalyse.

Sone schrieb:

muss die Länge des Arrays schon beim kompilieren bestimmt sein

Ja, bei echten Arrays schon*. Daher nimmt sich jeder, der ein dynamisches braucht, einen STL-Container.

~*: Bald - in circa einem Jahr nicht mehr. Aber dieses Geheimnis verrate ich dir nicht. Da musst du dich selbst informieren.~ :p

Sprichst du von VLA's? Ich denke, die sind totaler Schrott?

PS: std::array gibts auch noch

VLAs Schroot? Wer erzählt soetwas? Ich finde VLAs klasse und benutze sie massiv in Code, der nur mit dem GCC übersetzt wird.
Alternative wäre alloca, das funktioniert auch mit dem MSVC.

VLAs Schroot? Wer erzählt soetwas?

U.a. ich.

Ethon schrieb:

Ich finde VLAs klasse und benutze sie massiv in Code, der nur mit dem GCC übersetzt wird.

VLA ist was für Deppen.
VLA bieten für den Fehlerfall keine Auswertemöglichkeit.
VLA lassen sich nicht initialisieren.
VLA ist C, und davon hast du dann eben keine Ahnung.
VLA ist was für Deppen.

VLA bieten für den Fehlerfall keine Auswertemöglichkeit.
VLA lassen sich nicht initialisieren.

alloca bietet für den Fehlerfall auch keine Auswertemöglichkeit
alloca lässt sich nicht initialisieren (oder genau gleich wie VLAs)

VLA bieten für den Fehlerfall keine Auswertemöglichkeit.

Im Gegensatz zu alloca? Oder meinst du zu normalen Arrays?

VLA lassen sich nicht initialisieren.

Ist ein Nachteil gegenüber welcher VLA-Alternative?

Wutz schrieb:

VLA ist was für Deppen.
VLA ist C, und davon hast du dann eben keine Ahnung.
VLA ist was für Deppen.

Tourette-Syndrom?

Elemente verschieben geht nicht effizient in einem std::vector.
Stattdessen kannst du deine Schleife leicht abändern:

*snip*

Sieht aus wie der Anfang einer Korrelationsanalyse.

Hi,
danke für das Feedback.
Ich hab das jetzt glaube ich so ähnlich gemacht, nur ohne Hilfsfunktionen.
Hab einen Index von 0 bis vector.size() laufen lassen, mit der Unterbedingung
"if(vector[i] > Grenze)break;
{
Punkt = i;
}"

Das funktioniert so weit.
Ich hab jetzt beide Vektoren mit irgendwas gefüllt, Hauptsache die beiden Vektoren hab in der Nähe einigermaßen ähnliche Werte damit das überschaubar bleibt.
Der Inhalt vom 2. Vektor wird auch wunderbar so verschoben, dass der Wert, der als erstes den eingerichteten Grenzwert überschreitet unter dem im ersten Vektor liegt.

nwp3 schrieb:

Sieht aus wie der Anfang einer Korrelationsanalyse.

Das nicht

Nächster Schritt und worauf das wirklich am Ende raus laufen soll, und dabei brauch ich noch mal Tips^^:

Mein nächster Schritt ist jetzt das ganze für 2-dimensionale Vektoren zu erweitern um den Inhalt des zweiten Vektors nicht nur nach links oder rechts, sondern auch nach oben oder unten verschieben zu können.

Um dann am Ende (und da hab ich noch Null Ahnung) ein kleines Bild einlesen zu können, die Farbwerte pro Pixel in den Vektor schreiben zu können -> einen bestimmten Farbwert finden zu können -> ein zweites Bild einlesen zu können -> dort den Farbwert ebenfalls finden zu können -> die Pixel quasi verschieben und als neues Bild abspeichern zu können, in dem dann die gesuchte Farbe auf den gleichen Koordinaten liegt.

Ich vermute das geht am besten alles ganz anders und geschickter. Aber ich hoffe mal mein Weg funktioniert auch irgendwie.

VLA bieten für den Fehlerfall keine Auswertemöglichkeit.

Einen Stackoverflow kann man meines Wissens nach generell nicht sinnvoll behandeln, ob VLA oder nicht ist da voellig wurscht.

Wutz schrieb:

VLA lassen sich nicht initialisieren.

Das einzige, wofuer ich mir bisher VLAs gewuenscht habe, sind temporaere Buffer. Und die will ich sicherlich nicht initialisiert haben.

Wutz schrieb:

VLA bieten für den Fehlerfall keine Auswertemöglichkeit.

Einen Stackoverflow kann man meines Wissens nach generell nicht sinnvoll behandeln, ob VLA oder nicht ist da voellig wurscht.

Eben nicht wurscht, denn ohne VLA würde der Stackoverflow nicht auftreten. Außer du reservierst stattdessen einfach ein riesiges statisches Array auf dem Stack, was aber einfach nur falsch wäre. Das heißt, durch das VLA baust du eine (nicht bloß rein theoretische) Quelle für einen unbehandelbaren Fehler in das Programm ein.

Ethon schrieb:

VLAs Schroot? Wer erzählt soetwas?

U.a. ich.

Ok.

Wutz schrieb:

VLA ist was für Deppen.

Ok.

Wutz schrieb:

VLA bieten für den Fehlerfall keine Auswertemöglichkeit.

Ich programmiere keine Fehler.

Wutz schrieb:

VLA lassen sich nicht initialisieren.

Mir egal, ich schaffe soetwas auch ohne Syntax Sugar.

Wutz schrieb:

VLA ist C, und davon hast du dann eben keine Ahnung.

Ok.

Wutz schrieb:

VLA ist was für Deppen.

Ok.