容器的 const_casting 元素类型

Question

有没有一种有效且安全的方式将std::vector<const Point*>& 转换为std::vector<Point*>&？

执行reinterpret_cast<std::vector<Point*>&>(constvec) 可能会正常工作，但可能是未定义的行为。

唯一的标准选项似乎是构造一个新的std::vector<Point*> 并手动添加每个const_casted 元素，但随后程序会不必要地为其分配内存。

编辑： 程序看起来像这样（简化）：

class A {
private:
    int some_data[10];

public:
    template<typename Callback>
    void algo(Callback callback) const {
          std::vector<const int*> values { &some_data[0], &some_data[5], &some_data[3] };
          // Class is const-correct internally, so only have const access to data here.
          // Making it mutable is not easily possible in the real code,
          // as there are constructs similar to iterator/const_iterator in the class hierarchy.
          callback(values);
    }

    template<typename Callback>
    void algo(Callback callback) {
         // Hack to avoid copying the entire algorithm implementation
         auto cb = [&](const std::vector<const int*>& vec) {
             callback(....); // <--- should be const std::vector<int*>
         }
         static_cast<const A*>(this)->algo(cb);
    }
};

另一种选择是在非常量变体中实现算法，然后在 const 变体中实现const_cast<A&>(*this).algo()。但这似乎更危险，因为 A 对象可能已创建为 const (const A a;)，然后它是 UB。

Answer 1

template<class A, class B>
struct as_const_as { using type=B; }
template<class A, class B>
struct as_const_as<const A, B> { using type=const B; }
template<class A, class B>
using as_const_as_t=typename as_const_as<A,B>::type;

private:
  template<class Self, class Callback>
  static void algo(Self* self, Callback callback) {
    // code using self instead of this
    using int_t = as_const_as_t<Self, int>; // const or not depending on self
  }
public:
  template<class Callback>
  void algo(Callback callback) {
    algo( this, callback );
  }
  template<class Callback>
  void algo(Callback callback) const {
    algo( this, callback );
  }

现在我们有两个外部方法algo，一个static 方法将自己的类型作为模板类型，可以是const，也可以不是。

Answer 2

除了std::vector 是一个标准库类之外，vector<Foo*> 和vector<Foo const*> 类型可能具有不同的特化和不同的大小。因此，虽然reinterpret_cast 通常会起作用，但它在形式上是未定义的行为。无论如何，然后需要reinterpret_cast（在某些 C 风格的上下文中，例如在 Windows API 级别编程中除外）通常是一个强烈的信号，表明你走错了路。

如果在const 和非const 版本中都有想要的方法的重要代码，一种解决方案是推迟到普通函数，例如static 成员函数。

为此，有一些支持机器很方便：

struct Mutable{};
struct Const{};

template< class Constness, class Type >
struct With_t;

template< class Type > struct With_t<Mutable, Type>{ using T = Type; };
template< class Type > struct With_t<Const, Type>{ using T = Type const; };

template< class Constness, class Type >
using With = typename With_t<Constness, Type>::T;

然后你可以写这样的类：

class Foo
{
private:
    int     something_;

    template< class Constness >
    static auto p( With<Constness, Foo>* that )
        -> With<Constness, int>*
    { return &that->something_; }   // In the real world some non-trivial code here.

public:
    auto p() -> int* { return p<Mutable>( this ); }
    auto p() const -> int const* { return p<Const>( this ); }

    Foo( int const value ): something_( value ) {}
};