Wie versteht man Zeigerarithmetik??

silent_max

bnadrfha schrieb:

Ist C++ für dich ein Ratespiel? Dein Code macht genau null Sinn.

Ratespiel hin oder her ... Wenn ich etwas nicht verstehe, dann frage ich halt nach. Und wenn es Dir unangenehm ist, dann kann ich ja nichts dafür oder?

Zurück zum Thema und beim Beispiel von Tobiking2 bleibend...

int a = 5;  // Zahl auf Ganzzahl 5 gesetzt
int *pa=&a; // Pointer auf die Variable deklariert und initialisiert
pa = pa+4;  // Hat mit der obigen 5 soweit nichts tun

Oder verstehe ich es immer noch nicht?

Probiers mal mit nem Array, vielleicht verstehst du es dann:

int a[] = {1, 3};  // Array mit den Werten 5 und 3 initialisieren
int *pa=&a; // Pointer zeigt auf die Adresse des ersten Elements im Array a, also auf a[0]
pa = pa+a[0];  // Pointer zeigt nun um a[0] * sizeof(int) Bytes weiter, da das Array aus int Werten besteht, also nun auf a[1]. Die Adresse von pa enthält also den Wert 3. a[0] hat den Wert 1, deswegen wird der Adresszeiger um 1 * sizeof(int) verschoben.

Wie groß sizeof(int) nun ist, ist Rechnerabhänigg.

Beispiel:
Auf einem 32 Bit Rechner sind 4 Bytes ein typischer wert.
Wenn also dein Adresszeiger zuerst auf die Adresse 39F3CA02 zeigen würde, dann würde er nach der pa = pa+a[0] Operation auf 38F3CA06 zeigen. Also um 4 Bytes verschoben, denn ein int ist 4 Bytes groß und wieviele int Werte man nun weiter geht, ist durch die 1, also a[0] festgelegt.

Würde pa noch auf a[0] zeigen und würdest du pa = pa + 2 ausführen, dann würde dein Zeiger auf eine Stelle außerhalb des Arrays zeigen und das ist undefiniertes Verhalten.
Genau das machst du aber in deinem ersten Code, denn dort hast du kein Array, sondern nur einen einzigen int Wert, also a. Was an der Adresse von a 4 Bytes weiter liegt, das ist nicht definiert.

Sorry, hab vergessen das Kommentar noch zu ändern, nach dem ich den ersten Wert im Array geändert habe.

Dies sollte natürlich lauten:

// Array mit den Werten 1 und 3 initialisieren

Ups, da hat sich beim nochmaligen Abtippen ein Fehler eingeschlichen.

Der zweite Adresswert ist natürlich:
39F3CA06

Die 8 war ein Tippfehler, hab das geänderte nun fett hervorgehoben.

Sone

Du bist kein Programmierfachprofi.
Dein Beispiel ist falsch und schlecht.

Sone schrieb:

Du bist kein Programmierfachprofi.
Dein Beispiel ist falsch und schlecht.

Jup, sollte so heißen:

int a[] = {1, 3};
int *pa=a;
pa+=1; // oder ++pa;

@ silent_max: Du hast irgendwo mal geschrieben, dass morgen irgendeine Prüfung anstehe. Und nun meinst du, mit mehreren Posts zu Einsteigerfragen am Sonntagabend irgendwie durchzukommen? Deine Fragen sind ungefähr die gleichen wie vor 9 Monaten
Ich hoffe, dass dein Lehrer keine Ahnung hat, dann könnte das sogar klappen...

silent_max

ohoh schrieb:

@ silent_max: Du hast irgendwo mal geschrieben, dass morgen irgendeine Prüfung anstehe. Und nun meinst du, mit mehreren Posts zu Einsteigerfragen am Sonntagabend irgendwie durchzukommen? Deine Fragen sind ungefähr die gleichen wie vor 9 Monaten
Ich hoffe, dass dein Lehrer keine Ahnung hat, dann könnte das sogar klappen...

Nein, ich habe erst im neuen Jahr eine Prüfung in C++ Programmierung.

Warum haben eigentlich so viele was gegen meine Fragen??

knivil

Schreib doch mal dein Beispiel korrekt auf, also was ist das Problem, was sind deine Annahmen, was sind deine Erwartungen and das Ergebnis und was kommt tatsaechlich raus.

Kurz: Zeigerarithmetik ist 'Rechnen mit Zeigern als Operanden', d.h. es muss erstmal + oder - her. Das Ergebnis ist wieder ein Zeiger, aber welcher Wert dieser hat oder worauf er nach einer Addition mit 5 zeigt, haengt vom Typ ab.

silent_max schrieb:

Warum haben eigentlich so viele was gegen meine Fragen??

Weil sich die meisten Deiner Fragen mit guter Literatur nicht stellen sollten.
Entweder überfliegst Du nur Dein Lernmaterial ohne auch nur 2 Minuten darüber nachzudenken, bis Du hier einen Beitrag schreibst, oder Du bist hoffnungslos mit programmieren überfordert.
Ich assoziiere Deinen Nick schon mit "Hoffnungsloser Fall". Nicht böse gemeint, aber es scheint einfach nichts für Dich zu sein.

Tachyon

silent_max schrieb:

Warum haben eigentlich so viele was gegen meine Fragen??

Weil Du hier seit Monanten ohne erkennbare Verbesserung Deiner Kenntnisse rumfragst. Dabei probierst Du einfach nur wild rum, ein ordentliches Buch zu nehmen, und dieses durchzuarbeiten.

silent_max

qwertzy schrieb:

Weil sich die meisten Deiner Fragen mit guter Literatur nicht stellen sollten.
Entweder überfliegst Du nur Dein Lernmaterial ohne auch nur 2 Minuten darüber nachzudenken, bis Du hier einen Beitrag schreibst, oder Du bist hoffnungslos mit programmieren überfordert.
Ich assoziiere Deinen Nick schon mit "Hoffnungsloser Fall". Nicht böse gemeint, aber es scheint einfach nichts für Dich zu sein.

Aha ... was ist für Dich gute Literatur?

Wer sieht mich alles noch als hoffnungsloser Fall an?

nman

Ist doch scheiszegal, mit Verlaub. Knie dich dahinter und fertig.

Hast du noch Fragen zum Threadthema, oder ist es dir inzwischen klar?

silent_max schrieb:

Wer sieht mich alles noch als hoffnungsloser Fall an?

Ich würd mich von den anderen nicht unterkriegen lassen. Jeder hat mal angefangen. Bei manchen ist der Anfang hat etwas schwerer.

Was man vielleicht mal erwähnen sollte. Das C++, das 90% der Dozenten lehren ist nicht das C++, das in einem guten Lehrbuch gelehrt wird. Du hast doch den "C++ Programmierer" vom Breymann. Ich kann mich jetzt nicht daran erinner, dass dort irgendwie printf und Zeigergefrickel drankamen. Wenn du also gleichzeitig das Zeug vom Dozenten und den Breymann lernst, schießt du dich selbst ins aus. Oder wie siehst du das?

silent_max

nman schrieb:

Ist doch scheiszegal, mit Verlaub. Knie dich dahinter und fertig.

Hast du noch Fragen zum Threadthema, oder ist es dir inzwischen klar?

Eine Frage zum Thema hätte ich noch ...

In welchem Zusammenhang ist die Zeigerarithmetik nötig? Mir fällt gerade kein Anwendungsbeispiel ein.

nman

Immer dann, wenn du einen Zeiger auf irgendeine Stelle irgendeines Arrays hast und ihn verschieben moechtest. Wobei du Pointerarithmetik in modernem C++ generell deutlich seltener sehen wirst, als in C-Programmen.

Max, schaust du dir das mal bitte an:
http://www.c-plusplus.net/forum/p1330752#1330752

Ein Zeiger belegt auf deinem Rechner vermutlich 4 Byte. Bleiben wir mal dabei.
Ein Int-Zeiger ist nicht viel anderes als ein int selbst. Ein int speichert Zahlen. Ein Zeiger auf Int (Int-Zeiger) speichert, wo andere Ints gespeichert sind, also die Adressen der Ints. Das selbe gilt für ein char. Ein char speichert ein Zeichen. Ein char-Zeiger speichert die Adresse von einem anderen char.

int zahl = 5;  // zahl ist irgendwo im Speicher gespeichert, sagen wir diese Speicherstelle heißt 0x01

cout << zahl; // gibt zahl aus, also 5.

int* adresseVonZahl = &zahl; // In adresseVonZahl steht nun 0x01, wir hätten auch direkt:
// int* adresseVonZahl = (int*)0x01; machen können, lass das mal aber lieber ;)

// gut, adresseVonZahl weiß wo sich unsere variable zahl befindet. gehen wir doch mal dahin.
cout << adresseVonZahl; // gibt 0x01 aus.
cout << *adresseVonZahl; // mit * wird zu der gespeicherten Adresse gegangen, also
// wenn wir zu 0x01 gehen, sind wir bei unserer Variable zahl, also wird 5 ausgeben.

Soweit, so klar?

Machen wir jetzt ein bisschen Zeigerarithmetik:

int a[2] = {11, 12}; // Sieht im Speicher so aus:
/* Speicher ( Adresse:Name:Wert) 
 ----------------------- 
|  1000 |  a[0]  |  11  | 
 ----------------------- 
|  1004 |  a[1]  |  12  |         
 ----------------------- 
*/ 

// Ein Integer ist bei dir vier Byte groß, also belegen wir vier Byte im Speicher. Danach kommt das nächste int.

// holen wir uns doch die Adresse von erstem Wert
int* ersteAdresse = &a[0]; // hier steht nun 1000 drin. Info: Bei Arrays ist &a[0] das selbe wie einfach nur a, also der Arrayname.

cout << ersteAdresse << " " << *ersteAdresse; // gibt 1000 11 aus.

// wir haben ein int array, wir wissen das ints vier byte groß sind, wir wissen das arraywerte im speicher nacheinander kommen
// dann lass uns doch mal zum nächsten array wert wandern

int* zweiteAdresse = ersteAdresse + 1; // unser compiler sieht hier, wir wollen ein int-adresse weiter 
// gehen, der compiler macht dann daraus ungefähr(*):

// int* zweiteAdresse = (int)ersteAdresse + 1*sizeof(int); nehme die 1000 und addiere vier bytes drauf, um zum nächsten zu gelangen
// sizeof(int) deswegen, weil int nicht überall gleich groß ist. 

cout << zweiteAdresse << " " << *zweiteAdresse; // gibt 1004 12 aus.

// wir können auch direkt mehr weiter gehen:
int* outOfSpace = ersteAdresse + 2; // achtung, da sind wir bei unserem array aber schon über die Grenze!!!

(*) Den TE bloß nicht überstrapazieren.

Mehr ist Zeigerarithmetik nicht.

@KasF
Du musst auch dazuschreiben, dass die 0x01 und die 1000 nur von dir ausgedachte Beispieladressen sind.
Diese Werte sind in realen Programmen ganz andere.

Anwendungsbeispiel:

int a[5] = {1,2,3,4,5};

// gebe mit hilfe der zeigerarithmetik all zahlen in a aus.

int* adresse = a; // = &a[0];

cout << *adresse; // 1

adresse = adresse + 1; // gehe sizeof(int) bytes weiter, also zum nächsten wert

cout << *adresse; // 2

adresse = adresse + 1;
cout << *adresse; // 3 , usw usf ..

// das schreit nach einer schleife:

adresse = a; // zurück zum anfang.
for(int i = 0; i < 5; ++i)
{
   cout << *adresse << " ";  // ausgeben
   adressen = adresse + 1;   // und eins weiter gehen
}

das kann man ein bisschen schöner machen:
adresse = a; // zurück zum anfang.

const unsigned int arrayGroesse = sizeof(a)/sizeof(int); // ergbibt 5! die gesamt größe des arrays durch die größe eines elements teilen.

for(int i = 0; i < arrayGroesse; ++i)
{
   cout << *adresse << " ";  // ausgeben
   ++adresse;   // und eins weiter gehen
}

Das reicht erstmals.

Sone schrieb:

Du bist kein Programmierfachprofi.
Dein Beispiel ist falsch und schlecht.

Mein Code funktioniert, die eine Warnung bei der Zeigerzuweisung kann man verschmerzen.

Siehe:

#include <stdio.h>

int main(){
  int a[] = {1, 3};
  int *pa=&a;
  pa = pa + a[0]; 

  for (int i = 0; i < 2; i++){
    printf("a[%i] = %i\n", i, a[i]);
  }
  return 0;
}

gcc -std=c99 -Wall -o "zeigerarithmetik" "zeigerarithmetik.c" (im Verzeichnis: F:\)
zeigerarithmetik.c: In function 'main':
zeigerarithmetik.c:5:11: warning: initialization from incompatible pointer type [enabled by default]
Kompilierung erfolgreich beendet.

ohoh schrieb:

Sone schrieb:

Du bist kein Programmierfachprofi.
Dein Beispiel ist falsch und schlecht.

Jup, sollte so heißen:
int a[] = {1, 3};
int *pa=a;
pa+=1; // oder ++pa;  <--- Das ist FALSCH!

Dein Code ist falsch.
Der Threadstarter wollte mit den Werten einer Variable rechnen und nicht mit einer absoluten Zahl.
Siehe dazu auch sein Verständnisproblem am Anfang, das du reingebracht hast, nachdem du mit konstanten Zahlen, anstatts mit Variablenwerten gerechnet hast.

Deswegen steht bei mir a[0] und den += Operator versteht ein Anfänger nicht unbedingt, deswegen sollte man es ausgeschrieben hinschreiben.
richtig ist also:
pa = pa + a[0];

so wie ich es zu Beginn schrieb.

Sone

den += Operator versteht ein Anfänger nicht unbedingt

Du machst Scherze oder? Den sollte selbst ein absolute Anfänger ohne Probleme verstehen können.

gcc -std=c99 -Wall -o "zeigerarithmetik" "zeigerarithmetik.c" (im Verzeichnis: F:\)
zeigerarithmetik.c: In function 'main':
zeigerarithmetik.c:5:11: warning: initialization from incompatible pointer type [enabled by default]

Wir sind hier im C++ Forum! Was ist denn mit dir los?