Very Computer

Consider the following class:

template <typename T, T value>
struct C {};

I need to distinguish between 'value == 0' and 'value != 0', which
should be handled at compile time, so I either need a specialized
version for 'value == 0', or require value-to-type mapping. Is there
any way to do this?

The following code doens't seem valid:

template <typename T>
struct C<T,0> {};

at least my compiler tells it isn't (Borland C++ 5.4: Partial
specializations
may not specialize dependent non-type parameters), and I assume it's
right (didn't check the standard, because that won't change my compiler).

I spend several hours last night finding a solution, and every time I came
close, the compiler (also GCC) would *on it. The one thing I can
detect with value to type mapping is when (in the example) 'value == 0',
but not when 'value != 0'.

One thing: a theoretical solution won't be good enough. That is, I actually
have use for it :). Specialization within template classes is not supported,
which I think could do the trick with something like:

template <typename T> struct Map {
    template <T> struct Value {
          typedef long Type;
     };
     template <> struct Value<0> {
          typedef short Type;
     };

Quote:};

and then implement some function for 'long' and 'short', but alas, the
compiler doesn't like it...

[real-life example:

template <class Implementor, class PropertyTraits, class CallbackPolicy,
          typename CallbackPolicy::template CallPolicy<Implementor,
                                        PropertyTraits>::GetMethodPtr
getMethod,
          typename CallbackPolicy::template CallPolicy<Implementor,
                                        PropertyTraits>::SetMethodPtr
setMethod>
class Property {};

I need to detect when getMethod and/or setMethod are 0.
]

TIA,
Geurt

      [ about comp.lang.c++.moderated. First time posters: do this! ]

| Consider the following class:
|
| template <typename T, T value>
| struct C {};
|
| I need to distinguish between 'value == 0' and 'value != 0', which
| should be handled at compile time, so I either need a specialized
| version for 'value == 0', or require value-to-type mapping. Is there
| any way to do this?
|
| The following code doens't seem valid:
|
| template <typename T>
| struct C<T,0> {};

How 'bout:

template <typename T, T value, bool not_zero>
struct Cimp   // value != 0
{
   Cimp() {}

Quote:};

template <typename T, T value>
struct Cimp<T, value, true>  // value == 0
{
   Cimp() {}

Quote:};

template <typename T, T value>
struct C
   : Cimp<T, value, value == 0>
{
   C() {}

Quote:};

-Howard

      [ about comp.lang.c++.moderated. First time posters: do this! ]

Quote:> template <typename T, T value>
> struct C {};

> I need to distinguish between 'value == 0' and 'value != 0', which
> should be handled at compile time, so I either need a specialized
> version for 'value == 0', or require value-to-type mapping. Is there
> any way to do this?

I actually found a solution last night. Here goes:

template <typename T, T value> struct Dep {

Quote:};

template <typename X, typename Y> struct Spec {
    typedef short Type;

Quote:};

template <typename X>
struct Spec<X,Dep<X,0> > {
    typedef long Type;

Quote:};

template <typename T, T value>
struct C {
    void G() { F(Spec<T,Dep<T,value> >::Type()); }

    void F(short) { cout << "value == 0" << endl; }
    void F(long) { cout << "value != 0" << endl; }

Quote:};

int main()
{
    C<int,100> c100;
    c100.G(); // calls F(short);
    C<int,0> c0;
    c0.G(); // calls F(long);

Quote:}

The one problem I ran into: for some reason it doesn't work
for member function pointers (can't set it to 0). For Borland
I could get around it by simply introducing a dumb indirection:

template <typename T> struct Ind {
    typedef T IT;

Quote:};

template <typename T, T::IT value>
struct Dep {

Quote:};

Which makes the following declaration for Spec:

    Spec<Ind<T>,Dep<Ind<T>,value> >::Type

Geurt

      [ about comp.lang.c++.moderated. First time posters: do this! ]

Quote:> How 'bout:

> template <typename T, T value, bool not_zero>
> struct Cimp   // value != 0
> {
>    Cimp() {}
> };

> template <typename T, T value>
> struct Cimp<T, value, true>  // value == 0
> {
>    Cimp() {}
> };

> template <typename T, T value>
> struct C
>    : Cimp<T, value, value == 0>
> {
>    C() {}
> };

No good, same problem as without the bool. Partial
specializations may not specialize dependent non-type
parameters, so the specialization for Cimp isn't valid.

Geurt

      [ about comp.lang.c++.moderated. First time posters: do this! ]

| > How 'bout:
| >
| > template <typename T, T value, bool not_zero>
| > struct Cimp   // value != 0
| > {
| >    Cimp() {}
| > };
| >
| > template <typename T, T value>
| > struct Cimp<T, value, true>  // value == 0
| > {
| >    Cimp() {}
| > };
| >
| > template <typename T, T value>
| > struct C
| >    : Cimp<T, value, value == 0>
| > {
| >    C() {}
| > };
| >
|
| No good, same problem as without the bool. Partial
| specializations may not specialize dependent non-type
| parameters, so the specialization for Cimp isn't valid.

I disagree.  14.5.4/8 says:

| A non-type argument is non-specialized if it is the name of a non-type
| parameter. All other non-type arguments are specialized.

Thus "value" in the Cimp partial specialization is _not_ specialized, and
thus not subject to 14.5.4/9:

| The type of a template parameter corresponding to a specialized non-type
| argument shall not be dependent on a parameter of the specialization.

But perhaps I am misinterpreting these paragraphs (wouldn't be the first
time).

-Howard

      [ about comp.lang.c++.moderated. First time posters: do this! ]

I haven't got Borland installed to try this on, but it works with GCC:

#include <iostream>

template <typename T, T value> struct C_generic {
  void hello() const { std::cout << "Generic hello\n"; }

Quote:};

template <typename T> struct C_zero {
  void hello() const { std::cout << "Specialised hello\n"; }

Quote:};

template <bool Flag, typename T, typename F> struct If;
template <typename T, typename F> struct If<true, T, F> {
  typedef T Type;

Quote:};

template <typename T, typename F> struct If<false, T, F> {
  typedef F Type;

Quote:};

template <typename T, T value> struct C:
  public If<value == 0, C_zero<T>, C_generic<T, value> >::Type {};

int main() {
  C<int, 0>().hello();
  C<int, 1>().hello();
  return 0;

Quote:}

--

========================================================================
          "Normally he was insane, but he had lucid moments
          when he was merely stupid."     -- Heinrich Heine

      [ about comp.lang.c++.moderated. First time posters: do this! ]