Question

I have this functor:

struct functor
{
  template<class T> void operator()(T value)           // (*)
  {
    // process the value
  }
  template<> void operator()<const wchar_t *>(const wchar_t *value) // (**)
  {
    if (value)
    {
      // process the value
    }
  }
  template<> void operator()<const char *>(const char *value) // (**)
  {
    if (value)
    {
      // process the value
    }
  }
  template<> void operator()<wchar_t *>(wchar_t *value) // (**)
  {
    if (value)
    {
      // process the value
    }
  }
  template<> void operator()<char *>(char *value) // (**)
  {
    if (value)
    {
      // process the value
    }
  }
};

你可以看到,我有4个相同的模板专业。是否有办法一一一一一一一一一一一一一一一一一一一一一一一一一一一一,即一一一how,就可将所有可能的类型分割至主要类别(*)和专门类别(**)?

感谢。

http://www.ohchr.org。

Oops, 固定了一些类型。

Answer 1

你们可以放弃一个更简单的计划——超负荷工作!

template<class T>
void foo(T value){ // general
  // ...
}

template<class T>
void foo(T* value){ // for pointers!
  if(value)
    foo(*value); // forward to general implementation
}

Also, I d recommend to make the parameter a reference - const if you don t need to modify it (or maybe both, depending on what you actually need to do):

template<class T>
void foo(T& value){ // general, may modify parameter
  // ...
}

template<class T>
void foo(T const& value){ // general, will not modify parameter
  // ...
}

如果你想对某几类(即整个一套)实施特殊规定,则海峡和标签的发送可以帮助你:

// dispatch tags
struct non_ABC_tag{};
struct ABC_tag{};

class A; class B; class C;

template<class T>
struct get_tag{
  typedef non_ABC_tag type;
};

// specialization on the members of the set
template<> struct get_tag<A>{ typedef ABC_tag type; };
template<> struct get_tag<B>{ typedef ABC_tag type; };
template<> struct get_tag<C>{ typedef ABC_tag type; };

// again, consider references for  value  - see above
template<class T>
void foo(T value, non_ABC_tag){
  // not A, B or C ...
}

template<class T>
void foo(T value, ABC_tag){
  // A, B, or C ...
}

template<class T>
void foo(T value){
  foo(value, typename get_tag<T>::type()); // dispatch
}

底线是,如果你想要把没有共同之处的类型分类,那么你就至少需要一些重复(标签、超负荷......)。

Answer 2

You mean like this?

struct functor
{
    template<class T> void operator()(T value)
    {
        // process the value
    }
    template<class T> void operator()(T* value) // overload, not specialization
    {
        if (value) {
            // process the value
        }
    }
};

rel=“nofollow”>http://ideone.com/P8GLp

If you want only those types, something else

struct functor
{
protected:
    template<class T> void special(T* value) // overload, not specialization
    {
        if (value) {
            // process the value
        }
    }    
public
    template<class T> void operator()(T value)
    {
        // process the value
    }
    void operator()(char* value) {special(value);}
    void operator()(wchar_t* value) {special(value);}
    void operator()(const char* value) {special(value);}
    void operator()(const wchar_t* value) {special(value);}
};

友情链接