Kurze Pointerfrage "C"

Aufpassen, C kenn keine Strings. In der Deklaration von deinem Struct 
ist 'n Fehler:

1

struct PERSON

2

{

3

  // ...

4

};

5

6

struct PERSON test;

oder

1

struct PERSON

2

{

3

  // ...

4

} test;

Der Rest stimmt. & referenziert, * deferenziert.

Thomas wrote:

> wenn ich ein struct habe
>
> typedef struct person
> {
>    string name;
>    string straße;
> } PERSON;
>
> [..]
>
> PERSON test;
>
> [..]
>
> wenn ich jetzt einer Funktion einen Pointer auf "test" übergeben will,
> mache ich das mit der deklaration so: (?)
>
> void testfunktion(PERSON *pointerAufTest);
> testfunktion (&test)

Yep. 100 Punkte

>
> in der testfunktion kann ja dann direkt werte von test ändern. das mache
> ich mit: (??)
>
> pointerAufTest->name = "Thomas"
> pointerAufTest->straße = "Straße"

Was den Pointerzugriff angeht: Yep. 100 Punkte

Einen kleinen Schönheitsfehler hat dein Beispiel noch:
In C gibt es keinen string Datentyp.
Abhängig davon, wie du 'string' definiert hast, geht die
Zuweisung der Texte da oben in die Hose oder auch nicht.

Das hat aber erst mal nichts mit dem Zugriff und dem ganzen
Drumherum um die struct person zu tun. Das ist 100% richtig.

I_ H. wrote:
> In der Deklaration von deinem Struct
> ist 'n Fehler:

Nö. Ist er nicht. Du hast den typedef übersehen.

Kommt darauf an wie string deklariert ist. Wenn string gleich char * 
ist, geht das so.

Thomas wrote:
> Ok Danke!

Eignetlich ist die Sache sehr einfach:

Hat man einen Pointer

  int * pPtr;

dann liefert der Audruck *pPtr  den int. Die Definition der
Variablen spiegelt also in einer gewissen Art und Weise
die Verwendung wieder:

  int * pPtr;
   ^  |    |
   |  |    |
   |  +----+
   |   Dieser Ausdruck liefert
   |   das hier  -+
   |              |
   +--------------+


  int j;
  j = *pPtr;

bzw. auch umgekehrt:

  *pPtr = j;

Mittels des Derefernzierungsoperators * gelangt man also immer
zu dem Datenwert auf den der Pointer zeigt:



    pPtr                         j
   +--------+                    +-----+
   |   o------------------------>|     |
   +--------+                    +-----+

Der * macht also nichts anderes, als dem Pfeil zu folgen,
der von der Pointervariablen ausgeht.

Nun gibt es aber auch Fälle, wie den den du hast:

struct abc
{
  int k;
  int l;
} test;

struct abc* pPtr;

pPtr = &test;

    pPtr                         test
   +--------+                    +-------+
   |   o------------------------>| k:    |
   +--------+                    +-------+
                                 | l:    |
                                 +-------+

Ausgehend von pPtr, verfolgt ein vorangestellter * wiederrum
dem Pfeil

    *pPtr

Am Ende des Pfeiles sitzt eine struct und um auf eine Komponente
so einer struct zuzugreifen benutzt man einen . so wie
man das zb in

   test.k = 5;

machen würde.

Also:

   *pPtr.k = 5;

Das hat jetzt aber einen Fehler. Der . bindet stärker als der *
So dass der Compiler das als

  *(pPtr.k)

auffassen würde. Das ist aber ganz was anderes (und im jetzigen
Szenario illegal, weil pPtr ja keine struct ist).
Daher müsste man sowas immer als

  (*pPtr).k = 5;

schreiben. Das ist aber eine mühsame Schreiberei. Da aber derartige
Konstruktionen oft vorkommen, hat man dafür einen eigenen Operator
eingeführt:
Anstelle von
   (*pPtr).k
kann man auch
    pPtr->k
schreiben. Und das ist dann schon etwas angenehmer zu tippen (und
zu lesen).