Pointer und Struct Verständnisproblem

Azador

Sorry, wenn die Frage hier überaus blöd klingt, aber es wäre nett, wenn es jemand einfach kurz beantworten könnte.

Ich hab mit Programmierung eher weniger am Hut, muss mich jedoch nun damit etwas intensiver auseinander setzen. Grundlagen sind schon welche da, aber mir fehlts gerade an einer Stelle etwas mit dem bildlichen vorstellen.

Folgendes: Kann mir jemand verständlich kurz beschreiben wie ich mir die Funktionsweise folgender Funktion vorstellen kann

void ReceiveMessage(
struct *Message
);

Was ich bis jetzt sehe. Die Funktion hat keinen Rückgabewert und heißt ReceiveMessage. Der Pointer und der Struct machen mir Probleme.

Struct ist ein Datentyp, der unterschiedliche Datentypen enthalten kann. Was heißt das jetzt im Zusammenhang mit dem Pointer? Ich dachte ein Pointer zeigt auf die Adresse und hat somit z.B. einen int Wert?

Ich hoffe ich konnte mein Problem anschaulich genug schilder. Danke schon mal.

Gruß
Azador

_matze

Das funktioniert so nicht. Wo hast du das denn her? Das hast du doch niemals aus einem bestehenden, funktionierenden Code kopiert. Mal abgesehen davon, dass das Semikolon fehlt, fehlt hier auch der Name des Typen. 'struct' alleine reicht nicht. Poste mal den korrekten Code, dann sehen wir weiter.

EDIT: Hab grad noch gesehen, dass das ja ein Prototyp ist. Dann feht natürlich kein Semikolon, der Rest stimmt aber weiterhin (bzw. stimmt eben nicht ).

helferlein

ich gehe mal davon aus das "ReceiveMessage" eine Nachricht empfangen soll

die Deklaration sieht bestimmt so aus:

void ReceiveMessage(
struct Message * // sternchen hier vorne!!
);

es handelt sich einfach um eine struct mit namen "Message".
Du legst ein objekt davon an und übergibst der Funktion die addresse als zeiger
die funktion kann über die addresse an dein objekt kommen und füllt dieses aus.

Azador

Danke schon mal für die Antwort und sehr schön. Mehr Fragen meinerseits. Was ist ein Prototyp genau?

Sorry, ich hab mir den Code nochmal angeschaut und war zu schnell mit dem kopieren. Richtig sieht er so aus:

void ReceiveMessage(
MsgContextType *Message
);

Zu MsgContextType hab ich folgendes gefunden:
Type: struct typedef
und dann folgend die Aufzählung der Datentypen der enthaltenen Elemente im struct

_matze

Ein Funktionsprototyp ist die Deklaration einer Funktion (um sie bekannt zu machen) und befindet sich üblicherweise in einer Header-Datei (Endung .h). Die Definition/Implementation befindet sich dann in der .c-Datei, sie enthält den Funktionsrumpf, also den tatsächlichen Inhalt (Folge von Anweisungen).

Nur anhand des von dir geposteten Prototypen wird dir niemand die Funktionsweise dieser Funktion erklären können (es sei denn, er kennt sie). Dazu ist halt die Implementation nötig.

void MeineFunktion(int par1,intpar2);  //Deklaration/Prototyp

void MeineFunktion(int par1,intpar2) {  //Implementation
  //Folge von Anweisungen
}

Azador

Ok, danke für die Beschreibung.

Die genaue Funktionsbeschreibung ist nicht nötig mir gehts eher um die Übergabeparameter. Da hackts bei mir mit der Vorstellung.

Ich rufe die Funktion "ReceiveMessage" auf und übergebe dabei einen Pointer auf ein Struct. Sehe ich das richtig?

Wie unterscheidet der Pointer die unterschiedlichen Elemente im Struct? Mal angenommen die Funktion will auf das dritte Element im Struct zugreifen?

_matze

Azador schrieb:

Ich rufe die Funktion "ReceiveMessage" auf und übergebe dabei einen Pointer auf ein Struct. Sehe ich das richtig?

Jepp.

Azador schrieb:

Wie unterscheidet der Pointer die unterschiedlichen Elemente im Struct? Mal angenommen die Funktion will auf das dritte Element im Struct zugreifen?

Du musst nur den Zeiger dereferenzieren, dann greifst du einfach auf die Elemente der Struktur zu.

//entweder
(*Message).meinElement

//oder direkt mit dem dafür vorgesehenen Operator
Message->meinElement

Ein Zeiger auf ein int gibt dir ja schließlich auch die Möglichkeit, auf den Wert der Variable, auf die gezeigt wird, zuzugreifen. Bei structs ist es nicht anders.

Azador

Danke, jetzt wird mir so schon einiges klarer.

Andere Frage noch zu der Funktion. Was passiert mit dem *Message Zeiger, wenn ich aus der Funktion einen FunktionsZeiger mache?

Wie würde dann der Code dafür aussehen? So:?

[...]
struct (*ptr) (*Message);
ptr = ReceiveMessage;
[...]

Das ist doch irgendwie ein Pointer auf einen Pointer?

NDEBUG

struct (*ptr) (*Message);

ist ein Fehler: man würde es so interpretieren ... ptr ist ein poitner auf eine Funktion die einen parameter von unbekanntem typ (FEHLER!) erwartet und ein nicht näher bezeichnetes struct (FEHLER!) zurückgibt.

so ist richtig:

struct s1 (*ptr)(struct s2 *);

Dann ist ptr ein pointer auf eine Funktion die ein pointer auf ein struct s2 als parameter erwartet und ein struct s1 zurückgibt.

Hoffe das hilft.

Konfusius

Die korrekte Funktionszeigerdeklaration geht so:

void (*ptr)(MsgContextType*);
ptr=RecieveMessage;

Die Deklaration eines Funktionszeigers sieht genauso aus wie ein Prototyp, nur daß man um den Funtionsnamen Klammern und ein Sternchen davor macht. Die C-Syntax für Typenausdrücke ist für Anfänger sehr kompliziert.