相关疑难解决方法(0)

我从ReSharper收到一条关于从我的对象构造函数调用虚拟成员的警告.

为什么不做这件事？

假设我有两个C++类:

class A
{
public:
  A() { fn(); }

  virtual void fn() { _n = 1; }
  int getn() { return _n; }

protected:
  int _n;
};

class B : public A
{
public:
  B() : A() {}

  virtual void fn() { _n = 2; }
};

如果我写下面的代码:

int main()
{
  B b;
  int n = b.getn();
}

人们可能期望将n其设置为2.

事实证明,n设置为1.为什么？

假设我有一个实现Runnable接口的抽象Base类.

public abstract class Base implements Runnable {

  protected int param;

  public Base(final int param) {
      System.out.println("Base constructor");
      this.param = param;
      // I'm using this param here
      new Thread(this).start();
      System.out.println("Derivative thread created with param " + param);
  }

  @Override
  abstract public void run();
}

这是一些衍生类.

public class Derivative extends Base {

  public Derivative(final int param) {
      super(param);
  }

  @Override
  public void run() {
      System.out.println("Derivative is running with param " + param);
  }

  public static void main(String[] args) {
      Derivative thread …

我知道这个问题与此类似:C++:在构造函数中调用成员函数？但我问的是一个更普遍的问题.

从构造函数中调用成员函数是一种好习惯吗？它使得阅读代码更容易,我更喜欢封装类型的方式(即每个代码块都有一个目标).

python中的一个说明性示例:

class TestClass:
    def __init__(self):
        self.validate()

    def validate(self):
        # this validates some data stored in the class

这是一种比validate在构造函数中编写代码更好的方法吗？这种方法有缺点吗？例如,功能开销是否更昂贵？

我个人更喜欢它的可读性,但这只是我的偏好.

干杯