zwei Spezialisierungen einer Template Klasse und bedingtes Kompilieren

[mekakic]

Hi

ich weiß, daß man das irgendwie über Templates machen kann. Ich möchte einen Template Parameter angeben, über den ich dann praktisch if/then/else Vergleiche auf Codegenerierungsebene der Klasse durchführe: also abhängig vom Template Parameter soll der eine Teil in die Klasse gebaut werden, sonst ein anderer Teil.

Konkret: Es soll die gleiche Klasse einmal als Synchronisierter Typ und einmal unsychronisiert verhanden sein - und diese Mechanismen sollen eben abhängig vom Template Parameter ein oder ausgebaut werden. Wie macht man das? Die ganzen Template Tutorials handeln immer nur vom Syntax wie man irgendwelche Typen einbaut.

danke

[Ectoplasma]

Sorry, hatte etwas geposted, was du eh weisst ;)

[Ectoplasma]

#define NEED_SYNC 1


class UnsynchronizedAction {
public:

void execute() {
// do something unsynchronized
}
};


class SynchronizedAction {
public:

void execute() {
// do something synchronized
}
};


template <bool _condition, class _then, class _else>
struct _if {
typedef _then Type;
};


// template specialization
template <class _then, class _else>
struct _if<false, _then, _else> {
typedef _else Type;
};


// example
_if<NEED_SYNC, SynchronizedObject, UnsynchronizedObject>::Type action;

action.execute();


Meinst du vielleicht soetwas?

[Coda]

Einfach einen bool als Template-Parameter und dann mit Bedingungen die richtigen Codeteile auswählen funktioniert auch, da der Compiler den nichtverwendeten Teil wegoptimieren wird.

[mekakic]

Meinst du vielleicht soetwas?Danke. Das geht in die Richtung bzw. so in etwa lief das schon. Ich habe mal was gelesen, daß war allerdings etwas einfacher. Da hat man auch über Templates structs zu Kontrollstrukturen instrumentalisiert und damit konnte man richtig im Code (if, then, else)-formulieren und wenn es auskompiliert wurde, war nur noch der fragliche Bereich vorhanden. Fand ich sehr elegant, aber ich erinnere mich nicht mehr richtig.

Einfach einen bool als Template-Parameter und dann mit Bedingungen die richtigen Codeteile auswählen funktioniert auch, da der Compiler den nichtverwendeten Teil wegoptimieren wird.Danke. Wie ist das, wenn es teilweise Mutex Stack Guards sind, ist es dann nicht etwas riskant?

So wird sicher kein neuer Stack aufgebaut?

template <typename T, bool SYNCED = true>
class Test
{
void foo()
{
if (SYNCED)
ScopedMutexGuard m(mMutex);
//... critical ops
}
};

[Coda]

So wird sicher kein neuer Stack aufgebaut?
Der Code in "if(SYNCED)" wird sicher nie ausgeführt, wenn SYNCED=false und andersrum, falls du das wissen willst. Das "schlimmste" was passieren könnte ist, dass der Compiler die Bedingung nicht komplett entfernt - dann müsste er aber schon ziemlich mies sein.

[mekakic]

Ich meinte eher in die Richtung, ob es passieren kann, daß ein Compiler hier ein neuen Stack aufbaut - also eher sowas macht:
if (SYNCED)
{
ScopedMutexGuard m(mMutex);
}... und damit das StackGuard gleich wieder abschießt. Denke eigentlich nicht, daß dies passieren darf. Wobei mir ein Ausdruck, der konstant in den Code generiert wird, lieber ist, werde ich es erstmal so machen.

[Ectoplasma]

Ich meinte eher in die Richtung, ob es passieren kann, daß ein Compiler hier ein neuen Stack aufbaut - also eher sowas macht:
if (SYNCED)
{
ScopedMutexGuard m(mMutex);
}... und damit das StackGuard gleich wieder abschießt. Denke eigentlich nicht, daß dies passieren darf. Wobei mir ein Ausdruck, der konstant in den Code generiert wird, lieber ist, werde ich es erstmal so machen.

Das ist aber schon böse. Der Compiler macht genau das, was er soll. Den Guard aufbauen und gleich wieder abschießen. Er muss sogar so vorgehen.

[mekakic]

Ich weiß, ich meinte ob eben jenes Gegenteil passieren kann (daß ein Stack eingefummelt wird, wo eigentlich keiner ist).