Problem mit einfachem C++ Programm (Arrays)

[Medic]

Hallo!

Ich bin ein Anfänger was C++ betrifft. Im Moment arbeite ich ein Einsteiger C++ Buch durch und bin beim Kapitel "Variablenfelder" (alle Quelltexte kompiliere ich unter RedHat Linux mit dem GNU Compiler gcc). Dort ist folgendes Programm leider ohne erleuchtende Erklärung abgedruckt:

#include <iostream.h>

using namespace std;

void input(int *a)
{
int y;

  for(y=0;y<10;y++)
    { 
       cout << "bitte Zahl " << y+1 << " eingeben:";
       cin >> a[y];
     }
}

void calc(int *a)
{
int y;

  for(y=0;y<10;y++)
    a[y]*=2;
}

void output(int *a)
{
int y;

  for(y=0;y<10;y++)
     {
         cout << "Das Ergebnis der " << y+1;
         cout << ". Multiplikation ist " << a[y] << endl;
     }
}

int main()
{
int x[10];

  input(x);
  calc(x);
  output(x);
}

Soweit so gut (ich hab das Programm bis jetzt noch nicht ausprobiert, mir geht es erstmal um das logische Verständnis). #include usw. ist klar. void input(int *a) heißt, daß die Funktion keinen Wert zurückliefert und das an sie der Inhalt (Dereferenzierungsoperator mit *) einer bestimmten Adresse übergeben wird. Die Funktion zählt zehn mal und erwartet vom Benutzer 10 Eingaben, die er im Array a abspeichert. Stimmt das?
Der Inhalt der zweiten Funktion ist mir ziemlich unklar...was ist a[y]*=2 für ein Ausdruck?
Die dritte Funktion ist wohl wie die erste.
Den Sinn des Inhaltes in der main-Funktion konnte ich bisher auch nicht ergründen. Die Funktionsnamen scheinen so etwas wie Feldnamen zu sein. Aber wieso liefern die Funktionen keinen Rückgabewert? Alle Variablen werden doch gelöscht beim Verlassen, wie kann dann mit den Werten weiter gerechnet werden?

 

[softrunner]

Hi Medic !

Die zweite Funktion multipliziert jeden Wert innerhalb des Array a mit 2. Der Ausdruck a[y]*=2 ist die kompaktere Form von a[y] = a[y] * 2.
Ein Ausdruck wie z.b. a = a + 1 wird in C üblicher Weise so notiert: a+=1.

mfG,softrunner

 

[Nornagest]

Den *= Operator hat Softrunner ja bereits erklärt.
Was du noch verstehen musst sind Zeiger, zugegeben, das ist am Anfang nicht ganz leicht.
Also: in main() wird ein Array aus 10 int Variablen erzeugt.
An alle drei Funktionen wird dann ein Zeiger auf dieses Array übergeben.
(genaugenommen auf das erste Element)
Es wird also keine Kopie der Variablen erzeugt, die dann an die Funktion übergeben wird sondern die Funktion arbeitet direkt mit den in main() erzeugten Variablen, deshalb ist auch kein Rückgabewert nötig.
mfg
Nornagest

 

[Medic]

Hallo ihr zwei!

Danke erstmal...daß a[y]*=2 gleich a[y] = a[y] * 2 ist wurde ein paar Kapitel zuvor erklärt, aber es war mir dummerweise wieder entfallen :-/

Nornagest:

An alle drei Funktionen wird dann ein Zeiger auf dieses Array übergeben.

Die Funktion weiss durch den Ausdruck void input(int *a) daß es ein Zeiger ist oder? Also: Funktion input wird ein Array von Zehn Variablen übergeben, die beliebig belegt werden können. Danach multpliziert Funktion calc jeden Feldbestandteil mit 2. Schließlich gibt Funktion output alle zehn Zahlen mit Text aus. Die Zahlen werden beim Verlassen der Funktionen nicht gelöscht, weil auf sie nur die Zeiger gerichtet sind, und im Endeffekt die Inhalte der quasi- globalen Variablen in der main Funktion verändert werden....hab ich das einigermaßen richtig verstanden?

 

[Nornagest]

Fast ganz richtig:
1. Die Funktion die den Zeiger bekommt weiß nicht wie groß das Array ist, deshalb wird häufig bei ähnlichen Funktionen noch ein int mit übergeben der das angibt.
2. Es wird ein Zeiger übergeben, dieser zeigt auf das erste Element (enthält also dessen Addresse).
Wenn amn jetzt auf ein späters Element mit dem Index Operator ([ ]) zugreift, errechnet das Programm mit Hilfe der Größe der Elemente (hier int) die richtige Addresse errechnet und auf diese zugegriffen.

 

[Medic]

Hallo,

okay eine Frage hab ich noch. Ein Beispiel aus einem Programm:

int x=24, *z;

z=&x;

Wieso muss ich hier noch mal eine Adress-Zuweisung mit z=&x vornehmen? Wenn ich einen Zeiger auf eine Variable definiere (mit *z) dann ist doch die Adresse dort automatisch gespeichert oder nicht?

 

[Nornagest]

Leider falsch gedacht
Denn anstatt:

int x=24, *z;

könntest du ebensogut:

int x=24;
int *z;

du definierst einen Zeiger, aber wenn du ihm nicht sofort eine Adresse zuweist, usst du das später tun, denn sonst zeigt er irgendwo hin.

int x=24, *z=&x;

macht das was du denkst.

 

[Medic]

Hallo Nornagest,

danke deine Antworten waren hilfreich.

 

[Teaser]

void input(int *a) heißt, daß die Funktion keinen Wert zurückliefert und das an sie der Inhalt (Dereferenzierungsoperator mit *) einer bestimmten Adresse übergeben wird

Nicht ganz:

Du musst klar unterscheiden zwischen Call By Value und Call By Reference.
Bei dir liegt Call By Reference vor. Du schreibst der Inhalt einer bestimmten Adresse wird übergeben. Ganz korrekt müßte man sagen das Variable a auf einen bestimmten Speicherplatz zeigt (eine Referenz auf diese Adresse hat). Der Wert wird also quasi nicht übergeben sondern direkt manipuliert. Wenn du nun Call By Value hättest würde der Wert übergeben, also eine Kopie des Wertes der Variable geholt.

Falls du es noch nicht weißt: Daraus ergeben sich auch ganz neue Möglichkeiten da du kein return mehr brauchst, und pro Funktion ist ja nur ein return Möglich das diese auch gleich abricht. Was du noch alles machen kannst möchte ich vorerst nicht näher erläutern, das überlasse ich lieber Profis.

Gruß Teaser