auf struct's in Funktion zugreifen

[struct.urschwach (Gast)]

Hallo,

ich habe ein paar Startschwierigkeiten mit "structs"

Folgendes habe ich in folgenden Dateien:

_________________________________________________
main.h:

struct T_Ringbuffer
{
char Soll;
char Ist;
char Buffer[RINGBUFFERGROSSE];
};

volatile extern struct T_Ringbuffer TX_Ringbuffer;

________________________________________________
uart.h:

volatile extern struct T_Ringbuffer TX_Ringbuffer;

________________________________________________
uart.c:

void shift_to_uart_tx_buffer(struct T_Ringbuffer *TX_Ringbuffer)
{
TX_Ringbuffer.Soll = 5; //(hierauf bezieht sich die Errormeldung)
}
________________________________________________

Fehlermeldung:
Error[Pe154]: expression must have struct or union type


Frage:
Was muss ich ändern, damit die Funktion in der uart.c das struct 
verarbeiten kann...?

mfg und danke schonmal im voraus.

[Björn B. (elmo)]

Dein *TX_Ringbuffer ist ja ein Zeiger. Darauf greifst du nicht mit "." 
zu, sondern mit "->".

Also:
TX_Ringbuffer->Soll = 5;

[Ralf (Gast)]

Du übergibst einen Pointer auf die Struktur.
Probier mal TX_Ringbuffer->Soll = 5 bzw. *TX_Ringbuffer->Soll = 5

Kann's leider grad nicht nachprüfen, aber ich meine, dass bei 
struct-Zugriffen über Pointer das '->' anstelle des '.' zum Tragen 
kommt.

Ralf

[nktion (Gast)]

TX_Ringbuffer->Soll ist lediglich eine bequemere Schreibweise
für (*TX_Ringbuffer).Soll

'.' bindet stärker als '*'.

[struct.urschwach (Gast)]

Danke für die Hilfe, funktioniert.

kann ich nun die Schlussfolgerung ziehen, dass es grundsätzlich zwei 
Fälle gibt,

Fall 1 wäre die Übergabe eines Pointers in der Funktion, der auf das 
struct zeigt.
In diesem Fall müsste ich
TX_Ringbuffer->Soll=5;
geschrieben werden


und Fall 2 wäre eine Funktion, die in etwa so aussehen würde:

void(struct structtyp meinstruct)
{
meinstruct.element = 10;
}

und ohne pointer arbeitet?

Ist das so korrekt?

[Rufus Τ. F. (rufus)]

struct.urschwach schrieb:
> und Fall 2 wäre eine Funktion, die in etwa so aussehen würde:
>
> void(struct structtyp meinstruct)
> {
> meinstruct.element = 10;
> }
>
> und ohne pointer arbeitet?
>
> Ist das so korrekt?

Nein. Dieser zweite Fall erzeugt beim Aufruf eine Kopie des Arguments, 
verändert die Kopie und wirft sie beim Verlassen der Funktion wieder 
weg.

Das nennt sich "call-by-value".

[Karl H. (kbuchegg)]

struct.urschwach schrieb:

> Ist das so korrekt?

Im Prinzip ja - es gilt 2 Fälle zu unterscheiden.

Es ist völlig analog zum Fall

void foo1( int i )
{
  i = 5;
}

und

void foo2( int * i )
{
  *i = 5;
}

im ersten Fall bekommt die Funktion einen int als Kopie und kann diese 
Kopie innerhalb der Funktion ändern wie sie lustig ist. Der Aufrufer 
kriegt davon nichts mit, denn ...  er hat ja nur eine Kopie seines 
Wertes an die Funktion weitergegeben

int main()
{
  int k = 8;
  foo1( k );    // k wird sich durch die Zuweisung in foo nicht ändern
}

Im zweiten Fall, gibt aber der Aufrufer die Adresse seiner eigenen 
Variablen an die Funktion. Wenn daher die Funktion dort den Wert über 
die Adresse ändert (genau das macht der * in *i = 5;), dann ändert sie 
die Variable des Aufrufers

int main()
{
  int k = 8;
  foo2( &k );   // hier greift die Funktion, mithilfe der Adresse auf
                // das k des Aufrufers durch. foo2 verändert k!
}

Und mit structs ist das auch nicht anders. Vom Mechanismus her völlig 
identisch. Ersetze "int" durch "struct T_Ringbuffer" und du hast wieder 
die beiden Fälle.

Mit dem einen kleinen Problem, dass man

void foo3( struct T_Ringbuffer * buf )
{
  (*buf).Soll = 5;
}

schreiben müsste (es geht um die Klammern)

Da das aber auf dauer mühsam ist, hat man für (*x).y eine andere 
Schreibweise eingeführt, die x->y lautet. Also kann man anstelle des 
Klammergewusels schreiben

void foo3( struct T_Ringbuffer * buf )
{
  buf->Soll = 5;
}

und hat genau dasselbe.



Sagt denn da dein C-Buch nichts darüber? Eigentlich sollte das eine 
nicht unbeträchtliche Anzahl von Seiten in deinem C-Buch einnehmen!

[struct.urschwach (Gast)]

...also schonmal vielen Dank für die Antworten, aber irgendwo läuft es 
immernoch nicht ganz so, wie gewünscht... ich denke ich bräuchte für den 
Aufruf des structs in meiner Funktion nochmal einen Denkanstoss, bzw. 
ich fürchte, dass ich das struct ev. falsch deklariert bzw. definiert 
haben könnte...

Folgende Fehlermeldung gibt es beim Compilieren:

Error[Pe167]: argument of type "struct T_Ringbuffer" is incompatible with parameter of type "struct T_Ringbuffer *"

Dies ist der Code sowie die Aufteilung auf die beteiligten Header- und 
C-Dateien:


main.h

struct T_Ringbuffer
{
char Soll;
char Ist;
char Buffer[RINGBUFFERGROSSE];
};
  
extern volatile struct T_Ringbuffer TX_Ringbuffer;

main.c:

#include "main.h"
#include "uart.h"


volatile struct T_Ringbuffer TX_Ringbuffer = {0,0, };

...

int main(void)
{
...

char Text[] = {"name"};
        
add_string_to_uart_tx_buffer(TX_Ringbuffer, Text);

...
}

uart.h

volatile extern struct T_Ringbuffer TX_Ringbuffer;

void add_string_to_uart_tx_buffer(struct T_Ringbuffer* TX_Ringbuffer, char* stringarray);

uart.c

#include "uart.h"
#include "main.h"

void add_string_to_uart_tx_buffer(struct T_Ringbuffer* TX_Ringbuffer, char* stringarray)
{
  char zeiger = 0;
  
  do
  {
   TX_Ringbuffer->Soll++;
   if(TX_Ringbuffer->Soll < RINGBUFFERGROSSE)
     {;}
   else
   {  
     TX_Ringbuffer->Soll = 0;
   }
 
   TX_Ringbuffer->Buffer[TX_Ringbuffer->Soll] = stringarray[zeiger];
   zeiger++;
  }while(stringarray[zeiger] != '\0');
}

[Karl H. (kbuchegg)]

struct.urschwach schrieb:


> Folgende Fehlermeldung gibt es beim Compilieren:
>

> Error[Pe167]: argument of type "struct T_Ringbuffer" is incompatible
> with parameter of type "struct T_Ringbuffer *"
>

Na dann schau dir die Teile an. Der Compiler ist da eh schon sehr 
spezifisch:

* Die Funktion will einen Pointer.
  Einen struct T_Ringbuffer *
* Der Aufrufer veruscht aber ein Objekt reinzustopfen.
  Es möchte einen struct T_Ringbuffer übergeben.

void foo( int * i )
{
  ...
}

int main()
{
  int j;

  foo( j );
}


wenn foo einen Pointer will, dann kann man nicht j reingeben ('das 
Objekt reinstopfen') sondern man muss zb. die Adresse von j übergeben

int main()
{
  int j;

  foo( &j );
}

[ronny (Gast)]

YEAH, C RULEZ!

[Karl H. (kbuchegg)]

ACh Ronny. Halt doch einfach mal die Klappe. Kein Mensch kann was dafür, 
dass du für C zu dämlich bist.
Das man eine Programmiersprache auch lernen muss, ist jetzt nicht 
wirklich wahsinnig überraschend. Und auch nicht, das das nicht von heute 
auf morgen geht.

[struct.urschwach (Gast)]

hm also es ist ja nicht so, dass ich die Fehlermeldungen nicht 
übersetzen kann, nur manchmal fixt man ein Problem und es entsteht 
dadurch ein neues.

Also ich habe jetzt mal den Aufruf abgeändert zu:

add_string_to_uart_tx_buffer(&TX_Ringbuffer, Text);

Dies hat aber erstmal eine weitere Fehlermeldungen hervorgerufen:

Error[Pe167]: argument of type "struct T_Ringbuffer volatile *" is incompatible with parameter of type "struct T_Ringbuffer *"

...Eine Lösung für dieses Problem habe ich zur Abwechslung mal selber 
finden können... wenn ich die "volatile" aus dem Code komplett entferne, 
wird das Programm durchcompiliert...

Da ich aber in meinen (noch nicht implementierten) 
Interrupt-Serviceroutinen ebenfalls auf die Werte aus dem struct 
zugreifen möchte, hatte ich bisher versucht, diese Variablen volatile zu 
halten...

[Decius (Gast)]

Das folgende:
extern volatile struct T_Ringbuffer TX_Ringbuffer;

in uart.h und main.h so geht das nicht, zumal du beide Headerdateien in 
main.c einbindest. Stichwort doppelte Deklaration. Nimm diese Zeile aus 
den Headerdateien heraus. und schreibe folgfendes:

main.c:
volatile struct T_Ringbuffer TX_Ringbuffer;

usart.c:
extern volatile struct T_Ringbuffer TX_Ringbuffer;

Man kann das auch über compileranweisungen wie #ifdef #else in den 
header dateien lösen. Aber ich denke mal , der weg oben ist erstmal 
leichter.

[Decius (Gast)]

main.c:
volatile struct T_Ringbuffer TX_Ringbuffer;

definiert die Struktur.
------------------------------------------------------

usart.c:
extern volatile struct T_Ringbuffer TX_Ringbuffer;

verweist den linker auf die definition in main.c

--------------------------------------------------------

[Decius (Gast)]

wollte schreiben deklariert die struktur. die struktur selbst wir in 
main.h definiert.

[struct.urschwach (Gast)]

 
allen einen herzlichen Dank für die Hilfestellungen!

[struct.urschwach (Gast)]

...eine Frage fällt mir im Anschluss nun doch noch ein:

Die Funktion

void add_string_to_uart_tx_buffer(struct T_Ringbuffer* TX_Ringbuffer, char* stringarray)

TX_Ringbuffer->Buffer[0] = 5;
stringarray[0] = 5;

arbeitet ja nun mit zwei Zeigern.
Ein Zeiger auf struct Ringbuffer und ein Zeiger auf ein stringarray.
Mit beiden Codezeilen verändere ich die Inhalte der Arrays.

Warum aber muss ich bei dem Funktionsaufruf das "normale" Array nicht 
mit der Adresse ansprechen, bei dem struct jedoch schon?

char* meinarray[3] = {0,2,5};

...
int main(void)
{
...
add_string_to_uart_tx_buffer(&TX_Ringbuffer, meinarray)
...
return 0;

Im Anschluss an diese Funktion ist global meinarray[0] == 5, obwohl dort 
nicht mit der Adresse gearbeitet wurde...

mfg

[Karl H. (kbuchegg)]

struct.urschwach schrieb:

> Warum aber muss ich bei dem Funktionsaufruf das "normale" Array nicht
> mit der Adresse ansprechen, bei dem struct jedoch schon?

Weil Arrays anders sind.
Arrays werden niemals als Kopie übergeben, sondern immer indem die 
Startadresse des Arrays übergeben wird. Steht der Name eines Arrays 
alleine (d.h. ohne Indexangabe), dann ist damit immer die Adresse des 
Arrays gemeint. (Einzige Ausnahme: sizeof)

Jetzt muss ich mich nochmals wundern. Sagt denn dein C-Buch darüber 
nichts?
(Wenn du keines hast, dann lass dir gesagt sein: Du wirst eines 
brauchen. Diese beiden Dinge hier sind die Spitze eines Eisbergs und 
noch vergleichsweise simpel. Da warten noch viele Dinge auf dich, die du 
lernen musst. Dein C-Buch kennt die Dinge und erklärt sie dir.)



> char* meinarray[3] = {0,2,5};
du meintest
char meinarray[3] = {0,2,5};

[struct.urschwach (Gast)]

du meintest
char meinarray[3] = {0,2,5};

richtig.