将const指针参数传递给模板类的成员函数

Question

Consider the following class:

template<typename T> class A{
public:
    virtual void foo(const T& v){ m_v = v + 1; }    
    T& bar(){ return m_v;}
    T m_v;
    // ... other member functions/variables ...
};

How can it be modified such that the following code works (without, if possible having to to a const_cast on p ):

int main(){
    A<int*> a;
    const int* p = nullptr;
    a.foo(p);
    a.bar();

    A<int>().foo(10);
}

The problem is that the signature of the foo method, when A is templated by int* becomes, as far as I can tell, foo(int* const&) . What we would like to have would be something like foo(const int* const&) .

Until now, I considered adding a specialized implementation of the foo member function for A templated by pointer types outside the class declaration (as one would do for specializing A<int>::foo ), but the compiler is not able to resolve the function definition prototype to the declared method.

template<typename T>
void A<T*>::foo(const T* const& ){}

gcc complains that it's an invalid use of incomplete type 'class A<T*>'

I've also considered adding a partial specialization for the whole class for pointer types which defines an extra member overloading foo that takes in a const T* , but I couldn't figure out how to reuse the rest of the code in the base template (ie without duplicating the declarations and definitions for all the other functions, eg bar ). Is there a way to reference the base template class from the pointer partial specialization, either for inheritance or for having a member to which to forward calls? ( This post provides a solution by adding an extra dummy template argument. Is there a way to circumvent this?).

Finally, I've also thought about using enable_if<is_pointer<T>::value, void>::type foo(const PointedToType*); to add an extra overload to the foo method when the template parameter is a pointer, but how can one get PointedToType from T (when it is known that T is a pointer type)?

Answer 1

Seems to me that you just need a trait for what the argument type of foo should be:

template <typename T>
struct arg_type { using type = T const&; };

template <typename T>
struct arg_type<T*> { using type = T const*; };

template <typename T>
using arg_type_t = typename arg_type<T>::type;

To be used thusly:

virtual void foo(arg_type_t<T> arg ) {}

Answer 2

I'm not sure if this is what you want but you could use a combination of std::is_pointer , std::remove_pointer and std::conditional to construct the argument type you want. I don't know how you would write the function body to do useful things with that argument, however.

#include <type_traits>

template <typename T>
struct A
{
  template <
    typename U = T,
    typename ArgT = std::conditional_t<
      std::is_pointer<U>::value,
      const std::remove_pointer_t<U> *,
      U>
  >
  void
  foo(const ArgT&)
  {
    // ...
  }
};

I'm using the C++14 type meta-functions here. If you cannot use C++14, replace std::fancy_t< … > with typename std::fancy< … >::type .

The following is now valid:

int
main()
{
  {
    A<int *> a {};
    const int * p {};
    a.foo(p);
  }
  {
    A<int> a {};
    const int i {};
    a.foo(i);
  }
}

Answer 3

You could just define a with a const template argument, ie, A<const int*> a; . That would work.

template<typename T> class A{
public:
    void foo(const T &v){ m = v; }
    void bar(T &v){ v = m; }
    T m;
    // ... other member functions/variables ...
};

int main(){
    A<const int*> a;
    const int* p = nullptr;
    a.foo(p);
    a.bar(p);
}