Also ich dachte (zumindest habe ich das in der Vorlesung so verstanden), dass wenn ich z.B Feld[10] eingebe, wird ein Feld mit 10 Stellen (von 0 bis 9) eingespeichert.

Wenn ich z.B aber cout<<b[3]<<endl; mache.. Also das 3.Element möchte, hat er eine 3 ausgespuckt. Zuerst dachte ich, dass er die 3 meinte..
Aber als ich b[10] eingegeben habe, kam auch die 3 heraus?
Wie darf ich das interpretieren?

Der bereich des Arrays geht, wie du gesagt hast von 0 bis n-1 (0 bis 9)

Hab noch eine Frage.. bzw hänge gerade..!

Hier die Aufgabe 6:
http://www.mathematik.uni-karlsruhe.de/ianm2/lehre/cpp2007w/media/cpp-ws07-ab03-a5.pdf
Aufgabe 5 habe ich hinbekommen.
Aber bei der Aufgabe 6 hänge ich..
Ich finde auch unser Prof hat das mit den Feldern nich so verständlich erklärt..
Haben ein paar Probleme mit.

Und zwar bin ich bisher hier:

#include <iostream>
#include <math.h>
using namespace std;

int main()
{
	int m, z;

	const int=1;
	double b[k];
	int k;

	cout<<"Wieviele Stellen hat die Dezimalzahl?"<<endl;
	cin>>m;
	if(m<0) cout<<"Bitte geben Sie einen positiven Wert ein."<<endl;
	z=0;

	for(z=0;k=0;k<=(m-1);k++)
		{
			z+= b[k]*(10^k);

Ist die Formel so richtig?
Also das ist ja nun vorerst der 1.Abschnitt.

Irgendwie war alles vor den Feldern für mich ziemlich verständlich und konnte die Aufgaben auch immer recht schnell in den Praktika lösen, aber da hing ich...
(falls es wen interessiert: Unsere HP zur Vorlesung

PS: Was mir noch nachträglich aufgefallen ist: Du kannst ein Array nicht anlegen, wenn du die Größe erst danach einlesen willst - die muß bereits beim Compilieren feststehen.

das mit den Feldern (Arrays) ist eigentlich eine ganz einfache Sache (wenn man es denn erst einmal verstanden hat). Felder sind nichts weiter als Zeiger (engl. Pointer) (EDIT - Siehe Folgepostings!).

Was ist ein Zeiger?

Ein Zeiger zeigt (wer hätte das gedacht) auf eine bestimmte Speicherstelle. Dem Zeiger ist es egal, wie groß der Speicherbereich ist auf welchen er zeigt. Er zeigt immer auf das erste Element.

int feld[10];
// Hier wird ein Feld mit einer Größe für 10 Elemente vom Typ int im Speicher
//  reserviert. Auf einer herkömmlichen x86-Architektur (32-bit) sind
//  das 10 x 4 Bytes. 'feld' zeigt nun auf den Anfang dieses
//  Speicherbereiches. Die Werte der Elemente sind zu diesem Zeitpunkt
//  völlig willkürlich!

Um nun auf die einzelnen Elemente des Feldes zugreifen zu können, wird der so genannte Index-Operator (operator[](size_t)) verwendet (eben die eckigen Klammern). Bei den "normalen" Datentypen kann man sich den Zugriff auf die Elemente wie in einer linearen Gleichung vorstellen:

Adresse = Startadresse + Index * GrößeElement

Oder als C++-Code:

int wert_aus_feld = Startadresse[Index];
// Die Größe des Elementes ist dem Compiler bekannt, darum muss man sich
//  nicht selbst kümmern.

Startadresse[Index] = wert_in_feld;
// Eben um einen Wert in das Feld zu speichern.

Aus der oben genannten Gleichung lässt sich ableiten, dass das erste Elemente immer den Index 0 hat und das letzte Element eben den Index Feldlänge-1.

EDIT - Nachfolgender Absatz ist getrichen, da es sich um eine falsche Aussage meinerseits handelte (siehe Folgepostings):

Anzumerken ist noch, dass der Compiler die Länge des Feldes nicht kennt. Du musst auf jeden Fall selbst prüfen, dass du bei den Zugriffen auf die Felder die Grenzen nicht überschreites (diese netten "Segmentation-Faults"/"Speicherzugriffsverletzung" wären die Folge).

Genug der Theorie...

Im Netz gibt es zahlreiche Informationen zu Zeigern, die du dir in diesem Fall ruhig mal ansehen kannst (EDIT - Ich mir im übrigen auch noch mal).

Grüße... Heiko

Felder sind nichts weiter als Zeiger (engl. Pointer).

nein.

bwbg schrieb:

Anzumerken ist noch, dass der Compiler die Länge des Feldes nicht kennt.

nein.

bwbg schrieb:

Felder sind nichts weiter als Zeiger (engl. Pointer).

nein.

Etwas missverständlich habe ich mich da wohl ausgedrückt. Ein Feld ist natürlich kein Zeiger, das sind zwei Paar Schuhe. Das Feld ist konkret im Speicher reserviert. Der Zugriff auf dieses Feld erfolgt mittelbar über den Zeiger, welcher ein eigenständiges Objekt ist und damit selbst an einer eigenen Stelle im Speicher gespeichert ist.

In der Verwendung macht es aber keinen Unterschied, ob ich nun feld[0] oder *feld verwende, da der Zugriff auf ein Feld über einen Zeiger erfolgt.

camper schrieb:

bwbg schrieb:

Anzumerken ist noch, dass der Compiler die Länge des Feldes nicht kennt.

nein.

Da gebe ich dir Recht. Der Compiler muss natürlich die Länge des Feldes kennen. Zur Laufzeit ist die Länge des Feldes nicht mehr bekannt. Ich werde die entsprechende Stelle im Posting ändern.

Sollte ich in irgendeiner Weise falsch liegen, bitte kurz anmerken. Ich will ja keinen Mist verbreiten.

Grüße... Heiko

camper schrieb:

bwbg schrieb:

Anzumerken ist noch, dass der Compiler die Länge des Feldes nicht kennt.

nein.

Da gebe ich dir Recht. Der Compiler muss natürlich die Länge des Feldes kennen. Zur Laufzeit ist die Länge des Feldes nicht mehr bekannt. Ich werde die entsprechende Stelle im Posting ändern.

Sollte ich in irgendeiner Weise falsch liegen, bitte kurz anmerken. Ich will ja keinen Mist verbreiten.

Grüße... Heiko

OK, langsam: Solange du das Fald direkt vor Ort hast, kannst du (über sizeof) auch zur Laufzeit an dessen Größe herankommen. Wenn du es an eine Funktion übergibst, wird in Wahrheit nur ein Zeiger auf das erste Feldelement weitergegeben - und über den hast du tatsächlich keine Möglichkeit mehr, die Feldgröße zu bestimmen.

OK, langsam: Solange du das Fald direkt vor Ort hast, kannst du (über sizeof) auch zur Laufzeit an dessen Größe herankommen. Wenn du es an eine Funktion übergibst, wird in Wahrheit nur ein Zeiger auf das erste Feldelement weitergegeben - und über den hast du tatsächlich keine Möglichkeit mehr, die Feldgröße zu bestimmen.

Ich finde hier steckt auch noch Potential für Missverständnisse: Ein benanntes Feld ist direkt vor Ort, denn sonst wäre es kein Feld sondern ein Zeiger. Man kann jedes Feld implizit in einen Zeiger umwandeln (man könnte auch sagen, man kann den Namen eines Feldes in vielen Fällen wie einen Zeiger auf das Feld verwenden), aber bei der Anwendung von z.B. sizeof wird schnell klar, dass das Ergebnis bei einem Feld anders ist als bei einem Zeiger auf ein Feld.

(Auch hier, nennt mich kleinkariert, wird die Größe nicht zur Laufzeit mit sizeof ermittelt, zur Laufzeit steht dort nur noch eine konstante Zahl im Speicher rum)

#include <iostream>
#include <math.h>
using namespace std;

int main()
{
	int m, z, bk, c, cl;

	z=0;

	cout<<"Wieviele Stellen hat die Dezimalzahl?"<<endl;
	cin>>m;
	if(m<0) cout<<"Bitte geben Sie einen positiven Wert ein."<<endl;

	for(int k=0;k<=(m-1);k++)
		{cout<<k+1<<".Stelle eingeben:"<<endl;
		cin>>bk;

			z+= bk*pow(10.0,k);
		}

	cout<<"Ihre Dezimalzahl lautet "<<z<<endl;

	int l=0;

	while(1)
		{
			cl= z%2;
			z=(z/2);
			l++;

		cout<<l+1<<"Stelle: "<<cl<<endl;

		if(z==0) break;
		}
return 0;
}

Die Laufanweisung ist noch falsch herum. Müsste ich noch ändern.
Nunja... Ich fands schwer