Stringify and Unstringify template arguments

Question

suppose I have a lot of classes with their "*Pack" counterparts in naming. For example, if I have a class Moo, I have MooPack, if I have Foo, I also have FooPack.

I want to have a c++ templated function which returns a FooPack from a Foo

template <class X, class XPack>
XPack packify(X input){
   ...
}

Is it possible to do this without having to specify the template argument? At the moment, this has to be done like the following:

Moo moo;
MooPack mooppey = packify<Moo, MooPack>(moo);

If it only required the Moo template argument, that ugly template specification bit could go away, but apart from using #defines, which isn't really the best solution either, still doesn't do it.

Is there a way, or will I have to wait for c++0x?

Puppy · Accepted Answer · 2011-01-07 13:17:53Z

5

You don't have to specify Moo, just MooPack, because moo will deduce the argument for you. However, I'd suggest that you make MooPack a typedef or nested class (called Pack) inside Moo itself, in which case you can easily access it by typename X::Pack inside the template.

class Moo {
public:
    class Pack {
        ...
    };
};
template<typename T> typename T::Pack packify(T t) {
    ...
}

// usage

Moo m;
Moo::Pack p = packify(m);

answered Jan 7, 2011 at 13:17

Puppy

147k40 gold badges271 silver badges481 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

kamziro Over a year ago

Ah yes, I think specifying only one argument is actually acceptable enough (two args just look ugly). That nested class thing is a great idea, but I can't change the existing class declarations..

Konrad Rudolph Over a year ago

You don’t even need to nest the *Pack class, you just need to provide a nested typedef to it. The usage is the same as in the above example. This is a pretty common pattern (called “metafunction”).

Grizzly · Accepted Answer · 2011-01-08 13:01:03Z

As the answer by DeadMG already mentioned you don't need to explicitely specify the parameter type as it can be deduced automaticaly (if it's the second instead of the first template parameter). Since you said you can't change the type declarations to form a link between the classes, I would propose the traits route for that (think std::iterator_traits):

template<typename T> struct pack_traits;
template<> struct pack_traits<Moo> { typedef MooPack Pack; };
...//traits for other packifable classes

template<typename T> pack_traits<T>::Pack packify(T val){...}
...
Moo moo;
MooPack mooppey = packify(moo);

This way you can call the function without manually specifying template arguments, without needing to modify the classes themselves.

Collectives™ on Stack Overflow

Stringify and Unstringify template arguments

2 Answers 2

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related