Prototypen

[Truggi]

Hallo

Ich bin jetzt bei Arrays.
Und es heisst man solle immer Prototypen deklarieren.
Was sind diese Prototypen genau und was bringen sie?

Danke für Antworten

Gruss Truggi

[Gast]

Momentan weiß ich nicht genau, was Prototypen mit Arrays zu tun haben, aber ich poste dennoch das Grundlegende darüber bezogen auf Funktionen.

Wenn du deine main-Methode hast, die andere Funktionen aufrufen soll, dann muss (logischerweise) bekannt sein, welche Funktionen aktuell aufgerufen werden können.

Zunächst ein Beispiel:

#include <iostream>

void schreibeHelloWorld() {
    std::cout << "Hello World!" << std::endl;
}

int main(int argc, char **argv) {
    schreibeHelloWorld();
}

Du kannst die Funktion schreibeHelloWorld() aufrufen, weil du diese vor der main(...) definiert und deklariert hast. Was wäre aber hier:

#include <iostream>

int main(int argc, char **argv) {
    schreibeHelloWorld();
}

void schreibeHelloWorld() {
    std::cout << "Hello World!" << std::endl;
}

Dies gäbe einen Compilerfehler, weil die Funktion schreibeHelloWorld() nicht definiert ist (zumindest nicht vor der main(...) ). Hier helfen Vorwärtsdeklarationen/Prototypen, um dem Compiler zu sagen "Die Methode gibt es, ist aber erst später definiert."

Dazu muss man bloß die Funktionssignatur ohne Funktionsrumpf nochmals schreiben.

#include <iostream>

// Prototyp
void schreibeHelloWorld();

int main(int argc, char **argv) {
    schreibeHelloWorld();
}

void schreibeHelloWorld() {
    std::cout << "Hello World!" << std::endl;
}

Dies wird erst interessant, wenn du deinen Code in mehrere Dateien/Module auslagerst!

Ich hoffe, dass ich es kurz und verständlich erklärt habe :xmas1:

// EDIT:

Später nutzt man sog. Header-Dateien, in denen man bloß noch Prototypen definiert, die in komplett anderen Sourcecode-Dateien vollständig ausgecoded sind. Somit kann man die Funktionen ordnen/sortieren und den Code nicht zu aufgebläht wirken lassen.

[Truggi]

Danke für die Ausführliche Antwort.

In dem Buch gibt es immer Beispielprogramme und bei den Arrays wird das zum ersten Mal gebraucht.

Bei dem Beispiel sieht es so aus:
( ich weiss nicht wie man das mit dem C++- Feldern macht :D)

...
using namespace std;

//Prototypen deklarieren
int readArray(int integerArray[], int maxNumElements);
...( noch 2 Prototypen)

int main ...
usw.

Aber wieso deklariert man Prototypen, aber man schreibt dann keine Funktion darunter?
Ist es egal ob man den Inhalt der Funktion in der main() Klammer aufschreibt oder schon vorher, wenn man die Funktion schon deklariert hat?

Sorry wenn ich das jetzt kompliziert mache

Gruss Truggi

[Gast]

Zunächst kann du C++-Code farbig hervorheben (wie ich) indem du unter den Smilies beim Erstellen eines Posts zwei mal auf den Button "C/C++" drückst und zwischen den eckigen Klammern, die erschienen sind, deinen Code postest.

Truggi schrieb:

Ist es egal ob man den Inhalt der Funktion in der main() Klammer aufschreibt oder schon vorher, wenn man die Funktion schon deklariert hat?

Deine Frage ist durchaus komisch. Ich verstehe nicht genau, was du willst, deshalb konkretisier das bitte bzw. versuche es ganauer zu erklären.

[Truggi]

Wieso kann man eine Funktion vor der main() Klammer sowie in der main() Klammer den Inhalt geben(also das in den geschweiften Klammern)?

Ich schreibe morgen meine Frage nochmal genauer, weil ich jetzt gehen muss.
Ist ein bisschen kompliziert.

Aber danke das du mir helfen willst.

Gruss Truggi

[Gast]

Der Teil einer Funktion zwischen den geschweiften Klammer wird Funktionsrumpf genannt.

void foo() {
    // Funktionsrumpf hier
}

Eine Funktion kann ihren Funktionsrumpf nicht innerhalb einer anderen haben, weil diese mit der Signatur ( void foo(); ) verknüpft werden muss, wenn ich jetzt recht verstehe, was du willst

Das in der Hauptmethode ist nur ein Aufruf und keine konkrete Deklaration/Definition der Funktion!

[Manni66]

Irgendwie habe ich das Gefühl, dein Buch erklärt nicht wirklich viel. Was liest du denn da?

[Truggi]

Das Buch heisst "C++ für Dummies"

Es erklärt schon viel aber für mich ist es ein bisschen kompliziert.

Also zu meiner Frage:

Verstehe ich das richtig, dass man eine Funktion vor der main() Klammer definieren muss, aber den Funktionsrumpf kann man auch erst in der main () Klammer schreiben?

[icarus2]

Wenn du eine Funktion aus der main() aufrufen möchtest, musst du sie vor der main() deklarieren, damit der Compiler die Signatur der Funktion kennt.

Den Funktionsrumpf kannst du nachher irgendwo nach dem Prototypen schreiben, aber NICHT im Rumpf der Main-Methode.

Z.B. so:

// Hier ist der Prototyp, damit der Compiler die Signatur der Funktion kennt
int add( int a, int b );

int main()
{
	cout << add(1, 2) << endl;
}

// Der Rumpf wird implementiert
int add( int a, int b )
{
	return a + b;
}

Oder du kannst es auch direkt machen:

// Die Funktion wird vor der Main bereits mit Rumpf definiert
int add( int a, int b )
{
	return a + b;
}

int main()
{
	cout << add(1, 2) << endl;
}

Interessant wird dies dann vor allem auch wenn du mit Header-files beginnst zu arbeiten. Du kannst dann in den Headerfiles die Prototypen hinschreiben und diese in einem anderen file (z.B. .cpp file) implementieren.

[Truggi]

Aha

Danke
Oke jetzt kapier ichs

Aber wenn ich den Funktionsrumpf erst nach der main() Klammer aufschreibe, fehlt dem Compiler dann nicht während er die main- Funktion ausführt die Daten der deklarierten Funktionen?

[icarus2]

Der Compiler braucht nur die Signatur zu kennen. Das heisst er muss wissen wie viele Argumente eine Funktion hat und welchen Rückgabetypen. Der Rest übernimmt dann der Linker.

[Truggi]

Oke

Danke

Hattet ihr als ihr C++ gelernt habt auch so Probleme mit Arrays?

[icarus2]

Nein, überhaupt keine. Aber als ich Java lernte (war meine erste Programmiersprache) hatte ich zu Beginn Probleme Arrays genau zu verstehen. Aber das wird schon

Kannst ja sonst im Forum auch einen Fred aufmachen um Fragen zu stellen, falls etwas ganz unklar ist.

[Truggi]

Also im Moment verstehe ich überhaupt nichts mehr

Das Buch ist wahrscheinlich nicht für 16jährige geschrieben oder ich bin nicht begabt

[icarus2]

Ach was Ich versuche es mal zu erklären.

Angenommen du möchtest in deinem Programm 10 int Werte haben. Du könntest nun natürlich die Variablen int x1, int x2, ..., int x10 deklarieren. Spätestens wenn du aber mal 1000 int Werte brauchst ist das nicht mehr so schön. Dafür sind Arrays da.
Du kannst dir ein Array wie eine Reihe von Fächern vorstellen und in jedes Fach kannst du einen int Wert reinlegen. Die Fächer werden nummeriert von 0 bis 9, da die Nummerierung immer bei 0 beginnt.

Du möchtest also nun die Zahlen von 1-3 in deinem Array haben. Du kannst das z.B. so machen:

int x_werte[3]; // Hier deklarierst du einen Array, in den 3 Werte reinpassen
	x_werte[0] = 1; // Du initialisierst den ersten Array-Wert mit 1 (anschaulich: du tust 1 in das erste Fach)
	x_werte[1] = 2; // 2 tust du ins 2te Fach
	x_werte[3] = 3;

Über x_werte[i] bekommst du also den Wert, der an der i-ten Stelle liegt. Diesen kannst du dann brauchen wie eine normale int Variable.

Wenn du nun die Werte ausgeben möchtest kannst du folgendes machen:

// Hier werden die Werte der Reihe nach ausgegeben
	cout << x_werte[0] << endl;
	cout << x_werte[1] << endl;
	cout << x_werte[2] << endl;

Wenn du nun die Werte von 1-100 haben möchtest, kannst du ein int-Array der Länge 100 machen und dann über eine for-Schleife die Werte initialisieren. Dann kannst du diese auch wieder über eine for-Schleife ausgeben, z.B. so:

int x_werte[100];

	// Weise allen 100 Fächern den Wert von i+1 zu
	for( int i = 0; i < 100; i++ )
	{
		x_werte[i] = i+1;
	}

	// Gebe alle 100 Werte im Array aus
	for( int i = 0; i < 100; i++ )
	{
		cout << x_werte[i] << endl; // Gibt den Wert an i-ter Stelle aus.
	}

Ich hoffe, dass dir das etwas Hilft. Man kann sich Arrays wirklich sehr gut als eine Reihe von Fächern vorstellen, in den man Werte eines gewissen Typs (z.B. int, double oder float) reintun kann.

Das Problem ist jetzt halt, dass es in C++ sehr viele verschiedene Arten gibt Arrays zu initialiseren und deklarieren. Am besten spielst du einfach mal ein bisschen mit Arrays herum. Wenn dann etwas konkretes nicht klappt, dann fragst du hier im Forum.

[Truggi]

Cool genau nach sowas hab ich gesucht
Danke

Spätestens wenn du aber mal 1000 int Werte brauchst ist das nicht mehr so schön.

In dem Buch steht aber, dass man pro Array nur 128 Werte speichern kann.
Wie geht dann das?

Und kannst du mir vl mal eine Aufgabe stellen, die ich dann lösen könnte?

Gruss Truggi und Danke nochmal

[JürgenWürgen]

In dem Buch steht aber, dass man pro Array nur 128 Werte speichern kann.

Das steht da sicherlich nicht. So etwas würde nicht mal Jürgen Wolf behaupten. Wahrscheinlich legst du 128-elementige Arrays an, in die dann natürlich nur 128 Werte passen. Du kannst aber genauso gut Arrays mit 1000 Werten anlegen.
Wie das geht hat dir der übermütige Engel schon gesagt.

[Truggi]

Ups

Sorry, alles klar.

Wer genau lesen kann ist im Vorteil.

[icarus2]

Hmm, Aufgaben auszudenken ist immer etwas schwer aber ich versuchs mal (teilweise habe ich ähnliche Aufgaben in Programmierbüchern gefunden):

Änder den Code von mir mal so ab, dass du 1000 Werte speichern kannst und schau, ob es funktioniert. Bei mir funktioniert es einwandfrei

Deklariere ein Array der Länge 10 und speichere darin die ersten 10 ungeraden Zahlen (also 1, 3, 5, ...), am besten mit einer for-Schleife.

Deklariere ein Array

int x[] = {9,4,3,5};

Dies ist ein Array der Länge 4. x[0] = 9, x[1] = 4 usw.
Gibt mit einer for-Schleife die Summe der Werte aus, die im Array gespeichert sind.

Deklariere zwei float Arrays x und y der Länge 3, und fülle beide mit beliebigen Werten. Anschliessend gibst du mit einer for-Schleife x[0]+y[0] und [x1]+y[1] und x[1]+x[2] aus.

Ich hoffe, dass diese Aufgaben nicht allzu schwer sind.

[Truggi]

1. Geschafft

Bei 2.,3. und 4. weis ich nicht, wie ich die for-Schleifen deklarieren soll.
Wie geht das? Kannst du mir das bitte erklären?