@printf, scanf, C++:
Genaugenommen sind es (auch) C++-Anweisungen.
C++ ist (bis auf ein paar feine Ausnahmen) eine Obermenge von C,
also C mit neuen zuätzlichen Sprachkonstrukten (wie Klassen),
ohne aber das Bestehende zu ändern
if, for, while etc. sind in C und C++ komplett gleich, printf aus C funktioniert auch in C++...
Für Dinge wie Konsolenausgabe sind bei C++ weitere Funktionen etc. dazugekommen
(die die neuen C++-Sachen wirklich ausnutzen) (schon in C ist printf bei weitem nicht das Einzige)
cout wäre sowas. Benutzt die Streamklassen von C++, die es in C nicht gibt, daher C-untauglich,
gibt aber auch nicht bessere Konsolenausgaben als printf.
"Problem" der Sache ist, dass es für viele zum guten Ton gehört,
konsequent nur C oder nur neue C++-Möglichkeiten zu verwenden
(falls man die Wahl hat natürlich)
---
Attays eindimensional, fixe Größe
sind vom Prinzip her nur mehrere int/float/etc. in einem Variablennamen, durchnummeriert
Vergleichbar mit einer Tabellenzeile.
Anlegen, für zB. 100 int, Variablenname arr:
(Durchmischen von verschiedenen Variablentypen ist so direkt nicht möglich.
Ein Array hat nur int oder nur float oder ...)
Zugriff auf die Werte geht prinzipiell wie mit einfachen int,
nur immer [] Klammern mit der Nummer dazwischen dabei
C++:
arr[27] = 0;
arr[35] = 1;
if(arr[27] == 1)
printf("Kaputt :/");
Was daran wichtig ist: Die Nummern beginnen bei 0.
Beim Anlegen gibt man die Anzahl der int an, die man haben will (
nicht die höchste Nummer)
Und für Anzahl 4 wären die zulässigen Nummern [0], [1], [2] und [3]. Genau 4 Stück.
[4] gibts nicht
. Verwenden davon liefert aber (meistens) keine Fehlermeldung,
sondern macht irgendwas seltsames unvorhersehbares.
Eventuell passiert gar nichts beim ersten Programmdurchlauf,
und beim zweiten bekommt man ein falsches Ergebnis, und beim dritten einen Absturz...
bei sowas das Problem finden kann uU. lang dauern
Beim arr[100] gehen die Nummern also von [0] bis [99]
Falls man das Array nach und nach "voller" macht muss man irgendwo
(zB. einem eigenen (separaten) int) mitspeichern, wie viel Plätze schon verbraucht sind.
Genau wie bei einzelnen int kann man beim Array nämlich nicht prüfen, ob man schon einen Wert in Nummer xy gespeichert hat. Da steht immer irgendein Wert drin,
nur ob es einer ist, den man da haben will oder einer, der von Anfang an da war...
---
Fixe Arrays mehrdimensional
Während oben eine "Tabellenzeile" war, ist jetzt hier ein Array aus Zeilen = ganze Tabelle
Einfach, indem man noch eine [] mit Größe dazutut:
Macht 4 Zeilen mit je 10 int
Zeile 0-3, jede davon hat Element 0-9
C++:
tabelle[0][0] = 1*1;
tabelle[2][2] = 3*3;
tabelle[3][9] = 4*10;
...
Was zwar oben nicht steht, aber natürlich auch bei eindim. Arrays geht:
Die Indexnummern in den [] können natürlich auch von Variablen kommen.
C++:
int i, j;
for(...)
tabelle[i][j] = (i+1)*(j+1); //+1 weil i von 0 losgeht, und man ja ein 1x1 will :)
...
Nur die Größe beim Anlegen muss eine fixe Zahl sein (variabel kommt unten gleich)
Man kann auch drei-, vier...dimensionale Array machen
C++:
int bla[2][2][2];
float blub[3][3][3][3][3][3][3];
...
Nur wie man sich das bildlich vorstellen kann (2dim = Tabelle) ...das hier gar nicht.
---
Eindimensional, variable Länge
Unterscheidet sich "nur" im Anlegen, verwendet wird es dann komplett gleich
a) Variable selbst
Ohne [größe], dafür der Stern.
Kann so noch nicht verwendet werden
b)
Eigentliches Anlegen
C++:
arr = (int *)malloc(8 * sizeof(int));
Die zwei "int" (und das bei Schritt a) können natürlich durch float etc. ersetzt werden
Die Größe ist hier 8, also 8 Stück int für arr.
Schaut hier zwar wieder fix aus, kann aber genausogut ein Variablenname dastehen,
von dem dann der Wert genommen wird.
c)
Jetzt muss überprüft werden, ob das Anlegen erfolgreich war.
Kann vorkommen, dass es nicht passt, zB. wenn man mehr anlegen wollte,
als der Computer speichern kann.
C++:
if(arr == NULL)
{
//Fehler
//zB. Ausgeben und Programm beenden
}
d)
Normal verwenden
arr[0], arr[9]...
e)
Und noch eine Neuheit: So angelegte dynamische Arrays müssen auch
wieder weggeräumt werden, geht nicht automatisch wie bei den Fixen.
Irgendwo zB. am Programamende, wenn man das Array jedenfalls nicht mehr braucht:
Eine Variable wie in a) kann auch mehrere malloc-free-Durchgänge haben
(hintereinander, nicht gleichzeitig)
---
Und
mehrdimensionale dynamische Arrays:
(in "Höhe" und "Breite" der Tabelle beides variabel) (sonst einfacher):
Anlegen mit zwei (oder mehr) * statt einem.
Und die malloc-Sache wird schleifenlastig:
Zuerst legt man ein Array aus noch nicht angelegten Arrays (Zeilen) an,
von denen dan jedes in einer Schleife wieder ein malloc erfahren muss.
Ebenso beim free.
Was noch "schöner" ist: Wenn eins der mallocs daneben geht (aus Speichermangel etc.)
muss man die bisher allokierten Sachen noch freen.
Nur genau die, für die es schon geklappt hat.
Deswegen einfach mal Code.
C++:
int zeilenanzahl, spaltenanzahl; //Werte geben, dann geht der Rest ohne Änderungen
int i; //Für Schleife
//Variable
int **array;
//Anlegen
array = (int **)malloc(zeilenanzahl * sizeof(int *));
if(array == NULL) {
printf("Fehler\n");
return; //Programmende
}
for(i = 0; i < zeilenanzahl; i++)
{
array[i] = (int *)malloc(spaltenanzahl * sizeof(int));
if(array[i] == NULL) //Bisher angelegte Zeilen und Ganzes löschen
{
for(--i; i >= 0; i--)
free(array[i]);
free(array);
printf("Fehler\n");
return;
}
}
//VERWENDEN
//array[..][...]
//Löschen
for(i = 0; i < zeilenanzahl; i++)
free(array[i]);
free(array);
---
So, für Genaueres leider grad keine Zeit (sowieso schon wieder so lang geworden
),
speziellere Erklärungen gerne später, wenn Fragen sind.
Sonst steht hier in Kap. 11, 12 und 14 auch recht viel:
http://openbook.galileocomputing.de/c_von_a_bis_z/
(auch die anderen Kapitel sind nicht schlecht
)
