C Struct einzelne Elemente mit Funktion ändern

[Peda (Gast)]

Hallo,
ich habe zwei C Dateien: in der einen solle der struct und 
Zugriffsfunktionen deklariert werden und in der Anderen der Zugriff 
erfolgen:

//structDatei.c

struct test
{
  int i;
  int x;
};
static struct test Test;

void setStruct_i(int value)
{
  Test.i = value;  
}
void setStruct_x(int value)
{
  Test.x = value;  
}

Das blöde ist jetzt das ich für jedes Struct-Element eine eigene set 
Fuktion schreiben muss.
Ich hätte gerne eine elegantere universelle Methode in etwa so:
void setStruct_int("parameter", int value)
{
  Test.“parameter“ = value;
}

„parameter“ gibt das Struct-Element an, welches geändert werden soll.
Hat jemand eine Idee wie man das in C realisieren kann?

[Cyblord -. (cyblord)]

Peda schrieb:
> „parameter“ gibt das Struct-Element an, welches geändert werden soll.
> Hat jemand eine Idee wie man das in C realisieren kann?

Das geht über Arrays und den Index als enum.

ABER:
Warum willst du überhaupt setter wenn die so extrem allgemein sein 
sollen? Setter sind selten allgemein weil die bestimmte Invarianten 
garantieren sollen, die aber vom jeweiligen Datum abhängen.

Will ich einfach jeden beliebigen Zugriff zulassen, dann kann man auch 
gleich direkt auf die Variable zugreifen.

[? DPA ? (Gast)]

Willst du einen Parameter anhand eines Strings setzen, oder geht es 
wirklich nur um die Reduktion von Schreibarbeit?

In letzterem Fall könnte man ein Macro nehmen:

#define STRUCT_TEST_GENERIC_PUBLIC_MEMBERS \
  X(int, i) \
  X(int, x)

struct test
{
#define X(T, ID) T ID;
STRUCT_TEST_GENERIC_PUBLIC_MEMBERS
#undef X
};
static struct test Test;

#define X(T, ID) \
  void setStruct_ ## ID(T value_) \
  { \
    Test.ID = value_; \
  } \
  T getStruct_ ## ID() \
  { \
    return Test.ID; \
  }
STRUCT_TEST_GENERIC_PUBLIC_MEMBERS
#undef X

[Steinzeit (Gast)]

Willkommen in der Zukunft. Lerne C++ und wende dieses an:

struct bla{
  uint8_t x;

  void setX(uint8_t x){
    this->x = x;
  }
}

bla variable;
variable.setX(100);

[pointer (Gast)]

Peda schrieb:
> Ich hätte gerne eine elegantere universelle Methode in etwa so:
> void setStruct_int("parameter", int value)
> {
>   Test.“parameter“ = value;
> }

kannst du doch:

#include <stdio.h>                                                      
#include <stddef.h>                                                     
                                                                        
struct test {                                                           
   int x;                                                               
   int y;                                                               
};                                                                      
                                                                        
void                                                                    
set_some_value(int* data, int value)                                    
{                                                                       
   *data = value;                                                       
}

                                                                       
int                                                                     
main(void)                                                              
{                                                                       
   struct test t;                                                       
   set_some_value(&t.x, 1);                                             
   set_some_value(&t.y, 2);                                             
                                                                        
   return EXIT_SUCCESS;                                                 
}

[Programmiersprachentheaterintendant (Gast)]

cpp der C-Präprozessor kann man als Vorfahre von Word+VBA ansehen: ein 
programmierbares Textverarbeitungssystem das in der Lage ist den Text so 
umzuarbeiten dass am Schluss kompilierbares C (ohne, resp. mit 
aufgelösten Makros) rauskommt.

Beides ist in etwa ähnlich kryptisch und vergleichbar mit 
Verdauungssysteme: wenn man damit arbeitet klebt einem zum Schluss 
irgendwie 5che1**e an den Fingern.

---

Wenn man Sowas (structs mit Zugriffsfunktionen) systematisch und "viel" 
braucht (z.B. als gemeinsame Basis in heterogenen Systeme wo mit 
unterschiedlichen Programmiersprachen und/oder über verschiedene 
Architekturen Daten auszutauschen sind) ist man besser dran eine 
Datenbeschreibungssprache mit konziser/kompakter Syntax zu verwenden 
und davon per Converterprogramm den C-Code generieren zu lassen.
Das lässt sich dann gut auch mit Kompatibilitätschecks ausschmücken (f. 
Compiletime & Runtime) was sich beim Debugging in heterogenen Systemen 
sehr bezahlt macht.
BTDT, mehrmals & mit Erfolg

[Adam P. (adamap)]

pointer schrieb:
> struct test t;
> set_some_value(&t.x, 1);

Ja, das geht, aber dann gehört dir die Struct eh und dann kannst auch 
gleich
t.x = 1;
schreiben - falls du auf die Funktionsprüfung verzichten möchtest.

Peda schrieb:
> Das blöde ist jetzt das ich für jedes Struct-Element eine eigene set
> Fuktion schreiben muss.
> Ich hätte gerne eine elegantere universelle Methode

Also eigentlich, willst du deine Struktur vor falschem setzen 
schützen...
und Sie gehört nur dem Modul. OK.

Aber das kannst du auch anders lösen,
anstatt die Technik der Klassen aus C++ nachbilden zu wollen...
ja jetzt schreien gleich wieder alle, aber die Basis des allen ist doch 
die gleiche:

Man möchte verhindern, dass falsche Parameter gesetzt werden.
Doch das kann man auch mit einer set Fkt. lösen und nicht für jede 
Variable mit einer.
...Denn ob die Struktur nun static im Modul ist und man wird vom 
falschen
setzen der Werte gehindert - oder ob man Sie selbst besitzt oder auch 
nicht
und gehindert wird...kommt aufs gleiche rauß.

Siehe Anhang.

[Hmmm (Gast)]

Peda schrieb:
> Ich hätte gerne eine elegantere universelle Methode

Sowas kannst Du mit offsetof() lösen.

[Cyblord -. (cyblord)]

Adam P. schrieb:
> Also eigentlich, willst du deine Struktur vor falschem setzen
> schützen...
> und Sie gehört nur dem Modul. OK.

Aber nochmal: Was bringt es, eine Struktur "privat" zu halten um dann 
doch über eine generelle setter jeglichen Zugriff darauf zu erlauben?

[Adam P. (adamap)]

Cyblord -. schrieb:
> "privat"

Sie ist nicht "privat", sie gehört dem Modul, es gibt sie nur 1x.

Das war ja sein wunsch.
Klar ist das inkonsistent.

Da würde noch ein "verwalter" hingehören, der jedem anforderer eine neue 
instanz gibt (speicherbereich: array of foo_t)

und dann durch ne queue per callback den zugriff verwaltet...aber hey.
er wollte doch nur ne lösung für sein problem um die verwaltung des 
zugriffs hatte er ja nicht gefragt ;)

Cyblord -. schrieb:
> jeglichen Zugriff darauf zu erlauben?

tut er ja dann nicht, wenn die werte nicht stimmen.

[Adam P. (adamap)]

Cyblord -. schrieb:
> Aber nochmal: Was bringt es, eine Struktur "privat" zu halten um dann
> doch über eine generelle setter jeglichen Zugriff darauf zu erlauben?

Du nimmst dir halt das Interface und kannst es nutzen....falls du es 
richtig konfigurierst. Aber es existiert im besten fall nur einmal, oder 
als Array mit Job-Queue.

Wenn du eine COM oder UART verwenden willst, hast du auch eine Config. 
die du setzen musst. Aber das Objekt kann, muss aber nict bei dir 
liegen, das ist alles Design-Sache.

...so nebenbei:
Betriebssysteme erlauben nur den EINEN zugriff auf COM...warum?

Wenn man es doch so möchte, würde das doch auch gehen:

Task1  Task2
  \    /
   \  /
access_mgr
    |
    |
   UART

Mache ich auf dem µc jeden Tag, 1x I²C, aber 5 Devices.
Die Tasks fragen per DMA aber geben den Job in Auftrag und der Manager 
kümmert sich drum und gibt ne Callback.

Problem gelöst.

OK, das geht am Thema vorbei, aber wollt nur verdeutlichen, dass man das 
"Objekt" nicht immer besitzen muss...alles design sache.

---

Eigentlich wollte der TO nur wissen, wie man eine static gehaltene 
varibale im eigenen modul sicher setzen kann...
und um tipp arbeit zu ersparen, kommt ja je aufs gleiche rauß:

get_default_foo
// do anything with your foo
set_my_foo
// and hope ;)

[foobar (Gast)]

> Ich hätte gerne eine elegantere universelle Methode in etwa so:
> void setStruct_int("parameter", int value)
> {
>   Test.“parameter“ = value;
> }

Die C Version davon:

struct.h:

enum StructElem { ELEM_I, ELEM_X };
void setStruct(enum StructElem what, int value);

struct.c

#include "struct.h"

static struct {
  int i;
  int x;
} test;

void setStruct(enum StructElem what, int value)
{
  switch (what)
  {
    case ELEM_I:  test.i = value;  break;
    case ELEM_X:  test.x = value;  break;
  }
}

main.c

#include "struct.h"

  ...
  setStruct(ELEM_I, 42);
  setStruct(ELEM_X, 0);

Falls der Datentyp von "value" je nach Element unterschiedlich ist (z.B. 
int oder double oder pointer), kann man das mit stdarg.h machen.

[Adam P. (adamap)]

foobar schrieb:
> Die C Version davon:

elegante Idee....
aber ich frag mich ob das so intuitiv beim tippen ist?

will ich wirklich jedes mal angeben, was ich setzen will....
dazu kommt noch der overhead der funktionsaufrufe :

[Programmiersprachentheaterintendant (Gast)]

foobar schrieb:
>> Ich hätte gerne eine elegantere universelle Methode in etwa so:
>> void setStruct_int("parameter", int value)
>> {
>>   Test.“parameter“ = value;
>> }
>
> Die C Version davon:
>
> struct.h:
>

> enum StructElem { ELEM_I, ELEM_X };
> void setStruct(enum StructElem what, int value);
>

>
> struct.c
>

> #include "struct.h"
> 
> static struct {
>   int i;
>   int x;
> } test;
> 
> void setStruct(enum StructElem what, int value)
> {
>   switch (what)
>   {
>     case ELEM_I:  test.i = value;  break;
>     case ELEM_X:  test.x = value;  break;
>   }
> }
>

Ja, auch solche CodePatterns kommen gerne vor in heterogenen Systemen.
Da dann auch oft die Anzahl Felder in den structs ergo die Anzahl 
Einträge für die Enums nicht klein bleibt, werden Wartung und 
Erweiterung solchen Codes sehr Disziplinlastig.

Deshalb: Datenbeschreibungsprache --> generierten Code um diese Daten.

[Adam P. (adamap)]

Oder halt so...geht auch:

main.c

#include <stdio.h>
#include <stdlib.h>

#include "foo.h"

int main()
{
    bool ret;

    /* TEST 1 */
    ret = set_my_foo(&foo.i, 1400);

    if (ret)    printf("ret: ok\n");
    else        printf("ret: failed\n");

    ret = set_my_foo(&foo.x, 60);

    if (ret)    printf("ret: ok\n");
    else        printf("ret: failed\n");

    return 0;
}

foo.h

#ifndef FOO_H
#define FOO_h

#include <stdint.h>
#include <stdbool.h>

typedef struct foo_t
{
    int i;
    int x;
} foo_t;

extern foo_t foo;

bool set_my_foo(foo_t *src, int value);

#endif // FOO_H

foo.c

#include "foo.h"

foo_t foo;

bool set_my_foo(foo_t *src, int value)
{
    if ((&foo.i == &src->i) && (value > 1000))
        return false;

    if ((&foo.x == &src->x) && (value < 45))
        return false;

    foo.i = src->i;
    foo.x = src->x;

    return true;
}

[Rolf M. (rmagnus)]

Adam P. schrieb:
> will ich wirklich jedes mal angeben, was ich setzen will....

Musst du doch sowieso.

[oli (Gast)]

eine weitere Möglichkeit:

[c]

#define OFFSETOF(TYPE, ELEMENT) ((int)&(((TYPE *)0)->ELEMENT))

struct test
{
  int i;
  int x;
  int y;
};

static struct test Test;

void setStructInt(int offset, int value)
{
  char *ptr;
  ptr = (char*)&Test;

  ptr += offset;
  *ptr = value;
}

int main()
{

  setStructInt( OFFSETOF(struct test, i),1);
  setStructInt( OFFSETOF(struct test, x),2);
  setStructInt( OFFSETOF(struct test, y),3);


  return 0;
}

/[c]

[oli (Gast)]

oli schrieb:
> void setStructInt(int offset, int value)
> {
>   char *ptr;
>   ptr = (char*)&Test;
>
>   ptr += offset;
>   *ptr = value;
> }

muss so heißen:

void setStructInt(int offset, int value)
{
  int *ptr;
  ptr = (int*)&Test;

  ptr += offset/4;
  *ptr = value;
}

[Irgend W. (Firma: egal) (irgendwer)]

oli schrieb:
> eine weitere Möglichkeit:
>
> [c]
>
> #define OFFSETOF(TYPE, ELEMENT) ((int)&(((TYPE *)0)->ELEMENT))

und wo soll da jetzt der Vorteil gegenüber der schon vorhanden offsetof 
sein?
https://en.cppreference.com/w/c/types/offsetof

[oli (Gast)]

Irgend W. schrieb:
> und wo soll da jetzt der Vorteil gegenüber der schon vorhanden offsetof
> sein?

Ist das gleiche Makro!

Es ging nur um die Methodik, wie man das realisiert.

[P. S. (namnyef)]

Peda schrieb:
> Das blöde ist jetzt das ich für jedes Struct-Element eine eigene set
> Fuktion schreiben muss.

Es ist zwar die Frage um wie viele Elemente es geht und welchen Kontext 
sie zueinander haben, aber warum ist das blöd? Grundsätzlich sind viele 
Funktionen mit geringer Komplexität wartungsfreundlicher als wenige 
Funktionen mit hoher Komplexität. Natürlich ist - je nach Anwendungen - 
auch oft eine andere Herangehensweise sinnvoll, aber prinzipiell sind 
viele Funktionen erst mal nichts schlimmes, wenn man sich dadurch keine 
anderen Nachteile einhandelt (doppelter Code, usw.).

[A. S. (Gast)]

Peda schrieb:
> Hat jemand eine Idee wie man das in C realisieren kann?

Solange der TO nicht sagt, was er erreichen will, macht keine Antwort 
Sinn.

Wenn der setter nur setzt, ist er über. Wenn er mehr macht, kommt es 
darauf an, was er machen soll.