在C+中返回自动本地对象+；我试图理解C++的一些方面。_C++_Return_Copy Constructor

在C+中返回自动本地对象+；我试图理解C++的一些方面。

c++

在C+中返回自动本地对象+；我试图理解C++的一些方面。,c++,return,copy-constructor,C++,Return,Copy Constructor,我编写了这个简短的程序来展示从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& op

我编写了这个简短的程序来展示从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
    }
}

现在，我有以下问题：

makeNewCarCopy安全吗？是否在函数结束时复制和销毁本地对象？如果是这样，为什么不调用重载赋值操作符呢？它是否调用默认的复制构造函数

makeNewCarCopy

makeNewCarCopy

Car

makeNewCarCopy

Car

Car

std:：shared\u ptr

是
```
makeNewCarCopy
```
是安全的。在大多数情况下，它是有效的，因为编译器可以进行某些优化，例如（您没有看到调用赋值运算符或复制构造函数的原因）和/或C++11添加的优化
```
makeNewCarPointer
```
可能非常有效，但同时也非常危险。问题是您很容易忽略返回值，编译器不会产生任何警告。因此，至少应该返回智能指针，如
```
std:：unique\u ptr
```
或
```
std:：shared\u ptr
```
。但以前的方法更可取，至少不会慢。如果由于不同的原因必须在堆上创建对象，情况就不同了

std:：unique_ptr

std:：shared_ptr

unique_ptr

独特的ptr

unique\u ptr

shared\u ptr

shared_ptr

unique_ptr

shared_ptr

shared_ptr的任何功能
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