Moin,
ich versuche mit scanf 10 Variablen einzulesen. Die sollen aber nicht in Variablen gespeichert werden, sondern nur über Zeiger. Ich weiß, es geht bestimmt einfacher, aber zum Verständnis für Zeiger würde ich das gerne so versuchen.
Mein Quelltext lautet wie folgt:
#include
#include
void main (void)
{
/\*10 Zeiger auf double definieren\*/
int i;
double\* zeiger[10];
/\*jeweils Speicher für ein double reservieren\*/
for( i=0; i
Leider wird bei scanf nicht der eingegebene Wert an den Zeiger übergeben und nach dem dritten Durchlauf der scanf-Schleife springt das Programm in den debug-Modus ??!
Wer kann mir sagen, welche Anfängerfehler ich hier begehe?
thx
moe.
Moin auch,
Leider wird bei scanf nicht der eingegebene Wert an den Zeiger
übergeben und nach dem dritten Durchlauf der scanf-Schleife
springt das Programm in den debug-Modus ??!
Da zeiger[i] bereits ein Zeiger ist, muss es heißen:
scanf( „%d“, zeiger[i]);
Gruß Klaus
Hallo FlamingMoe,
ich versuche mit scanf 10 Variablen einzulesen. Die sollen
aber nicht in Variablen gespeichert werden, sondern nur über
Zeiger. Ich weiß, es geht bestimmt einfacher, aber zum
Verständnis für Zeiger würde ich das gerne so versuchen.
Klaus hat ja den entscheidenden Tipp gegeben,
das ein „Zeiger“ auch nur ein normaler Wert
ist, den man wiederum in einem Array (von
Zeigern) ablegen kann.
Um das zu verdeutlichen, habe ich Dein Programm etwas
vereinfacht, um darzustellen, was das wesentliche
an der Zeigerei ist:
#include
void main (void)
{
int i;
double wert[10];
double\* **zeiger** [10];
for( i=0; izeiger[i] = &wert[i]; // Zeiger auf Werte zeigen lassen
}
printf( "10 Zahlen!\n" );
for( i=0; izeiger[i] );
}
printf( "\nWerte:\n" );
for( i=0; izeiger[i][0] ); // \*zeiger[i]
}
}
Ein Zeiger ist also nur ein Wert, der die ‚Adresse‘
der Speicherstelle der Daten enthält.
Grüße
CMБ
Moin auch,
Leider wird bei scanf nicht der eingegebene Wert an den Zeiger
übergeben und nach dem dritten Durchlauf der scanf-Schleife
springt das Programm in den debug-Modus ??!
Da zeiger[i] bereits ein Zeiger ist, muss es heißen:
scanf( „%d“, zeiger[i]);
Danke.
Jetzt gibt es einen anderen Fehler 
die letzte printf-Anweisung habe ich schon korrigiert.
aus %d.2 habe ich %.2d gemacht.
Trotzdem werden nur ints übernommen. Bei Eingabe einer Komma-Zahl springt das Programm von der scanf-Schleife zur printf-Schleife und spuckt die eingegebenen int-Werte aus und für die restlichen zeiger[i] reichlich Unsinn (ist klar, weil was soll sonst ausgespuckt werden).
thx
moe.
Nochmal moin,
lesen der Doku ist zwar nicht Pflicht, aber ab und zu hilfreich 
SCNR
%f ist Dein Freund bei der Ausgabe von Gleitkommazahlen. (%g manchmal auch)
Bsp: printf("%8.2f",doubleWert);
Gruß Klaus
Nochmal moin,
lesen der Doku ist zwar nicht Pflicht, aber ab und zu
hilfreich SCNR
%f ist Dein Freund bei der Ausgabe von Gleitkommazahlen. (%g
manchmal auch)
Bsp: printf("%8.2f",doubleWert);
Der Fehler entsteht aber nicht bei der Ausgabe, sondern beim Einlesen der Werte.
moe.
Hallo moe,
%f ist Dein Freund bei der Ausgabe von Gleitkommazahlen. (%g
manchmal auch)
Bsp: printf("%8.2f",doubleWert);
Der Fehler entsteht aber nicht bei der Ausgabe, sondern beim
Einlesen der Werte.
scanf() verwendet die selbe Logik wie printf() !
also scanf("%d",…) liest immer nur Integer ein !!
Näheres findest du in der Dokumentation zu C und deinem Compiler.
MfG Peter(TOO)
Um das zu verdeutlichen, habe ich Dein Programm etwas
vereinfacht, um darzustellen, was das wesentliche
an der Zeigerei ist:
#include
void main (void)
{
int i;
double wert[10];
double* zeiger [10];
for( i=0; izeiger[i] = &wert[i]; // Zeiger auf Werte zeigen
lassen
}
printf( „10 Zahlen!\n“ );
for( i=0; izeiger[i] );
}
printf( „\nWerte:\n“ );
for( i=0; izeiger[i][0] ); // *zeiger[i]
}
}
Ein Zeiger ist also nur ein Wert, der die ‚Adresse‘
der Speicherstelle der Daten enthält.
Was hat es denn mit dem zweiten Index in der letzten Anweisung auf sich ?
printf( „\t%g\n“, zeiger[i][0] ); // *zeiger[i]
Klappt das ganze auch, wenn ich einen einzelnen Zeiger auf wert[10] anlege und diesen dann (wie genau weiß ich auch noch nicht) vor der nächsten Wertzuweisung oder -Auslesung inkrementiere?
thx
moe.
Hallo FlamingMoe
Klappt das ganze auch, wenn ich einen einzelnen Zeiger auf
wert[10] anlege und diesen dann (wie genau weiß ich auch noch
nicht) vor der nächsten Wertzuweisung oder -Auslesung
inkrementiere?
Ja, genau:
#include
void main (void)
{
int i;
double wert[10];
double\* **zeiger** ;
**zeiger** = &wert[0]; // identisch: zeiger = wert;
printf( "10 Zahlen!\n" );
for( i=0; izeiger++) {
printf( "Geben Sie #%d (von 10) ein!", i+1);
scanf( "%lf", **zeiger** );
}
**zeiger** = &wert[0]; // Achtung: wieder von vorne
printf( "\nWerte:\n" );
for( i=0; izeiger++ ) {
printf( "\t%g\n", \ ***zeiger** ); // identisch: zeiger[0]
}
}
Nicht vergessen, den Zeiger wieder auf den Anfang
zu setzen, bevor die Ausgabe beginnt.
Übrigens: ein %g in printf(…) und double ist
empfehlenswert, weil ganze Zahlen auch als ganze
Zahlen (ohne Punkt) dargestellt werden.
Grüße
CMБ
Hallo FlamingMoe,
ich versuche mit scanf 10 Variablen einzulesen. Die sollen
aber nicht in Variablen gespeichert werden, sondern nur über
Zeiger. Ich weiß, es geht bestimmt einfacher, aber zum
Verständnis für Zeiger würde ich das gerne so versuchen.
Klaus hat ja den entscheidenden Tipp gegeben,
das ein „Zeiger“ auch nur ein normaler Wert
ist, den man wiederum in einem Array (von
Zeigern) ablegen kann.
Um das zu verdeutlichen, habe ich Dein Programm etwas
vereinfacht, um darzustellen, was das wesentliche
an der Zeigerei ist:
#include
void main (void)
{
int i;
double wert[10];
double* zeiger [10];
for( i=0; izeiger[i] = &wert[i]; // Zeiger auf Werte zeigen
lassen
}
printf( „10 Zahlen!\n“ );
for( i=0; izeiger[i] );
}
printf( „\nWerte:\n“ );
for( i=0; izeiger[i][0] ); // *zeiger[i]
}
}
Ein Zeiger ist also nur ein Wert, der die ‚Adresse‘
der Speicherstelle der Daten enthält.
Was hat es denn mit dem zweiten Index in der letzten Anweisung auf sich ?
printf( „\t%g\n“, zeiger[i][0] ); // *zeiger[i]
thx
moe.
Hallo FlamingMoe
Was hat es denn mit dem zweiten Index in der letzten Anweisung
auf sich ?
printf( „\t%g\n“, zeiger[i][0] ); // *zeiger[i]
der Ausdruck:
int k = \*zeiger;
und
int k = zeiger[0];
ist äquivalent. Ebenfalls analog:
int k = \*zeiger[i];
und
int k = zeiger[i][0];
die Dereferenzierung *ptr ist
auch mit ptr[0] oder 0[ptr]
zu machen.
Grüße
CMБ