parameter in structure beschreiben

[Franz (Gast)]

Hallo,
ich habe eine Struktur mit normalen Parametern und constanten parametern

typedef struct
{
    const uint8_t constValue;
    uint8_t value;
}struct_ts

den Wert value kenne ich erst in einer Funktion, da dieser von einem 
anderen Modul kommt. den constValue kenne ich schon zu beginn.
Jetzt möchte ich eine Structur struct_s erstellen, welche für eine ganze 
Datei gillt

static struct_ts struct_s = 
{
  .constValue = 0x85,
  .value = 0x00,
};

.
Das Problem ist, dass ich hier für den wert Value einen dummywert 
eingeben muss und diesen in einer späteren Funktion wieder überschreiben 
muss.
In der init funktion kann ich den wert constValue aber nicht mehr 
beschreiben.

static struct_ts struct_s;

void init(void)
{
  struct_s.constValue = 0x85;  // geht nicht
  struct_s.value = getValue();
}

gibt es eine möglichkeit die Struktur nur an einer Stelle zu 
beschreiben?
Also am besten in der init-funktion, da ich dort an value komme.

[Mike B. (mike_b97)]

Franz schrieb:

> typedef struct
> {
>     const uint8_t constValue;
>     uint8_t value;
> }struct_ts
...
> In der init funktion kann ich den wert constValue aber nicht mehr
> beschreiben.static struct_ts struct_s;

Wenn du oben das const weglässt?
Wofür setzt du in der typedef was als const wenn du es unten 
veränderlich haben willst?
bin nicht so arg firm in C/C++, in PASCAL heißt const "konstant"

oder auch
Beitrag "c struct const"

[Nur_ein_Typ (Gast)]

Franz schrieb:
> gibt es eine möglichkeit die Struktur nur an einer Stelle zu
> beschreiben?
> Also am besten in der init-funktion, da ich dort an value komme.

Probier's mal wie in init_mystruct():

typ@irgendwo$ cat main.c 
#include<stdio.h>

typedef struct {
    const char konst;
    int value;
} mystruct;


mystruct init_mystruct(int value) { 
    return (mystruct){'a', value}; 
}

void print_mystruct(mystruct s) {
    printf("konst = %c, value = %d\n", s.konst, s.value);
}


int main(void) {
    mystruct a = init_mystruct(0);
    print_mystruct(a);
    
    a.value = 15;
    print_mystruct(a);
    
    // a.konst = '3'; // Fehler!
    //print_mystruct(a);
    
    return 0;
}
typ@irgendwo$ gcc -Wall -Wextra -Wpedantic -o main main.c
typ@irgendwo$ ./main 
konst = a, value = 0
konst = a, value = 15

(Ja, Zeiger wären schöner, aber das sei dem geschätzten Leser zur Übung 
überlassen.)

[Mike B. (mike_b97)]

Nur_ein_Typ schrieb:
> typedef struct {
>     const char konst;
>     int value;
> } mystruct;
> mystruct init_mystruct(int value) {
>     return (mystruct){'a', value};

m.M.n. umgehst du seine fragestellung komplett
Er will konst einen char zuweisen, (was nicht geht).
Du lässt einfach einen char an der Stelle von konst ausgeben ohne ihn 
zuzuweisen.

[Sheeva P. (sheevaplug)]

Mike B. schrieb:
> Nur_ein_Typ schrieb:
>> typedef struct {
>>     const char konst;
>>     int value;
>> } mystruct;
>> mystruct init_mystruct(int value) {
>>     return (mystruct){'a', value};
>
> m.M.n. umgehst du seine fragestellung komplett
> Er will konst einen char zuweisen, (was nicht geht).
> Du lässt einfach einen char an der Stelle von konst ausgeben ohne ihn
> zuzuweisen.

Das hier funktioniert genauso:

mystruct init_mystruct(char konst, int value) {
    return (mystruct){konst, value};
}
/* [...] */

int main(void) {
    mystruct a = init_mystruct('a', 0);
/* [...] */

[Rolf M. (rmagnus)]

Sheeva P. schrieb:
> Das hier funktioniert genauso:

Dann steht das Ergebnis aber nicht in der globalen Struktur, sondern in 
einer lokalen Variable innerhalb der aufrufenden Funktion.

[Oliver S. (oliverso)]

Franz schrieb:
> Jetzt möchte ich eine Structur struct_s erstellen, welche für eine ganze
> Datei gillt1static struct_ts struct_s =
> 2{
> 3  .constValue = 0x85,
> 4  .value = 0x00,
> 5};
> .
> Das Problem ist, dass ich hier für den wert Value einen dummywert
> eingeben muss und diesen in einer späteren Funktion wieder überschreiben
> muss.
> In der init funktion kann ich den wert constValue aber nicht mehr
> beschreiben.

Dann mach das doch einfach nicht. constValue hat den Wert 0x85, und das 
bleibt bis zum Ende der Welt (bzw. des Programms) so. Schreib in value 
rein,was immer du willst, und lass constValue einfach in Ruhe. Ich 
verstehe dein Problem gar nicht.

Oliver

[A. S. (Gast)]

Wenn Du sagst, warum der Wert const sein muss, kann man einen workaround 
genau dafür empfehlen.

Sonst indem Du das

Mike B. schrieb:
> const weglässt?

[Ein Kommentar (Gast)]

Eine der beiden Ideen hinter dem "const": Der Compiler kann Lesezugriffe 
weg optimieren. Er kann Berechnungen mit den konstanten Werten während 
der Kompilierung durchführen und das Ergebnis direkt in den 
Maschinencode einbauen.

Der Compiler darf sogar den Speicherplatz für "static 
struct_ts.constValue" komplett weg optimieren.

Da ist die Frage, wenn Franzs Konstruktion erlaubt ist, wie findet der 
Compiler heraus: für "struct_ts.constValue" kann er immer und überall 
den Wert 0x85 direkt in den Maschinencode einbauen?

[Simon (Gast)]

geht das Folgenbde nicht einfach?

struct xxxxx_t
{
  const uint32_t c_var;
  uint32_t var_var;
};

void funktion()
{
  struct xxxxx_t x = {.c_var = 0x55};
}

[Ein Kommentar (Gast)]

> geht das Folgenbde nicht einfach?

Ist halt eine ganz andere Sache.

Das struct_s von Franz ist in der gesamten Datei sichtbar. Das x nur 
innerhalb von main.

Und das stecken unterschiedliche Konzepte dahinter. Modernes C benutzt 
das Wort const für 2 unterschiedliche Sachen.
- Das alte "#define constValue 0x85" ersetzen
- Dem Benutzer eines Moduls mitteilen: das Modul wird den Speicherplatz 
nicht verändern.

Verwirrung entsteht wahrscheinlich, weil im C Standard die Konstruktion 
von Franz für den ersten Zweck gedacht war, er aber den ańderen Zweck 
erreichen will.

[Klaus W. (mfgkw)]

Wenn man nicht C, sondern C++ nimmt, kann man mit mutable einen Teil 
einer struct oder class veränderbar halten - auch wenn der Rest drumrum 
als const deklariert ist.

(Wenn man C++ nicht mag, kann man sich ja genau das rauspicken und den 
Rest wie sonst in C schreiben.)

[Oliver S. (oliverso)]

Klaus W. schrieb:
> Wenn man nicht C, sondern C++ nimmt, kann man mit mutable einen Teil
> einer struct oder class veränderbar halten

Falls der TO das wirklich wollte (was er anscheined ja gar nicht will), 
wäre das die bessere Lösung:

Mike B. schrieb:
> Wenn du oben das const weglässt?

Oliver

[A. S. (Gast)]

Ein Kommentar schrieb:
> Der Compiler kann Lesezugriffe
> weg optimieren. Er kann Berechnungen mit den konstanten Werten während
> der Kompilierung durchführen und das Ergebnis direkt in den
> Maschinencode einbauen.
>
> Der Compiler darf sogar den Speicherplatz für "static
> struct_ts.constValue" komplett weg optimieren.

Ein C-Compiler? Seit wann? (Gut, der C-Compiler sowieso nicht, aber ab 
Linker, geschenkt).

[Mikro 7. (mikro77)]

Franz schrieb:
> gibt es eine möglichkeit die Struktur nur an einer Stelle zu
> beschreiben?

Die const Member der Struktur kannst du nur an einer Stelle setzen, 
nämlich beim Erzeugen der Instanz. Ein nachfolgendes Schreiben auf das 
const Member würde ja dem "const" widersprechen.

Franz schrieb:
> Das Problem ist, dass ich hier für den wert Value einen dummywert
> eingeben muss und diesen in einer späteren Funktion wieder überschreiben
> muss.
> In der init funktion kann ich den wert constValue aber nicht mehr
> beschreiben.

static struct_ts struct_s;
void init(void)
{
  struct_s.constValue = 0x85;  // geht nicht
  struct_s.value = getValue();
}

Aber auch hier hast du bereits einen "dummywert" verwendet, nämlich 
struct_s.value=0 (mit dem implizit initialisiert wurde).

Wenn du unbedingt den globalen Zugriff brauchst und nur an einer Stelle 
die Initialisierung durchführen möchtest, dann musst du das wohl über 
einen Pointer realisieren. (Oder du überschreibst per Casting/memcpy das 
const, was ja aber nicht der Sinn der Übung sein sollte.)

[Einer (Gast)]

Franz schrieb:

> eine Struktur mit normalen Parametern und constanten parametern

[...]

> den Wert value kenne ich erst in einer Funktion, da dieser von einem
> anderen Modul kommt. den constValue kenne ich schon zu beginn.

[...]

> Das Problem ist, dass ich hier für den wert Value einen dummywert
> eingeben muss und diesen in einer späteren Funktion wieder überschreiben
> muss.

[...]

> In der init funktion kann ich den wert constValue aber nicht mehr
> beschreiben.

[...]

> gibt es eine möglichkeit die Struktur nur an einer Stelle zu
> beschreiben?

Merkst Du es nicht?

Bis jetzt hast Du nur eine Lösung präsentiert, ohne das ursprüngliche 
Problem zu benennen.

Der ganze Ansatz ist offensichtlich falsch. Er passt nicht zum 
ursprünglichem Problem. Du dokterst an Pseudo-Problemen rum, die es gar 
nicht gibt, sondern die Du künstlich geschaffen hast.

Darum die entscheidende Frage:

Was ist Dein eigentliches Problem, welche Aufgabe willst Du lösen?

[Johann L. (gjlayde)]

Mikro 7. schrieb:
> Oder du überschreibst per Casting/memcpy das const,

Das ist Undefined Behaviour in C/C++.

[Mike B. (mike_b97)]

Sheeva P. schrieb:

> Das hier funktioniert genauso:
> mystruct init_mystruct(char konst, int value) {
>     return (mystruct){konst, value};
> }
> /* [...] */
> int main(void) {
>     mystruct a = init_mystruct('a', 0);
> /* [...] */

nee, das is was anderes, da du genau an der richtigen Stelle
mystruct init_mystruct(*...* char konst, int value) {

Mike B. schrieb:
> ... das const weglässt

p.s. wie lauten bitte die Schlüsselwörter zur codeformatierung hier im 
Forum?

[Rolf M. (rmagnus)]

Mike B. schrieb:
> p.s. wie lauten bitte die Schlüsselwörter zur codeformatierung hier im
> Forum?

Das findest du oberhalb des Eingabefeldes, in das du deinen Text 
schreibst, gleich unter den wichtigen Regeln, die unter "Wichtige Regeln 
- erst lesen, dann posten!" stehen.

[Mike B. (mike_b97)]

Rolf M. schrieb:

> Das findest du oberhalb des Eingabefeldes, in das du deinen Text
> schreibst,

wer lesen kann ist klar im Vorteil, dann noch die richtige Brille auf 
der Nase und das geht nochmal doppelt so gut :D
Danke!

[Sheeva P. (sheevaplug)]

Rolf M. schrieb:
> Sheeva P. schrieb:
>> Das hier funktioniert genauso:
>
> Dann steht das Ergebnis aber nicht in der globalen Struktur, sondern in
> einer lokalen Variable innerhalb der aufrufenden Funktion.

Oh... true! ;-)