提供正确的类似指针行为（指向常量的指针）的替代类设计？

Question

我正在编写一组C ++参数化的类，并且我对其中一些类似于指针的行为感兴趣。 特别是，我希望能够从具有非恒定模板参数的对象创建具有恒定模板参数的对象，但不能反过来。 此示例代码应阐明我的意图：

int main() {
  myClass<int> mc_int;
  myClass<const int> mc_const_int;

  myClass<const int> mc1(mc_const_int); // This should compile.
  myClass<int> mc2(mc_int);             // This should compile.
  myClass<const int> mc3(mc_int);       // This should compile.
  myClass<int> mc4(mc_const_int);       // This should NOT compile.
}

通过创建下一个类层次结构（简化了可读性），我已经能够实现此特定行为：

template <typename T>
class Base {

  // ...

protected:

  template <typename U>
  Base(const Base<U> &obj): _elem(obj._elem) {}

private:

  T _elem;

  friend class Base<const T>;
};

template <typename T>
class myClass: public Base<T> {

  // ...

public:

  template <typename U>
  myClass(const myClass<U> &obj): Base<const U>(obj) {}
};

它可以按预期工作，但是我对此设计并不完全满意，因为我只能从构造函数中检测到非常量模板参数，而无法从任何其他成员函数中检测到。

例如，如果我想使用addAll()方法创建一个容器类，我希望能够做到这一点：

int main() {
  Container<int> c_int;

  c_int.add(new int(1));
  c_int.add(new int(2));
  c_int.add(new int(3));

  Container<const int> c_const_int;

  c_const_int.addAll(c_int); // This should compile.
  c_int.addAll(c_const_int); // This should NOT compile.
}

但是我不知道如何实现以前的行为。 是否有人对实现我正在尝试的替代设计有想法？ 有谁知道一个链接，在哪里可以更深入地讨论这个问题？

提前致谢。

Answer 1

一种方法是通过部分模板专门化。 您应该像通常那样为非const类型定义类：

template <typename T>
struct MyClass {
    void f(T&);
};

然后定义一个专业化

template <typename T>
struct MyClass<T const> {
    void f(T&);
    void f(T const&);
};

不幸的是，这导致代码重复，但是它应该允许您执行所需的操作。 当然，您也可以使函数采用MyClass<T>&和MyClass<T const>& 。

Answer 2

我有点理解这个问题。 您可能可以使用模板专门化。

template <typename T>
class container
{
public:
   template<typename U>
   void addAll(const container<U>& b ){}
private:
   template<>
   void addAll(const container<int>&b); //No implementation
};

container<int> b;
....
container<const int> a;
a.addAll(b) ; //Give a link error, I can't understand why vc2010 compile and run this line though

Answer 3

一种可能性是使用成员函数模板，将其启用以实现所需的组合。

#include <utility>

template <class T, class U>
struct const_convertible;

template <class T>
struct const_convertible<T, T>: std::true_type {};

template <class T>
struct const_convertible<T, const T>: std::true_type {};

template <class T>
struct const_convertible<const T, T>: std::false_type {};

template <class T>
class X
{
public:
   X() {}
   X(const X&) {} //copy constructor
   //conversion constructor as needed
   template <class U>
   X(const X<U>&, typename std::enable_if<const_convertible<U, T>::value, void>::type* = 0)
   {}

   template <class U>
   typename std::enable_if<const_convertible<U, T>::value, void>::type f(X<U>) {}
};

int main()
{
   X<int> mut;
   X<const int> con;

   X<int> a(mut);
   //X<int> b(con);
   X<const int> c(mut);
   X<const int> d(con);

   mut.f(mut);
   //mut.f(con);
   con.f(mut);
   con.f(con);

   //X<double> doub;
   //doub.f(mut);
}