ich spiele grad bisschen mit C++ template rum, und hab mal ein "blöde" Frage:

sagen wir mal ich habe ein struct

typedef struct Comp
{
	uint16_t ValA;
	uint16_t ValB;
	uint16_t ValC;
	uint16_t ValD;
} Comp;

und will mittels eine makros generisch auf einen best. parmater des structur selektieren:

#define Selector(x,Y) (uint16_t)(((Comp)x).Val##Y);

uint16_t t=  Selector(a,A);

geht sowa auch via templates ?

template <???>
class Selector
{
	public:
		Selector(Comp inst)
		{
			uint16_t x = inst.Val???;
		}
};

bitte fragt mich nich nach dem grund.. sonder einfach nur ob es möglich ist?

Grüßle

template<class T>
class selector<char> {
};

template<class T>
class selector<'A'> {
static auto select(T obj) -> decltype( obj.ValA) {return obj.ValA;}
};

template<class T>
class selector<'B'> {
static auto select(T obj) -> decltype( obj.ValB) {return obj.ValB;}
};

usw.

Dann könntest du So damit zugreifen:

uint16_t t =  selector<'A'>::select(a);

sagen wir mal ich habe ein struct

typedef struct Comp
{
	uint16_t ValA;
	uint16_t ValB;
	uint16_t ValC;
	uint16_t ValD;
} Comp;

Diese struct ist total unhandlich. Richtig modelliert sähe das so aus:

struct Comp {
        uint64_t Vals[4];
};

Dann kannst du dynamisch per Index zugreifen. Wenn du den Elementen Namen geben willst

enum class CompVal { A=0, B, C, D };

Alles andere (siehe Code von TNA) sind Workarounds um ein schlechtes zugrundeliegendes Design.

ich mach es jetzt so ungefähr:

uint16_t *p = ((uint16_t*)&Comp);

p[0] = ...; // entspricht A
p[1] = ...; // entspricht B

usw;)

typedef uint16_t Comp::*CompPart; // Typedef auf einen "pointer to member" (Deklaration ist wie üblich das selbe ohne das Keyword "typedef")

Deine "A", "B", "C" werden dann einfach zu Instanzen dieses Typs.

typedef uint16_t Comp::*CompPart;

static CompPart const Comp_ValA = &Comp::ValA;
static CompPart const Comp_ValB = &Comp::ValB;
static CompPart const Comp_ValC = &Comp::ValC;

uint16_t Selector(Comp const& c, CompPart p)
{
    return c.*p; // c.*p ergibt das Member an "Position" p im Objekt c
}

Comp theComp;
uint16_t someA = Selector(theComp, Comp_ValA);
// oder direkt
uint16_t someB = Selector(theComp, &Comp::ValB);

Geht natürlich genau so über einen non-type Template Parameter. (Wobei man bei Verwendung eines Tempaltes keine Member-Pointer bräuchte, man könnte dazu auch eine kleine Hilfsklasse pro Member schreiben die man dann als Type-Parameter an das Template übergibt.)