2 Anfänger Fragen: Array und Dev C++

[tobee]

Hallo,

ich habe ein paar grundlegende Fragen zu C++. Speziell Dev C++.

int main (int argc, char *argv[])
{
int tage1[4] = { 1, 2, 3, 4 };
int tage2[3] = { 5, 6, 7 };
int tage[2] = { tage1, tage2 };
}

Meine Fragen:
1. Wieso macht Dev C++ immer diese Zeile mit rein: int argc, char *argv[].
2. Ist diese Zeile überhaupt richtig?: int tage[2] = { tage1, tage2 };

Schonmal Danke, Tobee

 

[deepthroat]

Hi.

Hallo,

ich habe ein paar grundlegende Fragen zu C++. Speziell Dev C++.

int main (int argc, char *argv[])
{
int tage1[4] = { 1, 2, 3, 4 };
int tage2[3] = { 5, 6, 7 };
int tage[2] = { tage1, tage2 };
}

Meine Fragen:
1. Wieso macht Dev C++ immer diese Zeile mit rein: int argc, char *argv[].

So kann man auf die Parameter die dem Programm beim Start übergeben wurden zugreifen. Z.B. wenn dein Programm "test.exe" heißt, und du es von der Eingabeaufforderung mit "test.exe 1 2 hallo" aufrufst, dann ist in argc der Wert 4 (= Anzahl der Argumente im Array argv) gespeichert und argv hat den Wert { "test.exe", "1", "2", "hallo" }.

2. Ist diese Zeile überhaupt richtig?: int tage[2] = { tage1, tage2 };

Das kommt drauf an was du damit bezwecken willst. Willst du das tage Array mit den Adressen der Arrays tage1 und tage2 (implizit in einen int gecastet) initialisieren, dann ist es richtig. Der Compiler spuckt allerdings nicht ohne Grund die Warnung: "initialization makes integer from pointer without a cast" aus. Höchstwahrscheinlich ist es nicht ganz das was du möchtest.

Gruß

 

[jokey2]

1.

int main (int argc, char *argv[])

Das ist die Standard-Funktionsdefinition der C-Mainfunktion. Die Argumente können weggelassen werden, wenn man sie nicht braucht. Sie enthalten die Anzahl der Kommandozeilenargumente (argc) und das Array mit den Kommandozeilenargumenten (argv[]).
2. Ich denke, es müßte

int* tage[2] = { tage1, tage2 };

heißen, da die Arrayelemente int-arrays sind. Normalerweise geht das aber so nicht, da die Array-Initialisierung afaik nur mit Konstanten funktioniert.

 

[tobee]

Danke an beide von euch.

int* tage[2] = { tage1, tage2 };

So hat es funktioniert. Aber was bewirkt denn der Stern hinter dem int?

Noch 2 Fragen:
1. Wie ermittle ich die Größe eines Arrays
2. Der Compiler hat mir gesagt der Syntax so sein müsste:

int main (int argc, char *argv[])
{
const char* tage1[4] = { 1, 2, 3, 4 };
const char* tage2[3] = { 5, 6, 7 };
const char** tage[2] = { tage1, tage2 };
}

.
Wieso denn dann 2 Sterne?

Tobee

 

[deepthroat]

1. Codetags
2. Ich denke, es müßte

int* tage[2] = { tage1, tage2 };

heißen, da die Arrayelemente int-arrays sind. Normalerweise geht das aber so nicht, da die Array-Initialisierung afaik nur mit Konstanten funktioniert.

In C89 ist das tatsächlich nicht erlaubt - obwohl einige Compiler sich daran nicht unbedingt halten. C99 hebt diese Einschränkung jedoch auf. /edit: und in C++ ist es auch OK.

Gruß

 

[deepthroat]

Du solltest uns erstmal erklären was du damit überhaupt bezwecken willst. Was jokey2 gesagt hat bringt zwar den Compiler zum Schweigen, allerdings vermute ich das du keine Ahnung von Zeigern hast (da du nicht weißt was das Sternchen bedeutet) und das nicht das ist was du willst?! Ich kann mich natürlich auch irren.

Gruß

 

[tobee]

Sinn und Zweck von dem Programm gibt es nicht
Ich mach gerade ein Tutorial in C++, aber das ist nicht so gut erklärt.
Zum Beispiel wird da nicht erklärt was es mit dem Sternchen aus sich hat.


Wie ermittle ich die Größe eines Arrays?


Tobee

 

[deepthroat]

Aha. Also wenn es keinen Sinn gibt dann bleibt ja nur die Syntax die man korrigieren kann.

int* tage[2] = { tage1, tage2 };

So hat es funktioniert. Aber was bewirkt denn der Stern hinter dem int?

Dazu muß man wissen das Arrays im Grunde nur Zeiger sind. D.h. das sind Variablen die eine Adresse speichern. Diese Speicher-Adresse gibt an wo das Array anfängt - also wo das allererste Element das Arrays beginnt.

Das Sternchen bei der Variablendeklaration gibt an, das die Variable vom Typ ein Zeiger auf einen anderen Typ (in diesem Fall "int") ist. Dadurch das da auch noch eckige Klammern mit einer Konstanten stehen bedeutet das für die Variable tage, dass diese ein Array von 2 Elementen (Index 0 bis 1) vom Typ Zeiger auf int ist.

Bei Initialisierungen bzw. Zuweisungen sollten die Typen auf beiden Seiten des Gleichheitszeichens übereinstimmen.

Da tage1 ein Array von int's ist, ist es auch gleichzeitig ein Zeiger auf int - also "int*". Dasselbe gilt für tage2. Wenn man tage1 bzw. tage2 als Element an das Array tage zuweisen will muß die Variable also ein Array von Elementen dieses Typs sein. Also wie es dort steht "int*".

Das gleiche gilt natürlich auch für die char* Arrays.

Noch 2 Fragen:
1. Wie ermittle ich die Größe eines Arrays

Für statische Arrays (so wie du sie jetzt definiert hast) kannst du den sizeof Operator verwenden:

int array[] = { 1, 2, 3, 4 };
int groesse = sizeof (array) / sizeof(array[0]);

2. Der Compiler hat mir gesagt der Syntax so sein müsste:

int main (int argc, char *argv[])
{
const char* tage1[4] = { 1, 2, 3, 4 };
const char* tage2[3] = { 5, 6, 7 };
const char** tage[2] = { tage1, tage2 };
}

.
Wieso denn dann 2 Sterne?

Also erstmal stimmen bei der Initialisierung die Typen auf der rechten und linken Seite für die Arrays tage1 und tage2 nicht überein. Angeblich sind die Elemente dieser Arrays vom Typ "const char*", auf der rechten Seite hast du aber Integerwerte aufgelistet.

const char* tage1[4] = { "eins", "zwei", "drei", "vier" };

Gruß

 

[tobee]

Dazu muß man wissen das Arrays im Grunde nur Zeiger sind. D.h. das sind Variablen die eine Adresse speichern. Diese Speicher-Adresse gibt an wo das Array anfängt - also wo das allererste Element das Arrays beginnt.

Das Sternchen bei der Variablendeklaration gibt an, das die Variable vom Typ ein Zeiger auf einen anderen Typ (in diesem Fall "int") ist. Dadurch das da auch noch eckige Klammern mit einer Konstanten stehen bedeutet das für die Variable tage, dass diese ein Array von 2 Elementen (Index 0 bis 1) vom Typ Zeiger auf int ist.

Bei Initialisierungen bzw. Zuweisungen sollten die Typen auf beiden Seiten des Gleichheitszeichens übereinstimmen.

Da tage1 ein Array von int's ist, ist es auch gleichzeitig ein Zeiger auf int - also "int*". Dasselbe gilt für tage2. Wenn man tage1 bzw. tage2 als Element an das Array tage zuweisen will muß die Variable also ein Array von Elementen dieses Typs sein. Also wie es dort steht "int*".

Das gleiche gilt natürlich auch für die char* Arrays.

Erst mal Vielen Dank für deine ausführliche Antwort. Ich hab alles verstanden außer das mit dem Zeiger . Der Zeiger verweist quasi auf eine Variable wo dann der Wert in dieser gespeichert ist?

// Edit:

char count(const char* a)
{
  return sizeof(a) / sizeof(a[0]);
}

Das ist meine Funktion wo ich die Array Größe ermittel.
Irgend etwas ist aber noch falsch?

Tobee

 

[deepthroat]

Ja, Zeiger sind erstmal ein etwas kompliziertes Konzept.

Zeiger sind Variablen die Adressen speichern. Punkt.

Mit dem Adressoperator & kann man sich die Adresse von Variablen besorgen.

Bsp:

int x = 5;

int* y = &x;

x ist eine Integervariable die mit dem Wert 5 initialisiert wurde. y ist eine Variable vom Typ Zeiger auf int. Mit dem &-Operator wurde die Adresse der Variablen bzw. genauer die Adresse an der der Wert der Variablen steht ermittelt; und dann an y zugewiesen.

y speichert jetzt also die Adresse an der der Wert der Variablen x steht.

Um den Wert der Variablen x zu verändern kann man den Zeiger dereferenzieren:

*y = 10;

Das Sternchen wird hier zum Dereferenzieren benutzt. Das bedeutet es wird nicht der Wert von y geändert, sondern da wo y hinzeigt wird der Wert 10 gespeichert. Die Variable x hat also jetzt den Wert 10, der Wert von y ist immer noch unverändert.

Nützlich werden die Zeiger wenn man dynamische Datentypen benutzt oder beim Funktionsaufruf wo Ausgabeparameter verwendet werden.

Gruß