Const Pointer als Rückgabewert

[Felix (Gast)]

Ich habe eine große Struktur mit Konfigurationsdaten.

Ich möchte auf die Struktur so zugreifen, dass ich sie nicht aus 
versehen verändern kann, möchte aber nicht nicht die komplette Struktur 
zurückgeben da dies viel zu viel zeit kostet wenn man nur einen wert 
daraus möchte.

Nun sehe ich zwei Lösungen, ein funktioniert sicher ist aber relativ 
aufwendig, bei der anderen bin ich mir nicht sicher ob sie das macht was 
ich möchte. Sprich ob ich nicht "aus Versehen" die Konfiguration 
verändern kann.

Sicher? (leider muss man zwei Sachen updaten und auf Konsistenz prüfen)

typdef struct{
float bla0;
float bla1;
float bla2;
}conf_struct_t;

typdef enum{
bla0 = 0, bla1 = 1,bla2 = 2
}conf_enum_t;

union{
conf_struct_t conf;
float *value;
}conf_union;


float get_conf(conf_enum_t struct_member){
   return conf_union.value[struct_member];
}

//functionsaufruf:


iNeedConf = get_conf(bla1);

elegant?

typfdef struct{
float bla0;
float bla1;
float bla2;
}conf_t;

conf_t conf;

const *conf_t get_conf(void){
   return &conf;
}

//functionsaufruf:


iNeedConf = get_conf()->bla2;

sicher aber sehr langsam?

typfdef struct{
float bla0;
float bla1;
float bla2;
}conf_t;

conf_t conf;

conf_t get_conf(void){
   return conf;
}

//functionsaufruf:


iNeedConf = get_conf().bla2;

[Johann L. (gjlayde)]

Sowas?

/* Im Header */

#include <stdlib.h>

typdef struct
{
    float a, b, c;
} data_t;

extern const data_t* get_x (void);
extern const data_t* get_y (void);
extern const data_t* get_z (size_t);

#define Z0 (*get_z (0))
#define Z1 (*get_z (1))
#define Z2 (*get_z (2))

/* Im C-File */

static const data_t x = { 1.0, 2.0, 3.0 };

const data_t* get_x (void)
{
    return &x;
}

const data_t* get_y (void)
{
    static const data_t x = { 42.0, 3.14, 0.0 };
    return &x;
}

const data_t* get_z (size_t n)
{
    static const data_t x[] =
      {
         { 42.0, 3.14, 0.0 },
         { 2.0, 0.14,  9.0 },
         { 2.0, 3.14, 0.0 }
      };

    if (n >= sizeof (x) / sizeof (*x))
       abort();

    return &x[n];
}

[Karl H. (kbuchegg)]

Felix schrieb:

> aufwendig, bei der anderen bin ich mir nicht sicher ob sie das macht was
> ich möchte. Sprich ob ich nicht "aus Versehen" die Konfiguration
> verändern kann.

Was hindert dich daran, es einfach auszuprobieren?

struct test
{
  int a;
};

struct test myObj = { 5 };

const struct test* foo()
{
  return &myObj;
}


void bar( int* v )
{
  *v = 8;
}

void baz( struct test* v )
{
  v->a = 8;
}

int main()
{
  struct test* b;

  b = foo();
  b->a = 8;

  foo()->a = 9;

  bar( &(foo()->a) );

  baz( foo() );
}

jags durch den Compiler und sieh dir an was passiert. Probier noch alle 
anderen Sachen aus die dir einfallen, was alles du mit dem Returnwert 
von foo() anstellen könntest um zu versuchen an a ranzukommen und es zu 
verändern.

[Johann L. (gjlayde)]

Karl Heinz Buchegger schrieb:

> struct test myObj = { 5 };
>
> const struct test* foo()
> {
>   return &myObj;
> }

Das ist undefined in C.

Etwa wenn foo() verwendet wird unter der Annahme daß sich myObj nie 
ändert, myObj aber dennoch geändert wird.

[daniel (Gast)]

Johann L. schrieb:
> Das ist undefined in C.
>
> Etwa wenn foo() verwendet wird unter der Annahme daß sich myObj nie
> ändert, myObj aber dennoch geändert wird.

kenne ich so nicht. Kannst Du auf Standard irgendwo verweisen?
wenn volatile in die Definition mit aufgenommen wird, kann ich
dann an ein Zeiger ohne volatile Definition zuweisen bzw implizit
bei Rückgabe bei Funktionen. Etwa so

int const volatile i = 5;
const int * pi;

pi = &i;
const int * foo(void){ return &i; }

[Johann L. (gjlayde)]

daniel schrieb:

> kenne ich so nicht.

Stimmt, Denkfehler meinerseits.