C++ 在构造函数中通过引用传递对象和复制构造函数混淆

Question

我最近开始接触 C++，我的主要语言一直是 Java。

我希望能够在构造函数中传递对对象的引用，以便构造的对象可以使用传递的对象并对它进行更改。

在做一些关于这个主题的研究时，我遇到了复制构造函数，但我不太明白它们是否是这个操作所必需的，以及它们首先真正完成了什么。

TLDR:我想学习如何在 C++ 中执行与以下 Java 代码等效的操作。

Java code

class Master {
    private Slave slave;

    Master(Slave slave) {
        this.slave = slave;
    }

    public void doSomethingToSlave() {
        slave.doSomething();
    }

    public void changeSlave(Slave s) {
        this.slave = s;
    }
}

C++ Code ??? -my attempt so far-

class Master {
   public:
      Master(Slave& slave);
      void doSomethingToSlave();
      void changeSlave(Slave& s);

   private:
       Slave& slave;  // Is this correct? Do I need to specify that it's a reference?

}

Master::Master(Slave& slave) { // Copy constructor needed?
    this->slave = slave;
}

Master::doSomethingToSlave() {
    slave.doSomething();
}

Master::changeSlave(Slave& s) {
    slave = s;
}

Using Pointers ?

class Master {
  public:
      Master(Slave* slave);
      void doSomethingToSlave();
      void changeSlave(Slave* s);

  private:
      Slave* slave;  

}

Master::Master(Slave* slave) { 
    this->slave = slave;
}

Master::doSomethingToSlave() {
    slave.doSomething(); // How do I access the object at slave*? 
}

Master::changeSlave(Slave* s) {
    slave = s;
}

Answer 1

这是我希望阐明行为的示例:

#include <iostream>
using namespace std;

class MyType {
    public:
    int value;
};

int main() {
    // value == 1
    MyType obj1{1};
    // initialize a reference to refer to obj1.
    MyType &ref = obj1;

    // value == 2
    MyType obj2{2};

    // ref refers to obj1.
    cout << "A. ref.value = " << ref.value << endl;
    // this actually reassigns the memory in obj1
    // to the memory from obj2.
    ref = obj2;
    cout << "B. obj1.value = " << obj1.value << endl;

    // value == 3
    MyType obj3{3};
    // initialize a pointer to point to obj3.
    MyType *ptr = &obj3;

    // ptr refers to obj3.
    cout << "C. ptr->value = " << ptr->value << endl;
    // now we're just reassigning the pointer value.
    // this is like Java reference assignment.
    // ptr now points to obj2.
    ptr = &obj2;
    cout << "D. obj3.value = " << obj3.value << endl;
    // now we're reassigning the memory at obj2 to
    // the memory from obj1.
    // this is what the C++ reference assignment is doing.
    *ptr = obj2;
    cout << "E. obj2.value = " << obj2.value << endl;

    return 0;
}

输出如下:

A. ref.value = 1B. obj1.value = 2C. ptr->value = 3D. obj3.value = 3E. obj2.value = 2

Java 引用实际上就像一个C++ 指针，但Java 不允许您进行取消引用和赋值*ptr = value .

但是，我同意其他人的说法，即使用 Java 的编码风格来处理 C++ 并不是一个好主意。现代 C++ 程序并不真正使用原始指针。他们使用智能指针或值对象，因为 C++ 没有垃圾收集。如果您四处传递原始指针，则很难确定何时需要销毁特定对象。

在您的情况下，我认为您会使用 std::shared_ptr<Slave> .

一个值对象就像Slave slave; ，如果它在方法主体中声明，则它是堆栈分配的对象，或者如果它被声明为类或结构的成员，则它直接存储在对象的内存中。