limiting a template class to certain types ?

[mast2as]

Is it possible to limit a template class to certain types only. I found
a few things on the net but nothing seems to apply at compile time.

template <typename T>
class AClass
{
public:
AClass() {}
};

AClass<floatflo atSomethng; // yes it's fine
AClass<intintSo mething; // no we don't want to allow the creation of
that object

Thank you, -mark

[red floyd]

ma*****@yahoo.c om wrote:

Is it possible to limit a template class to certain types only. I found
a few things on the net but nothing seems to apply at compile time.

template <typename T>
class AClass
{
public:
AClass() {}
};

AClass<floatflo atSomethng; // yes it's fine
AClass<intintSo mething; // no we don't want to allow the creation of
that object

template<typena me T>
class AClass {
public:
AClass() { }
};

template<class AClass<int>;

int main()
{
AClass<doublead ;
AClass<intai; // error
}

[Victor Bazarov]

ma*****@yahoo.c om wrote:

Is it possible to limit a template class to certain types only. I
found a few things on the net but nothing seems to apply at compile
time.

template <typename T>
class AClass
{
public:
AClass() {}
};

AClass<floatflo atSomethng; // yes it's fine
AClass<intintSo mething; // no we don't want to allow the creation of
that object

The simplest way is probably hide the implementation of your template
type in a separate translation unit and use explicit instantiations
to stuff the same TU with the implementations of the class for some
specific types. A better way would be to design it so there is no
need to limit it.

Or you could do something like this (AKA "type traits"):

template<class Tclass allowed { enum { yes }; };

// then specialise it for the types that you allow:

template<class allowed<float{ public: enum { yes = 1 }; };
template<class allowed<double{ public: enum { yes = 1 }; };

// and last, use it:

template<typena me T>
class AClass
{
static const bool allowed = allowed<T>::yes ;

public:
AClass() {}
};

int main() {
AClass<floataf;
AClass<intaf; // error
}

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Frederick Gotham]

ma*****@yahoo.c om posted:

AClass<floatflo atSomethng; // yes it's fine
AClass<intintSo mething; // no we don't want to allow the creation of

The examples on this page may interest you:

http://www.boost.org/doc/html/boost_staticassert.html

(However, one of the examples is dubious in that it should use
"numeric_limits <T>::digits" rather than "sizeof(T) * CHAR_BIT" ).

--

Frederick Gotham

[mast2as]

Thanks everyone for your help !

[Steve Hicks]

Victor Bazarov wrote:

Or you could do something like this (AKA "type traits"):

template<class Tclass allowed { enum { yes }; };

// then specialise it for the types that you allow:

template<class allowed<float{ public: enum { yes = 1 }; };
template<class allowed<double{ public: enum { yes = 1 }; };

// and last, use it:

template<typena me T>
class AClass
{
static const bool allowed = allowed<T>::yes ;

public:
AClass() {}
};

int main() {
AClass<floataf;
AClass<intaf; // error
}

This works great for allowing certain templated classes to be used.
But what about functions and overloaded operators? For instance, if I
have a certain family of template classes, how could I overload an
operator so that it only acts on these classes? I'm thinking in
particular of boost::lambda, where they overload just about every
operator to work on the placeholders, but boost::spirit and many other
libraries do this sort of thing as well, even without the proposed
(TR2?) "concept" formalism.

To be more concrete. Suppose I have a predicate template of some sort,
either like your allowed<T>::yes enum, or maybe a bool
allowed_p<T>::v alue. Short of sticking all the allowed classes into an
unnamed namespace to restrict scope (since this allows classes from
global scope as well), how could I write this function

template<class T>
increment_retur n_type<T>::type operator++(T x);

so that T can ONLY be a class which satisfies the predicate?

Thanks,
steve hicks

[Victor Bazarov]

Steve Hicks wrote:

[..] Suppose I have a predicate template of some
sort, either like your allowed<T>::yes enum, or maybe a bool
allowed_p<T>::v alue. Short of sticking all the allowed classes into
an unnamed namespace to restrict scope (since this allows classes from
global scope as well), how could I write this function

template<class T>
increment_retur n_type<T>::type operator++(T x);

so that T can ONLY be a class which satisfies the predicate?

I probably don't understand the requirements. Could you please provide
a C++ illustration (even if it doesn't compile)?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Michiel.Salters]

To be more concrete. Suppose I have a predicate template of some sort,

either like your allowed<T>::yes enum, or maybe a bool
allowed_p<T>::v alue. Short of sticking all the allowed classes into an
unnamed namespace to restrict scope (since this allows classes from
global scope as well), how could I write this function

template<class T>
increment_retur n_type<T>::type operator++(T x);

so that T can ONLY be a class which satisfies the predicate?

Just add a test, using the typedef T type; trick again.

template<bool bstruct test; // undefined
template<struct test<true{ }; // defined specialization
template<typena me T, bool b>
struct test_identity<T : test<b{
typedef T type;
};

template<class T>
increment_retur n_type<test_ide ntity<T,
allowed_p<T>::v alue>::type>::t ype
operator++(T x);

HTH,
Michiel Salters

[Steve Hicks]

Mi************* @tomtom.com wrote:

Just add a test, using the typedef T type; trick again.

template<bool bstruct test; // undefined
template<struct test<true{ }; // defined specialization
template<typena me T, bool b>
struct test_identity<T : test<b{
typedef T type;
};

template<class T>
increment_retur n_type<test_ide ntity<T,
allowed_p<T>::v alue>::type>::t ype
operator++(T x);

That's a neat trick. Unfortunately, it doesn't quite do what I need.
Here is a small example:

/* BEGIN CODE */
#include <iostream>
template <bool bstruct test;
template <struct test<true{ };
template <class T, bool b>
struct test_identity : test<b{
typedef T type;
};
template <class Tstruct is_callable {
static const bool value = false;
};

template <class Tclass Constant {
T value;
public:
Constant(T t) : value(t) { }
void operator()()
{ std::cout << "value: " << value << std::endl; }
};
template <class Tstruct is_callable<Con stant<T {
static const bool value = true;
};

// T1 and T2 must be callable
template <class T1, class T2class Sum {
T1 t1; T2 t2;
public:
Sum(T1 _t1, T2 _t2) : t1(_t1), t2(_t2) { }
void operator()() { t1(); t2(); }
};

template <class T1,class T2>
typename test_identity<S um<T1,T2>,is_ca llable<T1>::val ue &&
is_callable<T2> ::value>::type
operator+(T1 t1,T2 t2) {
return Sum<T1,T2>(t1,t 2);
}
/* END CODE */

Basically, it only makes sense to have Sum<T1,T2if T1 and T2 are both
callable. I could easily insert a Boost static assert to ensure that
they are, but my issue is this: the overloaded operator+ still allows
any type to be sent to it, and then generates a compiler error if it's
not callable. So,

Constant<inta = 5; Constant<double b = 10.3;
(a+b)();

works, but

Constant<inta = 5;
(a+10.3)();

fails to compile, despite my implicit constructor, since it tries to
make Sum<Constant<in t>,intand in doing so, tries to make
test<is_callabl e<int>::valuewh ich is undefined.

I tried one more thing:

template <class T1,class T2>
Sum<T1,T2operat or+(typename
test_identity<T 1,is_callable<T 1>::value>::typ e t1,
typename test_identity<T 2,is_callable<T 2>::value>::typ e t2) {
return Sum<T1,T2>(t1,t 2);
}

but then my main() wouldn't compile because it couldn't implicitly
figure out that test_identity<T 1,...>::type was really just T1.
Hopefully I've made my problem more clear. Thanks to those still
paying attention. Any ideas?

steve

[Alf P. Steinbach]

* Steve Hicks:

Mi************* @tomtom.com wrote:

>Just add a test, using the typedef T type; trick again.

template<boo l bstruct test; // undefined
template<struc t test<true{ }; // defined specialization
template<typen ame T, bool b>
struct test_identity<T : test<b{
typedef T type;
};

template<cla ss T>
increment_retu rn_type<test_id entity<T,
allowed_p<T>:: value>::type>:: type
operator++(T x);

That's a neat trick. Unfortunately, it doesn't quite do what I need.
Here is a small example:

/* BEGIN CODE */
#include <iostream>
template <bool bstruct test;
template <struct test<true{ };
template <class T, bool b>
struct test_identity : test<b{
typedef T type;
};
template <class Tstruct is_callable {
static const bool value = false;
};

template <class Tclass Constant {
T value;
public:
Constant(T t) : value(t) { }
void operator()()
{ std::cout << "value: " << value << std::endl; }
};
template <class Tstruct is_callable<Con stant<T {
static const bool value = true;
};

// T1 and T2 must be callable
template <class T1, class T2class Sum {
T1 t1; T2 t2;
public:
Sum(T1 _t1, T2 _t2) : t1(_t1), t2(_t2) { }
void operator()() { t1(); t2(); }
};

template <class T1,class T2>
typename test_identity<S um<T1,T2>,is_ca llable<T1>::val ue &&
is_callable<T2> ::value>::type
operator+(T1 t1,T2 t2) {
return Sum<T1,T2>(t1,t 2);
}
/* END CODE */

Basically, it only makes sense to have Sum<T1,T2if T1 and T2 are both
callable. I could easily insert a Boost static assert to ensure that
they are, but my issue is this: the overloaded operator+ still allows
any type to be sent to it, and then generates a compiler error if it's
not callable. So,

Constant<inta = 5; Constant<double b = 10.3;
(a+b)();

works, but

Constant<inta = 5;
(a+10.3)();

fails to compile, despite my implicit constructor, since it tries to
make Sum<Constant<in t>,intand in doing so, tries to make
test<is_callabl e<int>::valuewh ich is undefined.

You could try

template <class T1,class T2>
typename boost::enable_i f_c<
is_callable<T1> ::value && is_callable<T2> ::value,
Sum<T1,T2>

>::type

operator+(T1 t1,T2 t2) { return Sum<T1,T2>(t1,t 2); }

which I believe is specifically what you're asking for.

However, for your chosen problem this leads to a little (contained)
combinatorial explosion: it answers the question but does not solve the
problem in a reasonable way, and that's because you're not asking about
the problem but about a particular non-working way to solve it.

Better to simply make sure that anything that can behave as a constant
has a value:

#include <iostream>

template <class Tclass Constant {
T value;
public:
Constant(T t) : value(t) { }
double operator()() const
{ std::cout << "value: " << value << std::endl; return value; }
};

template< typename T T valueOf( T const& x )
{ return x; }
template< typename T T valueOf( Constant<Tconst & x )
{ return static_cast<T>( x() ); } // Cast due to use of 'double'.

template <class T1, class T2class Sum {
T1 t1; T2 t2;
public:
Sum(T1 _t1, T2 _t2) : t1(_t1), t2(_t2) { }
double operator()() const { return valueOf(t1) + valueOf(t2); }
};

template <class T1,class T2>
Sum<T1,T2operat or+(T1 t1,T2 t2) { return Sum<T1,T2>(t1,t 2); }

int main()
{
Constant<inta = 5; Constant<double b = 10.3;

std::cout << (a+b)() << std::endl;
std::cout << (a+10.3)() << std::endl;
}

Hth.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?