Parameter verschiedenen typs in eine tabelle einfügen

"... aber es funktioniert nicht richtig."

Was heisst das?

Erhältst Du eine Compiler-Fehlermeldung, geht das Licht aus, wird der
Kaffee kalt oder stehen irgendwo in Deinem Programm uns nicht bekannte
Daten?

Schon mal Deinen Code (wenn er denn übersetzbar ist) in einem Debugger
angesehen?

@samuel:

Wäre einfacher gewesen Du hättest die Fehlermeldung des Compilers
gepostet...

Dein Problem ist:

Zuerst führst Du einen neuen Bezeichner für einen Typ ein: typedef
char* type_table;

Dann verwendest Du den selben Bezeichner als Member in Deiner Struktur:
char* type_table;

Das geht nicht. Änder' den Namen von einem und es sollte gehen.

Hallo,
hab hier folgendes Problem:
beim comilieren  der folgenden Zeile tritt fogende Fehlermeldung auf:

*(u08)comm_tab[mid].ptr=parametervalue_intern;
"
operand of "*" must be a pointer"

was sagt mir das?...und wie kann ich das Problem lösen?
danke

*(u08)comm_tab[mid].ptr=parametervalue_intern;

"operand of "*" must be a pointer"

Du castest den Ausdruck comm_tab[mid].ptr
in den Datentyp u08
und versuchst das zu dereferenzieren.
Wenn der Datentyp u08 kein Pointerdatentyp ist (ich vermute mal, daß
das unsigned char sein könnte), dann geht das nicht.

Was für einen Typ hat parametervalue_intern?
Was für einen Typ hat das Struktur-Member ptr?

ja u08 ist bei mir char....das war ein fehler von mir....
ich will eigentlich s16, s32, u16, u32 benutzen
parametervalue_intern ist s32

also mein programm sieht etwa folgendermassen aus:

//struct
typedef struct{
  char *name;
  u08 type;
  void *ptr;

}comm_struct;


//zugehörige tabelle
const comm_struct comm_tab[] = {      // command table
{"parameter1",TYPS16,&parameter1},
{"parameter2",TYPS16,&parameter2},

}

switch (comm_tab[mid].type)
    {

case TYPS16:
((*s16)comm_tab[mid]).ptr=(s16)parametervalue_intern;
break;

case TYPU16:
((*u16)comm_tab[mid]).ptr=(s16)parametervalue_intern;
break;

case TYPS32:
((*s32)comm_tab[mid]).ptr=(s16)parametervalue_intern;
 break;

case TYPU32:
((*u32)comm_tab[mid]).ptr=(s16)parametervalue_intern;
break;



und dann kommen folgende Fehlermeldungen, bei jeder Zeile in der switch
anweisung, bei der ich casten will:
type name is not allowed
error: expected a ")"

So:

case TYPS16:
  comm_tab[mid].ptr = (void *) parametervalue_intern;
  break;

etc.

Da ptr vom Typ void* ist, dürfen dem beliebige Pointer zugeweisen
werden.

wenn ich das so mache dann kommt für diese Zeile folgende
Fehlermeldung:
"error: expression must be a modifiable lvalue"
was sagt mir das?
danke Dir für deine Hilfe

Deine Definition der Tabelle ist das Problem:

const comm_struct comm_tab[] = ...
^^^^^

Das stört.

Du definierst die Tabelle const, willst sie aber modifizieren - das
erzeugt zu recht eine Fehlermeldung des Compilers.

Mir ist nicht ganz klar, was Du eigentlich bezwecken möchtest -
einerseits ist die Tabelle bereits initialisiert, andererseits möchtest
Du Elemente der Tabelle in Abhängigkeit anderer Elemente der Tabelle
modifzieren.

ich will über die serielle Schnittstelle des PCs die parameter ändern
können. wie muss ich dann die tabelle ändern?

Na, lass' einfach das Wort const weg, dann sollte es funktionieren.

cool...jetzt zeigt der compiler 0 Fehler an....
ich kapier noch nicht ganz, wieso man einfach einen wert der s32 war
wie parametervalue_intern in void* casten darf

> ich kapier noch nicht ganz, wieso man einfach einen wert der s32 war
> wie parametervalue_intern in void* casten darf

Man darf prinzipiell alles in void* casten. Ob's das überlebt, ist
'ne ganz andere Frage.
Ist sizeof (void *) kleiner als sizeof (s32), dann
gehen durch das Casting Informationen verloren.

Gute Morgen,
jetzt gibt es keine Fehlermeldung mehr....allerdings wird
paramatervalue_intern nicht richtig an die Variablen in der Tabelle
zugewiesen. Die Zeile

comm_tab[mid].ptr=(void*)parametervalue_intern;

bewirkt, dass ich nachher in comm_tab[mid].ptr den Wert stehen habe,
der in parametervalue_internb stand, allerdings steht dann z.B.
0x00000005 in comm_tab[mid].ptr, obwohl zuvor paremetervalue_intern den
Wert in dezimal hatte.
allerdings steht in dem entsprechenenden Parameter der Tablle am Ende
immer noch nicht der Wert
könnt ihr mir bitte helfen..danke

> allerdings steht dann z.B. 0x00000005 in comm_tab[mid].ptr,
> obwohl zuvor paremetervalue_intern den Wert in dezimal hatte.

Was magst Du damit meinen?
Daß der Debugger den einen Wert als 32-Bit-Hexadezimalzahl anzeigt,
während der andere Wert als 32-Bit-Dezimalzahl angezeigt wird?

Ich gewinne zunehmend den Verdacht, daß Du Dir mal ein Grundlagenwerk
über das Programmieren in C durchlesen solltest.

Das grösste Problem ist immer noch dass ich den Wert eben nicht in dem
Parameter stehen hab

Hä? Was ist denn bitte der Wert?
Wie sieht denn der Parameter aus?

Also mit folgendem Code will ich den Wert von parametervalue_intern an
den zugehörigen Parameter z.B. "parameter1" in der Tabelle zuweisen,
dabei klappt eben die Zuweisung in der switch Anweisung nicht,
jedenfalls hab ich den Wert nach den Operationen nicht in der variablen
z.B. parameter1 stehen.woran liegt das?

s16 parameter1;
s32 parameter2;
//etc...


//struct
typedef struct{
  char *name;
  u08 type;
  void *ptr;

}comm_struct;


//zugehörige tabelle
const comm_struct comm_tab[] = {      // command table
{"parameter1",TYPS16,&parameter1},
{"parameter2",TYPS16,&parameter2},
//etc.....
}



switch (comm_tab[mid].type)
    {

case TYPS16:
comm_tab[mid].ptr=&parametervalue_intern;
break;

case TYPU16:
comm_tab[mid].ptr=&parametervalue_intern;
break;

case TYPS32:
comm_tab[mid].ptr=&parametervalue_intern;
break;

case TYPU32:
comm_tab[mid].ptr=&parametervalue_intern;
break;

Doppelt Posten ist übrigens unheimich gemein >:\

Aus dem anderen Thread wird so allmählich klar, daß Deine
Aufgabenstellung eine andere ist.
Du möchtest in den Speicher schreiben, auf den comm_tab[mid].ptr
verweist, nicht den Wert dieses Pointers ändern.

Dann sieht natürlich Deine gesamte Zuweisung anders aus:

  case TYPS16:
    (* s16) (comm_tab[mid].ptr) = (s16) parametervalue_intern;

Damit überschreibst Du den bei der Initialisierung Deiner Tabelle
gefüllten Speicher;

  const comm_struct comm_tab[] =
    {
      {"parameter1", TYPS16, &parameter1},
      {"parameter2", TYPS16, &parameter2},


in parameter1 steht daraufin etwas anderes.

Dann darf auch das const wieder auftauchen - es muss nur sichergestellt
sein, daß parameter1 etc. nicht const definiert sind.


Im übrigen hat Oldbug recht - daß Du hier annähernd die gleiche
Diskussion in zwei Threads losgetreten hast, ist insgesamt nicht
förderlich.

Danke....ja jetzt läuft die ganze sache....

was noch nicht funktioniert ist folgendes:

*(u08 *)(comm_tab[mid].ptr)=value_of_parametervalue_u08;


u08 ist unsigned char. darf ich das so nicht machen oder wie so
funktioniert das so nicht? alls anderen castings auf s16, u16, s32, u32
und f32 funktionieren

sorry falsch...
der Fehler liegt in der Zeile davor:
value_of_parametervalue_u08 ist vom Typ u08
parametervalue_intern ist vom typ char*.

value_of_parametervalue_u08=(u08)parametervalue_intern;


diese casting geht schief...wieso?

Hier castest Du einen Pointer nach u08 - sonst castest Du
unterschiedlich große int-Varianten. Wie wär's mit Dereferenzieren?

Ich hab's Dir schon mehrfach geraten: Lies' Dir mal ein Buch über die
Grundlagen der Programmierung in C durch - Du scheinst nach wie vor das
eine oder andere Verständnisproblem zu haben.
Mehr als genug Hinweise wurden Dir jetzt auch schon gegeben - und einen
C-Grundkurs kann dieses Forum nicht ersetzen.