3. Prototypen

Prototypen

  • T

    Oke

    Danke

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

    0
  • I

    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.

    0
  • T

    Also im Moment verstehe ich überhaupt nichts mehr 😕

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

    0
  • I

    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.

    0
  • T

    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

    0
  • ?

    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.

    0
  • T

    Ups

    Sorry, alles klar.

    Wer genau lesen kann ist im Vorteil. 😃

    0
  • I

    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.

    0
  • T

    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?

    0
  • I

    Also du möchtest ja durch alle Werte des Arrays iterieren (iterieren bedeutet der Reihe nach alle Werte durchmachen).

    Du beginnst also am Anfang des Arrays bis zu einem bestimmten Index. In diesem Fall vom Anfang bis zum Schluss.

    Wenn du nun ein Array mit 10 Elementen hast weisst du, dass diese Elemente von 0 bis 9 durchnummieriert sind.

    Die for-Schleife sieht dann so aus:
    for( int i = 0; i < 10; i++ )
    Du beginnst also bei 0 und erhöhst i bei jedem Schritt um 1. Dies machst du aber nur solange i < 10 ist, da das Array ja nur Elemente von 1-9 hat.

    Den Rest siehst du in meinem Beispiel oben.

    0
  • T

    Aber es sollen ja die ungeraden Werte angezeigt werden

    0
  • ?

    Eine for-Schleife ist sehr einfach. Zunächst einmal ein Überblick in Pseudocode:

    for(Initialisierung; Bedingung; Fortsetzung) {
    Anweisungen
}

    Du hast die Möglichkeit eine Initialisierung durchzuführen, in der du für die Schleife eine Zählvariable definierst, mit der du den Programmfluss kontrollieren kannst. Solange die angegebene Bedingung wahr ist (meistens bezogen auf die Zählvariable), dann wird jeweils einmal alles zwischen den geschweiften Klammern ausgeführt (=Anweisungen). Zum Schluss wird in der Fortsetzung meistens die Variable inkrementiert (um 1 erhöht), damit die Schleife auch mal aufhört.

    for(int i = 0; i < 9; i++)
    std::cout << i << std::endl;

    Hier wird eine Variable i definiert und festgelegt, dass die Schleife solange ausgeführt werden soll, wie auch i < 9 . Am Ende eines Durchlaufs wird i dann inkrementiert.
    Ansonsten werden nur die Zahlen von 0 bis 8 ausgegeben.

    Hoffe das erklärt es irgendwie 😃

    // EDIT: Das war allgemein.
    Wenn du überprüfen willst, ob eine Zahl (un)gerade ist, dann kannst du den Modulo-Operator % nutzen.

    0
  • T

    Kannst du mir mit dem Modulo ein Beispiel machen?

    0
  • ?

    Der Modulo-Operator liefert immer den Rest einer Division:

    7 / 3 = 2 Rest 1
7 % 3 = 1

    Müsste einfach und selbsterklärend sein.

    0
  • I

    Oder gleich so für die ungeraden Zahlen:

    for( int i = 0; i < 10; i++ )
	{
		cout << 2*i + 1 << endl;
	}

    Falls du dann mal durch gerade Zahlen möchtest einfach das +1 weglassen.

    0
  • ?

    Das ist ja dann wieder höhere Mathematik, wenn man sagt, dass für jedes n eine Zahl k = 2*n + 1 (n, k Element N) immer ungerade ist. (Lässt sich durch vollständige Induktion beweisen 😃 )

    0
  • I

    Christian Ivicevic schrieb:

    Das ist ja dann wieder höhere Mathematik, wenn man sagt, dass für jedes n eine Zahl k = 2*n + 1 (n, k Element N) immer ungerade ist. (Lässt sich durch vollständige Induktion beweisen 😃 )

    Genau 😉 Aber für die, die vollständige Induktion nicht kennen gehts auch. Ist ziemlich intuitiv 🙂

    0
  • ?

    Schon, aber ich denke, dass ich es eher mit Modulo gemacht hätte, als jede Zahl einfach ungerade zu machen. 😃
    Aber jedem seine Herangehensweise.

    0
  • B

    Modulo Operator ist das Gegenstück zur Division aus der Grundschule.

    Da hat man noch etwa folgendes gerechnet:

    7 durch 2 == 3 Rest 1

    Bei int's ist es genauso.
    7 / 2 == 3
    und
    7 % 2 == 1

    Modulo gibt dir also den ganzzahligen Rest der Division. Das macht natürlich nur bei Integers Sinn.

    Nun überlegt man sich weiter, das jede gerade Zahl durch 2 teilbar ist, also bei der Division durch 2 den Rest 0 lässt. Also z.b. 8 % 2 == 0. Ist eine Zahl ungerade, dann ist sie nicht durch 2 teilbar. Sie lässt also bei Division durch 2 einen Rest ungleich 0. Also sogar den Rest 1. z.B. 9 % 2 == 1.

    Man kann also mit folgendem Code testen ob eine Zahl gerade oder ungerade ist:

    if(i % 2 == 0) cout << i << " ist gerade.\n";
else cout << i << " ist ungerade\n";

    Das ist aber umständlich um die ersten 10 ungeraden Zahlen zu finden. Besser ist es zu wissen, das jede zweite Zahl ungerade ist und das 1 die erste ungerade Zahl größer 0 ist. Das führt einem zu der Erkenntnis, das man jede beliebige ungerade Zahl als 2*i +1 darstellen kann. Damit kann man dann folgende Schleife aufstellen:

    int u; // da wird die ungerade Zahl drinstehen
for(int i=0; i<10; i++)
{
  u = 2*i +1;
  // tues was mit u
}

    Mario

    0
  • T

    Danke euch allen für die ausführlichen Antworten.

    Und wie ist es bei Aufgabe 3 und 4?

    Deklariere ein Array
    C/C++ Code:
    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.

    0
Anmelden zum Antworten