我正在尝试了解 C++ 的某些方面。

我编写了这个简短的程序来展示在 C++ 中从函数返回对象的不同方式:

#include <iostream> 

using namespace std;

// A simple class with only one private member.
class Car{
     private:
        int maxSpeed;
     public:
        Car( int );
        void print();
        Car& operator= (const Car &);
        Car(const Car &);
 };

 // Constructor
 Car::Car( int maxSpeed ){
    this -> maxSpeed = maxSpeed;
    cout << "Constructor: New Car (speed="<<maxSpeed<<") at " << this << endl;
 }

 // Assignment operator
 Car& Car::operator= (const Car &anotherCar){
    cout << "Assignment operator: copying " << &anotherCar << " into " << this << endl;
    this -> maxSpeed = anotherCar.maxSpeed;
    return *this;
 }

 // Copy constructor
 Car::Car(const Car &anotherCar ) {
    cout << "Copy constructor: copying " << &anotherCar << " into " << this << endl;
    this->maxSpeed = anotherCar.maxSpeed;
 }

 // Print the car.
 void Car::print(){
    cout << "Print: Car (speed=" << maxSpeed << ") at " << this << endl;
 }

 // return automatic object (copy object on return) (STACK)
 Car makeNewCarCopy(){
    Car c(120);
    return c; // object copied and destroyed here
 }

// return reference to object (STACK)
Car& makeNewCarRef(){
    Car c(60);
    return c; // c destroyed here, UNSAFE!
    // compiler will say: warning: reference to local variable ‘c’ returned
 }

// return pointer to object (HEAP)
Car* makeNewCarPointer(){
    Car * pt = new Car(30);
    return pt; // object in the heap, remember to delete it later on!
 }

int main(){
    Car a(1),c(2);
    Car *b = new Car(a);
    a.print();
    a = c;
    a.print();

    Car copyC = makeNewCarCopy(); // safe, but requires copy
    copyC.print();

    Car &refC = makeNewCarRef(); // UNSAFE
    refC.print();

    Car *ptC = makeNewCarPointer(); // safe
    if (ptC!=NULL){
        ptC -> print();
        delete ptC;
    } else {
        // NULL pointer
    }
}

代码似乎没有崩溃，我得到以下输出:

Constructor: New Car (speed=1) at 0x7fff51be7a38
Constructor: New Car (speed=2) at 0x7fff51be7a30
Copy constructor: copying 0x7fff51be7a38 into 0x7ff60b4000e0
Print: Car (speed=1) at 0x7fff51be7a38
Assignment operator: copying 0x7fff51be7a30 into 0x7fff51be7a38
Print: Car (speed=2) at 0x7fff51be7a38
Constructor: New Car (speed=120) at 0x7fff51be7a20
Print: Car (speed=120) at 0x7fff51be7a20
Constructor: New Car (speed=60) at 0x7fff51be79c8
Print: Car (speed=60) at 0x7fff51be79c8
Constructor: New Car (speed=30) at 0x7ff60b403a60
Print: Car (speed=30) at 0x7ff60b403a60

现在，我有以下问题:

• makeNewCarCopy 安全吗？本地对象是否在函数结束时被复制和销毁？如果是这样，为什么不调用重载的赋值运算符？它会调用默认的复制构造函数吗？
• 我的直觉告诉我使用 makeNewCarPointer 作为从 C++ 函数/方法返回对象的最常用方法。我说得对吗？

最佳答案

Is makeNewCarCopy safe? Is the local object being copied and destroyed at the end of the function? If so, why isn't it calling the overloaded assignment operator? Does it call the default copy constructor?

这里的重要问题是“makeNewCarCopy 安全吗？”这个问题的答案是“是的”。您正在制作对象的拷贝并按值返回该拷贝。您不会尝试返回对本地自动对象的引用，这是新手常犯的错误，这很好。

这个问题其他部分的答案在哲学上不那么重要，尽管一旦您知道如何安全地做到这一点，它们可能在生产代码中变得至关重要。您可能会或可能不会看到本地对象的构造和破坏。事实上，您可能不会，尤其是在启用优化的情况下进行编译时。原因是因为编译器知道您正在创建一个临时文件并返回它，然后将其复制到其他地方。临时变量在某种意义上变得毫无意义，因此编译器跳过了整个麻烦的创建-复制-销毁步骤，并简单地直接在最终预期的变量中构造新拷贝。这称为 copy elision 。允许编译器对您的程序进行任何和所有更改，只要可观察到的行为与未进行任何更改(参见:As-If Rule)相同，即使在复制构造函数具有副作用的情况下(参见:Return Value Optimization)也是如此。

My guts tell me to use makeNewCarPointer as the most usual way of returning objects from a C++ function/method. Am I right?

没有。考虑复制省略，正如我在上面描述的那样。所有当代的主要编译器都实现了这种优化，并且做得很好。因此，如果您可以(至少)像按指针复制一样高效地按值复制，那么按指针复制在性能方面有什么好处吗？

答案是否定的。如今，您通常希望按值返回，除非您迫切需要。在这些迫切的需求中，当您需要返回的对象比创建它的“范围”更长时——但其中不是性能。事实上，动态分配在时间上比自动(即“堆栈”)分配要昂贵得多。

关于c++ - 在 C++ 中返回自动本地对象，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/19430185/