C++Talk.NET

Loban A Rahman · Guest

Help! How do I make the following standards compliant:

template<typename T>
class Foo
{
struct bar
{
template<bool B>
struct moo
{
typedef tar& boo_type;
};

// FIXME: This section is the problem
template<>
struct moo<true>
{
typedef tar boo_type;
};
};

bar::moo<false>::boo_type a;
bar::moo<true>::boo_type b;
};

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Greg Herlihy · Guest

Loban A Rahman wrote:

werasm · Guest

Loban A Rahman wrote:

Loban A Rahman · Guest

Done! Check it out. I used an anonymous namespace outside the class.

namespace
{
template<typename T>
struct no_qualifiers
{
typedef
typename boost::
remove_cv<typename boost::
remove_reference type>::
type
type;
};

template<typename T, bool B>
struct is_fund_switch
{
typedef
const typename no_qualifiers<T>::type&
type;
};
template<typename T>
struct is_fund_switch<T, true>
{
typedef
const typename no_qualifiers<T>::type
type;
};

template<typename T>
struct parameter
{
typedef
typename is_fund_switch<T, boost::is_fundamental::type
type;
};
}

template <typename T>
class Event
{
typedef typename parameter<T>::type parameter_type;

/* Code that uses parameter_type */
}

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Loban A Rahman · Guest

Thanks for the reply, I think I have enough info now. However, since
you said you "don't know enough of the actual problem being solved",
I'm posting more of the actual code, in case you can give additional
advice.

#include <boost/type_traits.hpp>

template <typename T>
class Event
{
public:
/*
This handy typedef removes any const, volatile, or references
from the T type, which allows us to accept functions that take const
references to T as their parameter type. If we didn't do this, the
compiler would be trying to call Transmit(const const T &&object), and
since you can't have a reference to a reference, it wouldn't compile.
With this typedef, the call becomes Transmit(const T &object), which
is exactly what we want.
*/
typedef typename
boost::remove_cv<typename boost::remove_reference::type
no_qualifiers_T;

struct parameter
{
template<bool B>
struct is_fund_switch
{
typedef const no_qualifiers_T ¶m_type;
};

template<>
struct is_fund_switch<true>
{
typedef const no_qualifiers_T param_type;
};
};

/*
This typedef provides the final version of the parameter type that we
want to use in our function objects. It passes fundamental types
(ints, floats, void) as const T, which is the right way to pass simple
types, and passes all other types as const T &, the right way to pass
complex types.
*/
typedef typename
parameter::is_fund_switch<boost::is_fundamental::param_type
parameter_type;
};

Perhaps there's a simpler way to do this?

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Carl Barron · Guest

Loban A Rahman <loban.rahman (AT) gmail (DOT) com> wrote:

Greg Herlihy · Guest

Loban A Rahman wrote:

Valentin Samko · Guest

werasm wrote:

werasm · Guest

Valentin Samko wrote:

werasm · Guest

werasm wrote:

Johan · Guest

Since total specialization of inner structs is not allow, we can used a
trick to simulate it with a partial specialization:

class Foo
{
// The default argument will not change the call in the user code.
template<bool B, typename Dummy = void>
struct Moo
{
typedef int* type;
};

// partial specialization is accepted
template<typename Dummy>
struct Moo<true, Dummy>
{
typedef int type;
};
};

int main()
{
Foo::Moo<true>::type a = 42;
Foo::Moo<false>::type b = &a;
}

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Loban A Rahman · Guest

Greg Herlihy,

You are right! boost/call_traits.hpp does exactly what this code wants
to do. I'll inform the original programmer of this code about it. (I'm
just working on portability - his code works perfectly in Windows, I'm
working to get it portable to linux).

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]