在指向成员的指针和指向常量成员的指针之间转换

Question

我试过搜索这个，但我想到的每个词最终都会得到完全不相关的结果。

我有一个将指向成员的指针作为参数的函数（模板），但我似乎无法隐含地将指向的成员视为 const。使用 const_cast 是可行的，但如果可以的话，我想避免显式调用它。

struct MyStruct
{
  int *_array;
  int _size;
};

template<typename C, typename T>
void DoSomething(T* C::* arr, int siz)
{
  // do some read-only stuff with the member here
}

template<typename C, typename T>
void ConstDoSomething(T* C::* arr, int siz)
{
  DoSomething<C, T const>(arr, siz);
  // DoSomething<C, T const>(const_cast<T const* C::*>(arr), siz); // works
}

MyStruct ms;
ConstDoSomething<MyStruct const, int>(&MyStruct::_array, ms._size); // note:   cannot convert ‘arr’ (type ‘int* MyStruct::*’) to type ‘const int* MyStruct::*’

这是一个简化的示例，演示了我在使用更复杂的类树时遇到的问题。我试图避免强制转换，因为调用代码（例如，使用类模板的人）需要它。

---

更新：当我第一次发布这个时，我不小心使用了一个没有产生相同错误的代码示例。我花了相当多的测试来确定根本原因，即我在模板参数中添加了 const 限定符。上面的示例现在正确地演示了我正在使用的行为。

Answer 1

你使用什么编译器？我已经尝试过您的代码 Visual Studio 2012 和 2013，它的编译没有任何警告或错误。 无论哪种方式 - 当你玩 constness 时，你应该尝试 const_cast 而不是 static_cast

Answer 2

为了代替更好的解决方案（至少现在是这样），我创建了一个单独的重载来接受指向非 const 成员的指针，然后使用 const_cast 来调用原始方法。

如前所述，上面的示例是为了简单和清晰起见，但实际上我使用了几个类模板，每个模板都继承自另一个模板，依此类推。这导致了以下相当丑陋的解决方案：

// C = containing class (for pointer-to-members, std::nullptr_t if none)
// T = type of data being referenced

template<typename _C, typename _T> struct MakeMemberPointer // STL doesn't provide this??
{
public:
  typedef _T _C::* Type;
};

// Note: base-class template has specialization for C == std::nullptr_t
typedef typename std::conditional<std::is_same<C, decltype(nullptr)>::value,
  T const* C::*,
  T const*
>::type N;

typedef typename std::conditional<std::is_member_pointer<T>::value,
  typename MakeMemberPointer<
    C,
    typename std::add_pointer<
      typename std::remove_const<
        typename std::remove_reference<
          decltype(*(static_cast<C*>(nullptr)->*static_cast<N>(nullptr))) // T const&
        >::type // reference removed -> T const
      >::type // const removed -> T
    >::type // pointer added -> T*
  >::Type, // member pointer -> T* C::*
  typename std::add_pointer<typename std::remove_const<typename std::remove_pointer<N>::type>::type>::type
>::type NNoConst;

void DoSomething(N t) noexcept
{
}

void DoSomething(NNoConst t) noexcept
{
  DoSomething(const_cast<N>(t));
}

包含所有这些的类是从非 const 基类派生的仅 const 类（但由于模板参数，此处与 const 成员一起使用）。在类中声明所有这些（对我来说）比在调用代码中使用 const_cast 更可取，但我仍然不明白为什么 gcc 不允许这种转换隐式（毕竟，它只是 adding const 限定符！！）。