Problem mit Referenzen

Hallo,
ich möchte in einem C-Programm eine Variable x per Referenz an eine Funktion a übergeben. Die Funktion a soll diese Referenz dann an die Funktion b übergeben.
Die Frage ist nun wie der Funktionsaufruf für die Funktion b auszusehen hat. b(x) funktioniert leider nicht.

Der Code sieht schematisch so aus:

int main
{
    int x;
    a(&x);
}

void a(int* x)
{
   b(???);
}

void b(int* x)
{...}

Gruß
Hugh

MFK

HughJazz schrieb:

b(x)

ist genau richtig.

HughJazz schrieb:

funktioniert leider nicht.

ist keine ausreichende Fehlerbeschreibung.

dawa85

b(&*x);

also die Adresse vom Ziel wird da nochmals übergeben. mit b(x); klappts aber auch, weil in b steht ja die Adresse

void b(int* x)
{
	cout << *x;
	cin.get();
}

void a(int* x)
{
   b(x);
}

int main()
{

    int x;
	x=4;
    a(&x);
}

wow, das ging ja schnell

Also, wenn ich mir sowohl in main als auch in b Inhalt und Speicheradresse mit printf ausgeben lasse stimmen diese Werte nicht überein.

Falls es wichtig ist: die Software läuft und kompiliert unter Linux.

dawa85 schrieb:

b(&*x);

Hab ich auch schon versucht, führt zum selben Verhalten.

dawa85

HughJazz schrieb:

wow, das ging ja schnell

Also, wenn ich mir sowohl in main als auch in b Inhalt und Speicheradresse mit printf ausgeben lasse stimmen diese Werte nicht überein.

Falls es wichtig ist: die Software läuft und kompiliert unter Linux.

in b um Speicheradresse auszugeben:
cout << b;

in main um Speicheradresse auszugeben:
cout << &x

Bashar

HughJazz schrieb:

Also, wenn ich mir sowohl in main als auch in b Inhalt und Speicheradresse mit printf ausgeben lasse stimmen diese Werte nicht überein.

Zeig doch mal Code. BTW die Dinger heißen Zeiger, nicht Referenzen.

MFK

HughJazz schrieb:

Also, wenn ich mir sowohl in main als auch in b Inhalt und Speicheradresse mit printf ausgeben lasse stimmen diese Werte nicht überein.

Du musst in b natürlich *x benutzen. Hast du das getan? Zeig doch mal den Code.

dawa85

HughJazz schrieb:

wow, das ging ja schnell

Also, wenn ich mir sowohl in main als auch in b Inhalt und Speicheradresse mit printf ausgeben lasse stimmen diese Werte nicht überein.

Falls es wichtig ist: die Software läuft und kompiliert unter Linux.

in b um Speicheradresse auszugeben:
cout << x;

in main um Speicheradresse auszugeben:
cout << &x

weil in b ist der Inhalt von x die Speicheradresse von x in Main.
in main ist der Inhalt von x der entsprechende Wert. Wie in dem Beispiel unten z.B. 4

void b(int* x)
{
	cout << x << endl;

}

void a(int* x)
{
   b(x);
}

int main()
{

    int x;
	x=4;
    a(&x);

	cout << &x << endl;
	cin.get();
}

so bekommst du 2mal dieselbe Speicheradresse ausgegeben

Ich hab mich gerade mal aufklären lassen wieso das nicht gehen kann: Die beiden Funktionen laufen in unterschiedlichen Prozesse die untereinander mit messages kommunizieren. Jetzt wird das Ganze wohl doch ein bischen komplizierter...

Danke für eure Hilfe

*D*Evil

ANSI C kennt Streams? Oha ...

#include <stdio.h>

void foo(int* x) { printf(".foo: %p => %d", x, *x); bar(x); }
void bar(int* x) { printf(".bar: %p => %d", x, *x); }

int main()
{
    int x = 4;
    printf(".main: %p => %d", &x, x);
    foo(&x);
    getchar();
}

...

Ich glaube in der Überschrift gelesen zu haben "Problem mit Referenzen"
int* ist aber ein Pointer keine Referenz
int& ist die Referenz
Also

void b(int& x)
{
    cout << x;
    cin.get();
}

void a(int& x)
{
   b(x);
}

int main()
{

    int x;
    x=4;
    a(x);
}

Braunstein

Nur das es in AnsiC keine Referenzen gibt.

Braunstein schrieb:

Nur das es in AnsiC keine Referenzen gibt.

C kennt keine 'reference types' im sinne von C#, Java o.ä. in C nimmt man eben pointer dafür. der wichtigste unterschied ist ja nur, dass bei referenzen mit verweisen auf objekte gearbeitet wird, während bei 'by value' das objekt selber kopiert wird.

int a;
...
f (a);   // call 'by value', das objekt selbst wird kopiert
g (&a);  // call 'by reference', es wird ein verweis auf das objekt übergeben

Und bei g() übergibst du ein Objekt "by value" vom Typ T*.

Tim schrieb:

Und bei g() übergibst du ein Objekt "by value" vom Typ T*.

ja, das ist aber technisch bedingt. die referenz bzw. der pointer wird 'bei value' übergeben. es ändert aber nichts an der referenzsemantik, die dahinter steckt.

Es geht hier auch mehr um Terminologie als um Semantik.

Edit: Aber ich erwarte nicht (mehr), dass du das verstehst.

Tim schrieb:

Es geht hier auch mehr um Terminologie als um Semantik.

ist doch kein problem:

ISO/IEC 9899:1999 schrieb:

A pointer type describes an object whose value
provides a reference to an entity of the referenced type.

Also findest du auch das "call by reference" von dem du hier immer redest?

Tim schrieb:

Also findest du auch das "call by reference" von dem du hier immer redest?

wo? im C-standard? nein, aber wieso sollte 'call by reference' dort ausdrücklich erwähnt sein? wenn referenzsemantik in C mit pointern ermöglicht wird, sollten damit auch 'calls' gehen. ich weiss gar nicht, warum du damit solche schwierigleiten hast, oder meinst du den 'referenzbegriff' haben pointerlose programmiersprachen für sich gepachtet?