Felderein-/ausgabe

Andy_KA87

Ja stimmt.. Ich dachte aber, dass es dann das 10.Element ausgibt, also die 9.
Also ist z.B b[4]=4 ?
Nunja.

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

Andy_KA87

CStoll

abgesehen davon, daß "10^k" nicht die Potenz ist (^ ist XOR), sieht die Formel gut aus - und du solltest die einzelnen Werte auch noch eingeben.
(btw, für die einzelnen Ziffern würde ich ein int-Array verwenden)

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.

bwbg

MoinMoin...

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

camper

bwbg schrieb:

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

camper schrieb:

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

CStoll

bwbg schrieb:

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.

bwbg

Ich habe die entsprechenden Stellen im Text markiert. Die Sache mit den "Feldern auf dem Stack" hätte mir aber auch einfallen können, immerhin hatte ich auch mal basepointer geschubbst...

LordJaxom

CStoll schrieb:

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)

Andy_KA87

Also die 1.Formel war trotzdem falsch..
Aber habs nun hinbekommen
So sieht es im Endeffekt aus

#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