Suche Suchbegriff, C "->"

[Martin K. (dschadu)]

Hi,
ich würde gerne Google bemühen, allerdings Ignoriert google irgendwie 
das "->" in der Suche. Ich weiß auch leider nicht wie ich das nennen 
oder Umschreiben soll, jemand eine Idee, Link, oder gar Erklärung?

Da ich in letzter Zeit öfters drauf gestoßen bin, kann ichs wohl 
nichtmehr ganz ignorieren. Ich bin kein totaler Anfänger in C, kann 
schon nen bisl was, aber bei sowas haperts dann doch noch.

Konkretes Beispiel, Auszug aus der aktuellen USB LUFA der RingBuffer.h:

    static inline void RingBuffer_InitBuffer(RingBuffer_t* Buffer, uint8_t* const DataPtr, const uint16_t Size)
    {
      GCC_FORCE_POINTER_ACCESS(Buffer);

      uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
      GlobalInterruptDisable();
  
      Buffer->In     = DataPtr;
      Buffer->Out    = DataPtr;
      Buffer->Start  = &DataPtr[0];
      Buffer->End    = &DataPtr[Size];
      Buffer->Size   = Size;
      Buffer->Count  = 0;

      SetGlobalInterruptMask(CurrentGlobalInt);
    }

danke schonmal!


edit: Sorry, währe wohl besser in GCC aufgehoben gewesen.

[(prx) A. K. (prx)]

Und was war nochmal die Frage?

[Sebastian (Gast)]

Martin K. schrieb:
> ich würde gerne Google bemühen, allerdings Ignoriert google irgendwie
> das "->" in der Suche. Ich weiß auch leider nicht wie ich das nennen
> oder Umschreiben soll, jemand eine Idee, Link, oder gar Erklärung?

Vergleiche 
http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Member_and_pointer_operators. 
Der Operator "->" wird u.a. als "structure dereference" bezeichnet.

[Martin K. (dschadu)]

Super, danke für die flotte Antwort!

[tritratroll (Gast)]

A. K. schrieb:
> Und was war nochmal die Frage?

Was bedeutet "->"?

Ist eine andere Schreibweise um mittels Pointer auf Strukturen 
zuzugreifen:

typedef struct 
{
  int a;
  int b;
} mystruct_t;

mystruct_t structur, *pointer;

pointer=&structur;

//gleichbedeutend
structur->a=1;
(*structur).a=1;

[Sebastian (Gast)]

A. K. schrieb:
> Und was war nochmal die Frage?

Angenommen, die Frage lautet "Was tut dieser Operator '->'?"

Dann wäre eine Antwort: Er löst den linken Operanden, einen Zeiger auf 
eine Struktur (oder Klasse) auf, und sucht das Attribut bzw. die 
Methode, die durch den rechten Operanden beschrieben wird.

Im Prinzip (von Überladung etc. abgesehen) ist "a->b" gleichbedeutend 
mit "(*a).b".

Im ursprünglichen Beispiel ist "Buffer" ein Zeiger auf eine Struktur vom 
Typ "RingBuffer_t". Die Zugriffe mit "->" ersparen das explizite 
Dereferenzieren mittels "*Buffer". Anstelle von

      Buffer->In     = DataPtr;
      Buffer->Out    = DataPtr;
      Buffer->Start  = &DataPtr[0];
      Buffer->End    = &DataPtr[Size];
      Buffer->Size   = Size;
      Buffer->Count  = 0;

könnte man hier (höchstwahrscheinlich) auch

      (*Buffer).In     = DataPtr;
      (*Buffer).Out    = DataPtr;
      (*Buffer).Start  = &DataPtr[0];
      (*Buffer).End    = &DataPtr[Size];
      (*Buffer).Size   = Size;
      (*Buffer).Count  = 0;

schreiben. Das ist aber insbesondere durch die nötige Klammerung etwas 
sperriger als mit "->".

[Markus M. (Firma: EleLa - www.elela.de) (mmvisual)]

"Buffer" ist ein Zeiger auf eine Variable vom Typ "RingBuffer_t"

Buffer.In kann nicht geschrieben werden, da "Buffer" nur ein Zeiger ist.

Daher muss

Buffer->In

geschrieben werden.


RingBuffer_t BufferVar;  // Definition Variable und Speicher
Buffer = &BufferVar;     // Zeiger auf die Variable

BufferVar.In == Buffer->In; // Beides zeigt auf die gleiche 
Speicheradresse

[Sebastian Hepp (Gast)]

Falls doch noch der Name des Operators interessiert: "Pfeiloperator".

[Karl H. (kbuchegg)]

> Da ich in letzter Zeit öfters drauf gestoßen bin, kann ichs wohl
> nichtmehr ganz ignorieren. Ich bin kein totaler Anfänger in C,
> kann schon nen bisl was, aber bei sowas haperts dann doch noch.

Dann solltest du ganz schnell ein paar Euros investieren und dir bei 
Amazon ein C-Buch kaufen. Du wirst schnell merken, dass dieser Operator 
auf ungefähr 70% alles Seiten vorkommt. Wenn du den also noch nicht 
kennst, dann kennst du vieles von C noch nicht, was du eigentlich kennen 
solltest.

[hp-freund (Gast)]

http://eshca.net/books/DE/c_von_a_bis_z/015_c_strukturen_003.htm

und natürlich den Rest des Buches ;-)

[Vladimir (Gast)]

Die Wahrscheinlichkeit, dass bei einer C-Frage auf ein C-Buch verwiesen 
wird liegt bei 140%.

[Karl H. (kbuchegg)]

Vladimir schrieb:
> Die Wahrscheinlichkeit, dass bei einer C-Frage auf ein C-Buch verwiesen
> wird liegt bei 140%.

Kommt halt immer auf die Frage an :-)

Wenn die Frage eines Autofahrers lautet:
Welches ist die Bedeutung der anderen beiden Pedale im Fussraum des 
Fahrers?

wird man ihn als aktiven Autofahrer auch daran erinnern, doch bitte mal 
eine Fahrschule aufzusuchen und ein paar Stunden zu nehmen. Dort lernt 
er dann auch, wie man den 2. Gang einlegt und was es mit dem Bremsen so 
auf sich hat. Was dann wiederrum die Zahl der Dellen in seiner 
Garagenwand extrem verringert.

Oder wie würdest du mit jemanden verfahren, der dich in Mathematik beim 
Thema Differenzieren fragt: Wie war das nochmal mit dem Multiplizieren 
und Klammern auflösen?

[Rolf M. (rmagnus)]

Vladimir schrieb:
> Die Wahrscheinlichkeit, dass bei einer C-Frage auf ein C-Buch verwiesen
> wird

... ist ziemlich genau so groß wie die, daß es sich dabei um eine 
absolute Grundlagenfrage handelt, die in jedem C-Buch in einem der 
ersten Kapitel beantwortet wird.

[Mark B. (markbrandis)]

Martin K. schrieb:
> Hi,
> ich würde gerne Google bemühen, allerdings Ignoriert google irgendwie
> das "->" in der Suche.

Das ist leider eine grundsätzliche Krankheit bei Suchmaschinen. Manchmal 
wäre es absolut sinnvoll, wenn man nach Interpunktions- und 
Sonderzeichen suchen könnte. Auch und gerade wenn es um 
Programmiersprachen geht.

[Martin K. (dschadu)]

Danke für die Ergänzenden Beiträge!

Und jeder fängt halt mal klein an, bisher bin ich btw sehr gut nur mit 
Gaspedal gefahren :D