ich progge gerade ein (template-basiertes) neuronales Netz, das in (drei) verschiedenen Schichten unterschiedliche Neuronen hat. Je nachdem welche Neuronen verwendet werden haben diese Parameter von unterschiedlichen Typen oder nicht. Diese Parameter möchte ich nun auslesen um sie per EA zu modifizieren und zurückschreiben.

Also nun zu meinem daraus abgeleiteten relativ abstrakten Problem:
Ich habe eine Struktur mit zwei Listen von verschiedenen Typen. Aus dieser Struktur möchte ich die Parameter auslesen. Die zurückgelieferte Struktur ist natürlich abhängig von Typen darin und enthält jeweils separate Listen für Parameterinformationen für Typ T1 und Typ T2. Wenn allerdings einer der Typen keine Parameterinformationen hat, möchte ich ungern eine Liste mit einem Dummy-Typen haben. Deswegen habe ich mir überlegt wie ich es am besten lösen kann. Für den Fall, dass ein Typ Parameter hat, brauche ich eine Liste, ansonsten (optimalerweise gar nichts oder) ein leeres Parameterinfo Objekt. Zuerst muss ich dazu mein Objekt irgendwie kennzeichnen, ob er Parameter hat. Da diese Information zur Kompilierzeit gebraucht wird, muss es eine Konstante sein. Anhand dieser Konstante soll nun zur Kompilierzeit entschieden werden, ob ein Objekt mit Parameterinformationen oder ohne benötigt wird. Dazu habe ich eine Template-Spezialisierung für den Fall geschrieben, falls ein übergebener Template-Parameter gleich false ist. Damit man diesen 'Schummel'-Parameter nach außen nicht sieht, habe ich davon abeleitet. Dieser Parameter wird mit Hilfe der Konstanten gesetzt. Somit brauch ich nur ein Objekt mit dem entsprechenden Typ als Parameter erstellen und ich habe (nur) alle notwendigen Infos. Ähnlich bin ich auch bei den Funktionen für das füllen dieser Objekte vorgegangen. Da man keine partiellen Spezialisierungen für Template-Funktionen erstellen kann, greife ich auch hier auf eine Klasse zurück, die nichts macht falls der Template-Parameter false ist, ansonsten die Daten überträgt.

Hier der Code dazu (Sorry, dass er so lang ist):

#include <vector>
#include <utility>
#include <iostream>

class Foo{
public:
	static const bool has_parameters = false; 
};

template<typename T>
class Bar{
public:
	typedef T parameter_type;
	Bar(parameter_type i) : _param(i){}
	static const bool has_parameters = true; 
	parameter_type param() const{ return _param;}
private:
	parameter_type _param;
};

template<typename T, bool b>
class ParameterListBase{};

template<typename T>
class ParameterListBase<T, true>{
public:
	std::vector<typename T::parameter_type> vector;
};

template<typename T>
class ParameterListBase<T, false>{};

template<typename T>
class ParameterList : public ParameterListBase<T, T::has_parameters>{};

template<typename T1, typename T2>
struct FooBar{
	ParameterList<T1> first;
	ParameterList<T2> second;
};

template<bool b>
class ParameterExtractor{};

template<>
class ParameterExtractor<true>{
public:
template<typename T>
void operator()(std::vector<T>& vec, ParameterList<T>& list){
	for(T& t : vec){
		list.vector.push_back(t.param());
		std::cout << t.param() << " ";
	}
	std::cout << std::endl;
}
};

template<>
class ParameterExtractor<false>{
public:
template<typename T>
void operator()(std::vector<T>& , ParameterList<T>&){
	std::cout << "no param info" << std::endl;
}
};

template<typename T1, typename T2>
FooBar<T1, T2> extract_params(std::pair<std::vector<T1>, std::vector<T2> > data){
	FooBar<T1,T2> foobar;
	ParameterExtractor<T1::has_parameters> extractor1;
	extractor1(data.first, foobar.first);
	ParameterExtractor<T2::has_parameters> extractor2;
	extractor2(data.second, foobar.second);
	return foobar;
}

int main(){
	std::vector<Foo> foos;
	std::vector<Bar<int> > bars1;
	std::vector<Bar<float> > bars2;
	foos.push_back(Foo());
	bars1.push_back(Bar<int>(1));
	bars1.push_back(Bar<int>(2));
	bars2.push_back(Bar<float>(0.815));
	extract_params(std::make_pair(bars1, foos));
	std::cout << "---" << std::endl;
	extract_params(std::make_pair(bars2, bars1));
}

Also der Code funktioniert auch genauso wie er soll.

1 2
no param info
---
0.815
1 2

Irgendwie kommt mir mein Vorgehen etwas komisch vor. Würdet ihr so etwas analog lösen?
Was würdet ihr anders machen?
Gibt es eine Möglichkeit die entsprechenden Felder in FooBar nur zu erzeugen, wenn der Typ Paramter hat? Also ich erzeuge sonst ja leere Objekte.

Gruß,
XSpille

Gibt es eine Möglichkeit die entsprechenden Felder in FooBar nur zu erzeugen, wenn der Typ Paramter hat?

Gerade auf den Abschicken-Button gedrückt, da kam mir die Idee

Also so kann man es Lösen:

class Foo{
public:
        static const bool has_parameters = false;
};

template<typename T>
class Bar{
public:
        static const bool has_parameters = true;
        typedef T parameter_type;
};

template<typename T, bool b>
class AInfo{};

template<typename T, bool b>
class BInfo{};

template<typename T, bool b>
class CInfo{};

template<typename T>
class AInfo<T, true>{ public: typename T::parameter_type* a(){return 0;} };

template<typename T>
class BInfo<T, true>{ public: typename T::parameter_type* b(){return 0;} };

template<typename T>
class CInfo<T, true>{ public: typename T::parameter_type* c(){return 0;} };

template<typename T1, typename T2, typename T3>
class Info : public AInfo<T1, T1::has_parameters>, public BInfo<T2, T2::has_parameters>, public CInfo<T3, T3::has_parameters>{
};

int main(){
        Info<Bar<int>, Foo, Bar<float> > info;
        int* i = info.a();
        // info.b(); ### not available ###
        float* f = info.c();
}

EDIT: Ist natürlich schon eher Spielerei, aber manchmal will man halt wissen, ob man etwas verwirklichen kann

#include <vector>
#include <iostream>
#include <boost/type_traits/add_reference.hpp>

template<typename T>
class Foo{
public:
        typedef T parameter_type;
};
class Bar{
public:
        typedef void parameter_type;
};

template<typename T,int I=0>
class OptionalValue{
protected:
        T& value(){ return t; }
        T t;
};

template<int I>
class OptionalValue<void, I>{
protected:
        void value(){}
};

template<typename T1, typename T2>
class FooBar : public OptionalValue<typename T1::parameter_type, 0>, public OptionalValue<typename T2::parameter_type, 1>{
public:
        typename boost::add_reference<typename T1::parameter_type>::type value1(){ return OptionalValue<typename T1::parameter_type,0>::value();}
        typename boost::add_reference<typename T2::parameter_type>::type value2(){ return OptionalValue<typename T2::parameter_type,1>::value();}
};

int main(){
        FooBar<Foo<int>, Bar> foobar1;
        int& i = foobar1.value1();
        foobar1.value2();
        FooBar<Bar, Foo<double> > foobar2;
        foobar2.value1();
        double& d = foobar2.value2();
}