#include<iostream.h>
int reti(int *p, int a)
{
int t = *(p+a);
return ++t/2;
}
void main()
{
int i, a = 2, b = 9, *z;
float c = 1.0;
int v[5]={1,3,5,7,9};
c += ++a + b++/2.0;
cout << a << endl << b << endl << c << endl;
z = &v[0];
for( i = 0; i < 5; i++)
cout << i << endl << reti (z, i) << endl;
}

Zuerst wird einmal a, b, c auf dem Bildschirm ausgegebn: 3, 10, 8,5
Dannach wird reti(int *p, int a) aufgerufen. Doch was dann passiert verstehe ich leider nicht. Kann mir das jemand vielleicht erklären? Wäre sehr dankbar

Zuerst wird einmal a, b, c auf dem Bildschirm ausgegebn: 3, 10, 8,5

Zuvor werden allerdings allerhand Bezeichner definiert (und tlw. auch initialisiert).

Dannach wird reti(int *p, int a) aufgerufen.

Das passiert doch erst ganz am Schluss Dazwischen geschieht ebenfalls noch etwas.

Doch was dann passiert verstehe ich leider nicht. Kann mir das jemand vielleicht erklären? Wäre sehr dankbar

Was verstehst du denn konkret nicht? Da es sich hierbei um die wirklich elementaren Grundlagen handelt, empfehle ich ein Buch/Tutorial deiner Wahl noch einmal durchzusehen.

Gruß Caipi

int reti(int *p, int a)
{
int t = *(p+a);
return ++t/2;

Die for Schleife verstehe ich auch noch. Also er gibt i und dann reti(z, i) aus. Nur was macht er in diesem Teil ? bzw. Wie kommt man drauf was reti(z, i) ist ?

Die for-Schleife wird 5mal durchlaufen. Bei jedem Schleifen-durchlauf wird die Funktion reti() mit dem Argument z (einem Zeiger auf das erste Element des Arrays v) und dem aktuellen Zähler i, der nach jedem Schleifendurchlauf erhöht wird, aufgerufen.

Die Paramter der Funktion reti(), also int* p und int a, speichern die übergebenen Argumente. D.h. p speichert den Wert von z (die Adresse an welcher das Array v beginnt) und a speichert den Wert von i.

In der Funktion reti() wird nun eine Variable vom Typ int t initialisiert. Sie erhält den Wert, der an der Anfangsadresse des Arrays v (die Adresse steht in p) + dem Wert i (der den Wertebereich zwischen 0 und 4 annehmen kann) steht.
Der Ausdruck (p + i) besagt allgemein: Gehe zur Adresse, die in p steht, addiere den Wert von i hinzu (bzw. genauer isizeof(int), aber das macht der Compiler automatisch) und gebe den Wert, der an dieser Stelle des Speichers steht, zurück. (Dieser wird dann in t gespeichert).

Gruß Caipi

Es tut mir leid, dass ich mit dem Mist nerve, aber du solltest statt

#include <iostream.h>

doch lieber

#include <iostream>
using namespace std;

benutzen

Außerdem heisst es:

int main()
{
return 0;
}

chrische

Im nächsten Schleifendurchlauf ist i = a = 1 und z = p = 3. Dann ist int t= (3+1) dann ++t/2. Das ergibt dann eine 2.5 aber da int = 2

Im daraufflogenden Schleifendurchlaf ist i = a = 2 und z = p = 5. Dann ist int t = (2+5) dann ++t/2. Das ergibt dann 4. Und das wäre ja falsch.

Was mache ich denn bei der Berechnung falsch ?

Gehen wir mal die Schleife durch. Beim ersten Schleifendurchlauf wird i = a = 0 und z = p = 1. Dann int t = (0+1) dann ++t/2. Das ergibt dann eine 1.

Hier gehts schon los. z = p ist nicht 1, sondern die Adresse wo 1 in v steht.

Hast Du Dich schon etwas ausführlicher mit Zeigern und Zeigerarithmetik (auch der Wert in Klammern ist nicht (0+1) sondern WertAn(AdresseVon(v) + 1) ) auseinandergesetzt?