void param;

XSpille

Hallo zusammen,

ich würde gerne etwas wie:

void param;

haben.

Generell hört sich das wohl ziemlich unnütz an, jedoch habe ich eine
abstrakte Basis-Klasse, die (mehrere!) unterschiedliche Parameter besitzt.
Die Typen möchte ich dann in der abgeleiteten Klasse spezifizieren.

Hier jetzt zwar nicht abstrakt, aber nach diesem Muster möchte ich es haben:

template<typename TParam>
class Foo{
        TParam param;
};

int main(){
        Foo<int> foo1;
        Foo<double> foo2;
        Foo<void> foo3; // Das geht ja leider so nicht :(
}

Zur Zeit habe ich dazu eine private Basis-Klasse:

template<typename T,int I=0, bool B=!boost::is_void<T>::value>
	class ConditionalMember{
	protected:
		typedef T type;
        T& value(){ return t; }
        T t;
	};

	template<typename T,int I>
	class ConditionalMember<T, I, false>{
	protected:
		typedef void type;
        void value(){}
	};

und definier mir eine param()-Funktion, die mir ein ConditionalMember<...>::type zurückliefert.
(Ich verwende den zusätzlichen int, falls zwei Parameter den gleichen Typ haben)

template<typename TParam>
class Foo : private ConditionalMember<TParam,0>{
public:
        typedef typename ConditionalMember<TParam, 0>::type param_1_type;
        param_1_type param_1(){
                return ConditionalMember<TParam, 0>::value();
        }

};

int main(){
        Foo<int> foo1;
        int i = foo1.param_1();
        Foo<double> foo2;
        double d = foo2.param_1();
        Foo<void> foo3;
        foo3.param_1();
}

Kennt jemand eine sauberere Möglichkeit?

Gruß,
XSpille

ipsec

Mir erschließt bei grober Betrachtung der Sinn nicht (irgendwie muss ja der Parameter mal benutzt werden, wie soll das bei void gehen), aber abgesehen davon sieht das ja schon ganz sauber aus. Ich wundere mich blos gerade, dass T& value() bei void nicht einen Fehler liefert. Standardkonformer wäre vermutlich, wenn du boost::add_reference benutzen würdest.

Tachyon

So vielleicht?

template<typename T>
struct condition_member
{
    typedef T type;
};

template<>
struct condition_member<void>
{
    struct void_type{};
    typedef void_type type;
};

template<typename TParam>
class foo
{
    typedef typename condition_member<TParam>::type param_type;
    param_type param;
};

XSpille

Danke dir!

ipsec schrieb:

Ich wundere mich blos gerade, dass T& value() bei void nicht einen Fehler liefert.

wegen der Template-Spezialisierung Es steht nirgends void&

ipsec schrieb:

Mir erschließt bei grober Betrachtung der Sinn nicht (irgendwie muss ja der Parameter mal benutzt werden, wie soll das bei void gehen)

Ich hab in einer anderen Klasse mehrere Vektoren mit diesen unterschiedlichen Objekte.
Aus diesem Objekt hol ich mir dann ein Parameter-Informations-Objekt.
Das funtioniert natürlich ebenfalls mit Template-Funktionen.
Wenn man dann mit dem Objekt arbeiten möchte (Paramteter verändern möchte),
muss man natürlich wissen, was es für Typen sind.

(Ich weiß, klingt jetzt ziemlich abstrakt)

XSpille

Tachyon schrieb:

So vielleicht?

template<typename T>
struct condition_member
{
    typedef T type;
};

template<>
struct condition_member<void>
{
    struct void_type{};
    typedef void_type type;
};

template<typename TParam>
class foo
{
    typedef typename condition_member<TParam>::type param_type;
    param_type param;
};

Danke, eine gute Idee, jedoch im Gegensatz zu meinem Ansatz etwas Speicherverschwendung und ich hab etwas ziemlich speicherintensives damit vor
und ich möchte darauf achten...

Ich hab Foo um einen int erweitert, da ja kein Objekt Größe 0 haben kann, dann sieht man es (deutlich):

#include <xsp/util.hpp>
#include <iostream>

template<typename T>
struct condition_member
{
    typedef T type;
};

template<>
struct condition_member<void>
{
    struct void_type{};
    typedef void_type type;
};

template<typename TParam>
class Bar
{
    typedef typename condition_member<TParam>::type param_type;
    param_type param;
    int i;
};

template<typename TParam>
class Foo : private ConditionalMember<TParam,0>{
public:
        typedef typename ConditionalMember<TParam, 0>::type param_1_type;
        param_1_type param_1(){
                return ConditionalMember<TParam, 0>::value();
        }
private:
        int i;

};

int main(){
        std::cout << sizeof(Foo<void>) << std::endl;
        std::cout << sizeof(Bar<void>) << std::endl;
}

4
8

DocShoe

Und was ist, wenn du die Speicherausrichtung und -padding veränderst? Bei mir erhalte ich folgende Größen (Codegear 2007):

struct T1
{
};

// Byte Alignment
#pragma pack( push, 1 )
struct T2
{
};
#pragma pack( pop )

int main()
{
   int i1 = sizeof( T1 ); // 8
   int i2 = sizeof( T2 ); // 1
}