Specialising a member function with a template template parameter

Here is the guts of my problem...

I dont seem to be able to use the template template parameters TT1, TT2 & TT3 to specialize my member function Container:: object(). Basically I want to use them in order to select the
correct member variable index1_, index2_ and index3_ as this presents a nice Tag-style interface.

Any Ideas?

Code:

template<class T> struct X{ /* omitted*/ };
template<class T> struct Y{ /* omitted*/ };
template<class T> struct Z{ /* omitted*/ };

template < class T,
template <typename> class TT1,
template <typename> class TT2,
template <typename> class TT3>
struct Container
{
 template <template <typename> class FTT> FTT<T> object();

 /* All functions fail to compile. Error is
 // error C3207: 'MyClass<T,TT1,TT2,TT3>:: object' :
 // invalid template argument for 'FTT', class template expected
 template <> TT1<T> object<TT1>() { return object1_;}
 template <> TT2<T> object<TT12>() { return object2_;}
 template <> TT3<T> object<TT13() { return object3_;}
 //*/

 //* Compiles but needs to use template template parameters for generality
 template <> X<T> object<X>() { return object1_;}
 template <> Y<T> object<Y>() { return object2_;}
 template <> Z<T> object<Z>() { return object3_;}
 //*/

 private:

 TT1<T> object1_;
 TT2<T> object2_;
 TT3<T> object3_;
};


int _tmain(int argc, _TCHAR* argv[])
{
 Container<int, X, Y, Z> container;
 X<int> result1 = container.object<X>();
 Y<int> result2 = container.object<Y>();
 Z<int> result3 = container.object<Z>();
 return 0;
}

Templates are only syntactic sugar over preprocessor replacement. And replacing all your template code, the compiler would have to generate 3 functions named "object" differing by returntype only. This is not possible. Not even for a normal non-template class.

btw: include your error message next time, people don't like guessing what your problem may be, when you already have a specific error report.

It's wrong you explicit specialize like this, this is because TT1, TT2 and TT3 is same thing before you instantiate it. to fix this problem, you have to try other ways

e.g.

Code:

template<typename _Target> int match(_Target**);
template<typename _Target> char match(...);

template<typename _T, typename _U>
struct same_type
{
	enum{ value = sizeof(int) == sizeof(match<_T>((_U**)0))};
};

template<bool _Cond, typename _True, typename _False>
struct _if
{
	typedef _True value_type;
};

template<typename _True, typename _False>
struct _if<false, _True, _False>
{
	typedef _False value_type;
};

template<int ID>
struct IntToType{ enum {value = ID}; };

template < class T,
template <typename> class TT1,
template <typename> class TT2,
template <typename> class TT3>
struct Container
{
	typedef TT1<T> T1;
	typedef TT2<T> T2;
	typedef TT3<T> T3;

	template <template <typename> class FTT>
	FTT<T> object()
	{
		typedef FTT<T> type;

	                                  
		return __object<_if<same_type<T1, type>::value,
									IntToType<1>,
									typename _if<same_type<T2, type>::value,
											IntToType<2>,
											typename _if<same_type<T3, type>::value,
												IntToType<3>,
												IntToType<0>
											>::value_type
									>::value_type
						>::value_type::value, FTT<T> >::get(*this);
	}
 
	template<int _ID, typename _T>
	struct __object
	{
		static _T get(Container&){ return _T(); };        
	};
 
	template<typename _T>
	struct __object<1, _T>
	{
		static TT1<T> get(Container& c){ return c.object1_; }        
	};
 
	template<typename _T>
	struct __object<2, _T>
	{
		static TT2<T> get(Container& c){ return c.object2_; }        
	};

	template<typename _T>
	struct __object<3, _T>
	{
		static TT3<T> get(Container& c){ return c.object3_; }       
	};

	private:

	TT1<T> object1_;
	TT2<T> object2_;
	TT3<T> object3_;
};


template<class T> struct X{ /* omitted*/ };
template<class T> struct Y{ /* omitted*/ };
template<class T> struct Z{ /* omitted*/ };

int main()
{
	Container<int, X, Y, Z> container;
	X<int> result1 = container.object<X>();
	Y<int> result2 = container.object<Y>();
	Z<int> result3 = container.object<Z>();


    std::system("pause");
}

Thanks for your posts.

JinHao that is *wonderful* code... )...

Quite good, except that it blatantly violates all the rules about identifiers.

1) Globally scoped identifiers starting with an underscore ("_if). Not allowed. All such identifiers are reserved for the implementation.

2) Identifiers of any scope starting with a double underscore ("__object") or an underscore followed by an upper case letter ("_Cond", "_True", ...). Not allowed. All such identifiers are reserved for the implementation. In particular, an implementation may define extension keywords (such as MS's __declspec) or macros by such names, and that would seriously ruin your day.

An identifier starting with a double underscore like __object is for a inner class, starting with an underscore followed by an upper case letter like _Cond is for template parameter.

the rule is quite simple, maybe it is not your rule or other rules.

The rule is simple, yeah. But it violates the C++ standard. You're simply not allowed to use such identifiers. This is not a matter of taste.

please show me the details in c++ standard.

C++ supports UCN, is it violates the "Standard" if a programmer does not write C++ in English or uses other rules we've never met??

Originally Posted by jinhao

please show me the details in c++ standard.

From the C++ Standard (ISO/IEC 14882:2003) section 17.4.3.1.2 "Global names":

Certain sets of names and function signatures are always reserved to the implementation:
- Each name that contains a double underscore (_ _) or begins with an underscore followed by an uppercase letter is reserved to the implementation for any use.
- Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.

i m so sorry, i've never read C++03. it's a damn thing to let non-compliant code written before 2003 be compliant for old new standard. sigh...

It is exactly the same in C++98, and in the final public draft.
http://www.open-std.org/jtc1/sc22/open/n2356/

The same clause also appears in the final public draft of C99, and I dare claim that C90 contains exactly the same. (But I have no document to confirm this.)

So this thing has been invalid since just about forever (since pre-standard versions of C++ followed C conventions).