folgendes Funktioniert:

void foo(const char * data)
{

}

// hier legt der compiler automatisch ein statisches char Array an und übergibt es der Funktion
foo("hello world");

Frage:
kann man sowas (ähnliches) auch mit integern bzw. enum-Werten machen?

enum someId
{
    id0,
    id1,
    id2,
    id3,
    idInvalid
};

class CFoo()
{
public:
	CFoo(const someId * configuration);
}

// das hier ist unschön, da die Konfiguration getrennt von den Objekten angelegt werden muss
static const someId[] config0 = {id0, id2, idInvalid};
static const someId[] config1 = {id1, id2, id3, idInvalid};
CFoo foo0(config0);
CFoo foo1(config1);

// so etwas wäre schöner, compiliert aber in der Form leider nicht.
CFoo foo0({id0, id2, idInvalid});
CFoo foo1({id1, id2, id3, idInvalid});

=> Kann man den Compiler dazu veranlassen, das Array analog zu den strings automtatisch zu generieren?

Vielen Dank und schöne Grüße,
Martin

z.B.

// Die normale Funktion
void foo(int const * bar)
{
    // mach was mit bar
}

// Ein Wrapper um die normale Funktion
void foo(initializer_list<int> init)
{
    // laut cppreference.com liefert begin einen Zeiger auf das erste Element
    foo(init.begin());
    // alternativ, um sicher zu gehen, falls begin doch einen Iterator liefert
    foo(&(*(init.begin())));
}

// Aufruf:
foo({1, 2, 3});
// das ruft erst die Funktion mit der initializer_list auf, welche wiederum deine eigentliche Funktion aufruft.

Da das ein C++11 Feature ist, solltest du aber erstmal in der Doku deines Compilers nachschlagen, ob dieser initializer_lists bereits unterstützt.

danke für deine Antwort.
Dann führt an der "unschönen" Lösung wohl kein Weg vorbei.
Bin auf einem Embedded-System unterwegs und hab nicht mal die normale STL zur Verfügung, von C++11 Features ganz zu schweigen :-(.

Gruß,
Martin