C und "call by reference"

Hobbyprogrammierer schrieb:
> Ich wollte eigentlich, daß mir ein Unterprogramm ein array füllt und es
> leer "call by reference" übergeben. Nun lese ich aber, daß das nur in
> C++ und nicht in C geht.

Wo/Was hast Du das/da gelesen?

Ein Array kann man in C grundsätzlich nur als call by reference 
übergeben.
Lies mal in deinem C-Buch nach, warum das so ist.

Oliver

Pass auf, dass Du die C++ Referenz Übergabe nicht mit Call by Reference 
verwechselst.

In C++

1

  void mach_was(uint16_t& array)

2

  {

3

4

  }

In C++ wird "Call by Reference" mit einem Pointer übergeben:

1

  void mach_was(uint16_t* array)

2

  {

3

4

  }

Grüsse,
René

Beitrag "call by Reference? (&)"

Jedenfalls hat der Threadstarter von obengenanntem Link im Prinzip das 
gleiche Problem wie ich.

Ritchie schreibt:

1.8 Arguments - Call by Value
One aspect of C functions may be unfamiliar to programmers who are used 
to some other languages, particulary Fortran. In C, all function 
arguments are passed ``by value.'' This means that the called function 
is given the values of its arguments in temporary variables rather than 
the originals. This leads to some different properties than are seen 
with ``call by reference'' languages like Fortran or with var parameters 
in Pascal, in which the called routine has access to the original 
argument, not a local copy.

Also scheint's so ohne weiteres nicht zu gehen.

Rene H. schrieb:
> In C++ wird "Call by Reference" mit einem Pointer übergeben:

Natürlich meinte ich beim zweiten Beispiel:

In C......

Grüsse,
René

>d.H. obwohl die Parameterübergabe als "value" erfolgt, hat deine
>Funktion nacher eine "reference" auf die Array-Inhalte, und kann diese
>ändern.

Tatsächlich, es geht.
Danke.


Jetzt hab ich aber eine neue Anomalie:

Byte * Data;
...
printf("%02i: %02X\t\t", i*8+j, Data);
...

Jetzt sollte eigentlich (der Logik nach was ich heute gelernt habe )die 
Adresse von Data angezeigt werden, oder?
Stattdessen wird (was durchaus wünschenswert ist) der Inhalt auf den der 
Zeiger zeigt, angezeigt.
Oh Mann, das schwächt.

Die Verwirrung ist perfekt; letzter Post war ein Irrtum.

Hobbyprogrammierer schrieb:
> Jetzt sollte eigentlich (der Logik nach was ich heute gelernt habe )die
> Adresse von Data angezeigt werden, oder?

Für Zeiger gibt es bei printf den Formatspecifier %p.
Ein Zeiger ist kein (unsigned) int

Stefan Rand (srand) schrieb:

Klaus Wachtler schrieb:
>> Darüber kann man jetzt philosphieren.

> Eigentlich nicht.

Eigentlich schon.

> call-by-value und call-by-reference sind Sprachfeatures. Und C hat
> letzteres schlicht nicht.

Es hat aber einen Meachanismus, der genau das gleiche bewirkt. Manche 
Bücher unterscheiden deshalb nicht bei call-by-reference zwischen C und 
C++ siehe Beispielsweise hier

http://openbook.galileocomputing.de/c_von_a_bis_z/012_c_zeiger_006.htm

"In solch einem Fall bietet es sich an, statt der Variablen radius 
einfach nur die Adresse der Variablen als Argument zu übergeben. Die 
Übergabe von Adressen als Argument einer Funktion wird call-by-reference 
genannt. Das Prinzip sehen Sie im abgeänderten Programmbeispiel:"

Hobbyprogrammierer schrieb:
>>d.H. obwohl die Parameterübergabe als "value" erfolgt, hat deine
>>Funktion nacher eine "reference" auf die Array-Inhalte, und kann diese
>>ändern.
>
> Tatsächlich, es geht.

Das ist übrigens ein Grund warum es "const" gibt, damit Du dem Compiler 
sagen kannst dass Du zwar den Pointer auf das erste Array-Element 
übergibst, aber nicht willst dass darüber dann die Array-Elemente 
(versehentlich) modifiziert werden.

Hobbyprogrammierer schrieb:
> Byte * Data;
> ...
> printf("%02i: %02X\t\t", i*8+j, Data);
Byte *Data; -> Ist ein Pointer (Zeiger) der auf den Anfang(Adresse) der 
Speicherzellen von Data zeigt.

Im printf wird die Adresse der Speicherzelle von Data ausgegeben.

Besseres Beispiel, vielleicht verständlicher(?):

1

char *bp; /* Buffer pointer , zeigt jetzt ins nirgendwo */

2

3

bp = (char *)malloc(sizeof(char)*10); /* hat jetzt die Startadresse 

4

die von malloc geliefert wurde, oder NULL. 

5

Wir nehmen mal an, dass malloc != NULL geliefert hat.*/

6

7

printf("%x", bp); /* Gibt die Adresse von bp aus */

8

9

*bp = 'A';  /* Schreibt das Zeichen 'A' an die Startadresse von bp*/

10

*(bp+1) = NULL; /* String terminieren */

11

printf("%s",*bp); /* Gibt den Inhalt von bp aus */

Hoffe, dass ich etwas zur Verwirrung beitragen konnte.

Zu Pointern, Adressen, ... hilft vielleicht folgendes Video:

http://et-tutorials.de/3368/pointer-in-c/

Rufus Τ. Firefly schrieb:
> Dann ist es formaljuristisch auf allen Plattformen korrekt.
>
> Solange aber sizeof (int) == sizeof (int *) ist, funktioniert die
> --unsaubere-- Variante auch.

Allerdings haben Pointer auf manchen Plattformen etwas spezielle 
Schreibweisen, die %p berücksichtigen kann, %i aber nicht. Außerdem 
werden bei %i die Werte dezimal angezeigt und bei hohen Adressen ggf. 
auch negativ.

Klaus Wachtler schrieb:
> Bei C++ sind Referenzen ja intern wieder ebenso realisiert, nur daß man
> den zugehörigen Zeiger nicht direkt sieht.

Sie können so implementiert sein, müssen es aber nicht.

Gelegenheitsprogrammierer schrieb:
> Stefan Rand (srand) schrieb:
>
> Klaus Wachtler schrieb:
>>> Darüber kann man jetzt philosphieren.
>
>> Eigentlich nicht.
>
> Eigentlich schon.

Philosophieren kann man darüber. Wenn man aber doch lieber technisch als 
philosophoisch diskutieren will, bekommt man bei Übergabe eines Arrays 
aus int an eine Funktion einen Zeiger auf einen int und nicht eine 
Referenz auf ein Array aus int.

>> call-by-value und call-by-reference sind Sprachfeatures. Und C hat
>> letzteres schlicht nicht.
>
> Es hat aber einen Meachanismus, der genau das gleiche bewirkt.

Daß es das eben nicht tut, sieht man schon daran, daß sizeof innerhalb 
der Funktion die Größe eines Zeigers und nicht die des Arrays liefert.

> Manche Bücher unterscheiden deshalb nicht bei call-by-reference zwischen
> C und C++ siehe Beispielsweise hier
>
> http://openbook.galileocomputing.de/c_von_a_bis_z/012_c_zeiger_006.htm
>
> "In solch einem Fall bietet es sich an, statt der Variablen radius
> einfach nur die Adresse der Variablen als Argument zu übergeben. Die
> Übergabe von Adressen als Argument einer Funktion wird call-by-reference
> genannt. Das Prinzip sehen Sie im abgeänderten Programmbeispiel:"

Es ist nicht automatisch richtig, nur weil's in irgendeinem Buch steht. 
Zur Vereinfachung kann man es auch anfangs auch abstrahiert als 
"call-y-reference" bezeichnen, aber richtig ist das eigentlich nicht.