有没有办法禁止转换为 C++ 中非常量的子类？

Question

这是一个完整的例子。 我想通过只允许转换来禁止使用从 B 转换到 A 的对象的 A::set B 到常量 A。 怎么做？ （我不能使用虚函数）

#include <iostream>
#include <cassert>

using namespace std;

class A {
public:
  int  get() const { return i_; }
  void set(int i) { i_ = i; }
protected:
  int i_;
};

class B : public A {
public:
  int  ok() const { return A::get() == copy_i_; }
  void set(int i) { A::set(i); copy_i_ = i; }
protected:
  int copy_i_;
};

void test2() {
  A a;
  a.set(3); // ok here
  cout << a.get() << endl;

  B b;
  b.set(5);
  A& aa = b;
  assert(b.ok());
  aa.set(3); // not ok here
  assert(b.ok()); // fail-here
}

int main() {
  test2();
  return 0;
}

Answer 1

您可以将继承设为私有，并在 B 中提供一个成员函数来使用而不是强制转换。

const A& B::convert_to_A() const { return *this; }

Answer 2

为什么要选角？将 void A::set(int i) protected 设为适用于您的情况。

Answer 3

没有必要禁止非常量强制转换。您可以使用template method design pattern 解决您的问题。

#include "stdafx.h"
#include <iostream>
#include <cassert>

using namespace std;

class A {
public:
  int  get() const { return i_; }
  void set(int i) { assert(i_ = i); copy_i();}

protected:
  int i_;
  virtual void copy_i(){};
};


class B : public A {
public:
  int  ok() const { return A::get() == copy_i_; }
protected:
  int copy_i_;
  void copy_i(){copy_i_ = i_; }
};

void test2() {
  B b;
  b.set(5);
  A& a = b;
  assert(b.ok());
  a.set(3);
  assert(b.ok()); // success!
}

int main() {
  test2();
  return 0;
}