Hallo Community,

ich habe folgende Ausgangssituation:

//Dieses Typedef ist in einem Header erstellt

typedef struct{

	unsigned int var[8];

	unsigned int  prgcounter[4];

	unsigned runbits[4];

	//TICK16	timer[10];			//8 Usertimer

	//TICK8 	impulstime[2];		//zwei impulsausgänge

	//TICK8 	startdelay[2];

	//TICK8	lasttime[2];

	unsigned startimpuls[2];

	unsigned char impulsstate[2];

	unsigned char impulspins[4];

	unsigned char impulsform[2];

	//TICK8 frequenz[2];	//zwei frequenzausgänge

	//TICK8 lastfrequ[2];

	unsigned char freqoutpins[4];

	unsigned int freqinput[2];	//zwei frequenzeingänge

	unsigned int freqcounter[2];

	//TICK8 frequtime[2];

}uservar_t;

Wie greife ich nun auf die Werte in diesem Typedef zu ? Worin liegt eben der Unterschied bei . und ->?

#define PC1 (uservar_t->prgcounter[0])

#define PC2 uservar_t.prgcounter[1]

Wie greife ich nun auf die Werte in diesem Typedef zu ?

Ein Typedef hat keine Werte. Ein Typedef ist ein Typ. Du brauchst eine Variable dieses Typs, um auf Werte zugreifen zu können.

Den Punkt-Operator benutzt du, wenn links davon eine normale Variable oder Referenz (nur C++) steht. Der Pfeiloperator kommt dann zum Einsatz, wenn links davon ein Zeiger steht.

Ja und wenn ich das jetzt in diesem Beispiel annehme ?

Der Typedef ist in meinem Fall in einem Header deklariert, wie muss ich das dann verstehen?

Also Typedef im Header, in anderem Header soll jetzt auf Werte vom Typedef zugegriffen werden...

Also Typedef im Header, in anderem Header soll jetzt auf Werte vom Typedef zugegriffen werden...

Ein Typ hat keine Werte. Du brauchst eine Variable dieses Typs. Ohne Variable gibt es keine Werte.

okay soweit so gut verstanden... das bedeutet ich muss eine variable erzeugen vom Typ uservar_t!

Und wie greife ich anschließend auf die Werte zu bzw. kann diese im Header verarbeiten?

void main(void){



   //Angenommen:

   uservar_t uservars;

   //Wie greife ich jetzt auf einen Wert zu bzw kann diesen definieren ?

   uservars.var[0] = 3; //Oder wie funktioniert das ?




}


//Wie muss ich dann die Defines erledigen?

#define PC1 uservars.prgcounter[0]

uservars.var[0] = 3; //Oder wie funktioniert das ?

Genau so.

//Wie muss ich dann die Defines erledigen?

#define PC1 uservars.prgcounter[0]

Besser

#define PC1 (uservars.prgcounter[0])

Wenn der Makro-Ausdruck Operatoren enthält, sollte man ihn in Klammern setzen, damit es nicht zu unbeabsichtigten Effekten kommt, wenn man ihn in Ausdrücken mit anderen Operatoren höherer Bindungsstärke benutzt. Das kann dir in diesem Fall kaum passieren (. und [] haben schon eine sehr hohe Bindungsstärke), aber man sollte es sich besser einfach angewöhnen, damit man es automatisch macht, wenn man es mal braucht.

Okay. Dann habe ich das jetzt auch verstanden. Wenn ich jedoch nun die #Defines im Header erledigen möchte, woher weiß dieser dann von meiner Variable "uservars" ?

Die kann der Header zu diesem Zeitpunkt doch noch garnicht kennen, da diese Variable noch garnicht vorhanden war/ist oder ?

Die Variable muss nicht dort deklariert sein, wo die Makros definiert werden. Sie muss dort deklariert sein, wo die Makros benutzt werden.

Die Variable muss nicht dort deklariert sein, wo die Makros definiert werden. Sie muss dort deklariert sein, wo die Makros benutzt werden.

Ich glaub dem Op ist noch nicht klar was ein Makro ist.

Ein Makro ist ein Stück Programmcode welches einen Makronamen verpasst bekommt, aber für sich genommen nicht ausgeführt wird. Im regulären Programmcode kann dann der Makroname wie ein Schlüsselwort verwendet werden. Der Präprozessor ersetzt dann den Makronamen durch den entsprechenden Programmcode und erst das Ergebniss wird kompiliert und dann entsprechend ausgeführt. Das heißt wenn in dem Makro eine Variable benutzt wird dann mußt du diese, wie Klotzkopp schreibt, so betrachten als ob du sie selbst an der Stelle an der du das Makro verwendest in den Code geschrieben hast.

Wann du den Punkt und wann du den Pfeiloperator benutzt hat dir Klotzkopp schon in seiner ersten Antwort erklärt.

Vielleicht sollte man auch erwähnen, dass Macros, erst recht in dieser Ausprägung, sowieso schlecht schlecht schlecht sind.

uservar_t* ptr_uservar = new uservar_t();  

// C- Style :

// #include <stdlib.h>

// uservar_t* ptr_uservar = (uservar_t*)malloc(sizeof(uservar_t*));


//Methode 1:

(*ptr_uservar).runbits[0] = x;

//Methode 2:

ptr_uservar->runbits[0] = x;


//anschließend den Speicher wieder freigeben:

delete ptr_uservar;

// C- Style :

// #include <stdlib.h>

// free(ptr_uservar);