Dedukcja typu w template

Cześć,

Mam taki konstruktor:

MyClass(FactoryClass& factory) : myVariable(factory.get<myType>()) {}

Fabryka czyta obiekty ze zewnętrznego pliku, odszyfrowuje i zwraca. Jest tam powiedzmy taki template:

template <typename T>
T get () { return makeObject<T>(); }

Chciałem to zrobić krócej na zasadzie:

 
myVariable(factory >> myVariable)

Idea była taka, by nie przepisywać typów obiektów, a tylko nazwy...

ale dostaję ostrzeżenia, że jest uninitialized when used here. Czy da się to zrobić bardziej "elegancko"? Wtedy muszę przekazać zmienną, żeby wydedukować typ T, a ona zawsze będzie unitialized.

Pokaż kod operatora >>. Ale możliwe, że kompilator przesadza.

Operator praktycznie taki sam jak poprzednia funkcja:

 
template <typename T>
T operator>> (T& object) { return makeObject<T>(); }

Może podaj do operatora T*? Jak dla mnie Twój kod jest poprawny, a kompilator powinien zajrzeć do funkcji, której ciało widzi.

Jeśli zrobię coś takiego:

 
template <typename T>
T operator>> (T* object) { return makeObject<T>(); }

Dla T& wszystko działa, ale ze wspomnianym warningiem.

dostaję błąd: Invalid operands to binary expression ('FactoryClass' and 'int')
Kompiluję na macu w xcode.

Wtedy inicjalizuj ze wskaźnikiem: myVariable(factory >> &myVariable)

Ale tak ogółem to średnio czytelne jest z operatorem >>, nawet jeśli jest "cool". Może po prostu użyj decltype?

kq napisał(a):

Ale tak ogółem to średnio czytelne jest z operatorem >>, nawet jeśli jest "cool". Może po prostu użyj decltype?

Użyłbym, ale nie bardzo wiem jak :) Nie jestem orłem z C++, a jestem na stażu w ObjC z dodatkiem C++. Będę wdzięczny za wskazówki.

Operator >> nie jest "cool" ale w pracy seniorzy go lubią.

MyClass(FactoryClass& factory) : myVariable(factory.get<decltype(myVariable)>()) {}

Swoją drogą jaki kompilator i jakie ustawienia warningów strzelają? "U mnie działa"

struct Factory
{
	template<typename T>
	T make(){ return {}; }

	template<typename T>
	T operator<<(T*){
		return make<T>();
	}

	template<typename T>
	T operator>>(T&){
		return make<T>();
	}
};


int main()
{
	Factory f;
	int a{f.make<decltype(a)>()};
	int b{f << &b};
	int c{f >> c};
}

http://melpon.org/wandbox/permlink/oJsZJQmgDVtdQVSI

OK tak to czaję :) A jest jakiś sposób by zrobić to wewnątrz funkcji get(), ukryć decltype() aby inicjalizacja myVariable( ) miała jak najprostszą postać (takie założenie projektu)?