Im Skript meines Lehrers zu C++ steht in Bezug auf die Zeigerarithmetik folgendes:

Addition/Subtraktion Zeiger und Integerwert führt zu:
Zeiger = Zeiger + (Integerwert * Länge des Objektes)

Im Buch "Der C++ Programmierer" steht es jedoch anders und einleuchtender (jeder, der das Buch hat, liest bitte die Seiten 192 und 193 durch, zu zitieren würde zu lange dauern)...

Nach wem soll ich mich jetzt richten??

Danke für die Antworten im Voraus.

Gruß

Max

Wenn du schreibst

Zeiger = Zeiger + Integerwert

Wird das vom Compiler umgewandelt in

Zeiger = Zeiger + (Integerwert * Länge des Objektes)

d.h. du brauchst dich nicht darum zu kümmern, wie lang das Objekt jetzt genau ist.

Ich verstehe es halt nicht ...

Also machen wir es an einem Beispiel:

int a = 5;
int *pa=&a;

Wenn ich jetzt nach

Zeiger = Zeiger + Integerwert

gehe, dann müsste es ja wie folgt heißen:

pa = pa + 5;

Oder verstehe ich da etwas verkehrt??

Oder verstehe ich da etwas verkehrt??

Ja, das tust du. Dein Code enthält nämlich gar keine Zeigerarathmetik.

Ein Beispiel für Zeigerarathmetik wäre

int a = 5;
int *pa=&a;
pa = pa+4; // Setzt pa auf pa + ( 4 * sizeof(int) )

gehe, dann müsste es ja wie folgt heißen:

Was ist "es"?

silent_max schrieb:

pa = pa + 5;

Oder verstehe ich da etwas verkehrt??

Das kommt darauf an, was du glaubst, verstanden zu haben. Die Zeile wird zwar kompilieren, ist aber undefiniertes Verhalten und völliger Quatsch.

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?

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.

Dies sollte natürlich lauten:

// Array mit den Werten 1 und 3 initialisieren

Der zweite Adresswert ist natürlich:
39F3CA06

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

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: 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??

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.

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.

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.

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?

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

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?

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.

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.

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.

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.

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?