CPP类与对象

CPP类与对象

1、浅拷贝与深拷贝区别？

1. 浅拷贝：只拷贝指针地址，导致两个指针指向同一块内存空间。cpp默认拷贝构造函数是浅拷贝，这在没有指针时是可行的，但当数据成员有指针时，如果仅采用浅拷贝，则两个指针指向同一堆内存。一个对象被析构后，会造成另一对象的指针悬挂。

2. 深拷贝：会在堆内存中另外申请一段空间来存储数据。

2、当定义类时，编译器会为类自动生成哪些函数？这些函数各自都有什么特点？

构造函数：

1. 函数名与类名相同，无返回值，可传参，可重载。
2. 完成数据成员初始化。
3. 默认构造函数无参。
4. 初始化表达式：初始化顺序只与数据声明顺序有关。

析构函数：

1. 函数名与类名相同，并带一取反符号，不可传参，唯一，不可重载。
2. 完成对象销毁，执行清理任务。

拷贝构造函数：

1. 默认浅拷贝
2. 调用时机：已存对象复制给一个新对象、形参和实参都是对象、函数返回值是对象
3. 参数为 const 类名& 
a、必须是引用，否则符合调用时机（形参和实参都是对象），无限调用自己。
b、必须是const，为实现左值引用和右值的绑定 

赋值构造函数：

1. 返回值必须是引用，否则调用拷贝构造函数，增大开销
2. 返回值必须是类类型，而不能是void，为实现p1 = p2 = p3 的连等
3. 参数也是const 类名&

3、什么是左值与右值，拷贝构造函数中的引用与const为什么不能去掉？

左值：可以取地址
右值：不可取地址。表现为临时对象、匿名对象、字面值常量

参数为 const 类名&
a、必须是引用，否则符合调用时机（形参和实参都是对象），无限调用自己。
b、必须是const，为实现左值引用和右值的绑定

4、this指针是什么?

1. 指向对象本身的指针，用来在共用成员函数体的情况下区分成员数据。
2. 隐藏在每个非静态成员的第一个参数处。静态函数如同静态变量一样，他不属于具体的哪一个对象，静态函数表示了整个类范围意义上的信息，而this指针却实实在在的对应一个对象，所以this指针不能被静态函数使用。
3. *const指针常量(指针是形容词，常量是名词，表示是一个常量的指针，指针本身的值不可变，但指向对象的值是可变的)
4. const修饰成员函数时，实则修饰的是this指针，使其变成指向内容为常量的指针常量。

5、必须在构造函数列表中初始化的3种情况?

1. const
2. 引用
3. 类对象成员

6、Computer类示例

#include <iostream>
#include <string.h>

using std::cout;
using std::endl;

class Computer{
public:
    Computer(const char* brand, double price)
    : _brand(new char[strlen(brand) + 1]())
    , _price(price)
    {
        cout << "Computer(const char* brand, double price)" << endl;
        strcpy(_brand, brand);
    }
    ~Computer(){
        if(_brand){
            delete[] _brand;
            _brand = nullptr;
        }
    }
#if 0
    //浅拷贝
    Computer(const Computer& rhs)
    : _brand(rhs._brand)
    , _price(rhs._price)
    {}
#endif
#if 1
    //如果去掉引用符号，形参是对象，无限调用复制构造函数
    //若去掉const，左值引用无法绑定右值，复制构造函数无法调用
    Computer(const Computer& rhs)
    : _brand(new char[strlen(rhs._brand)+1]())
    , _price(rhs._price)
    {
        strcpy(_brand, rhs._brand);
    }
#endif
    void print(){
        cout << _brand << " " << _price << endl;
    }
    void setBrand(const char* brand){
        strcpy(_brand, brand);
    }
    void setPrice(double price){
        _price = price;
    }
    //默认情况下，编译器会提供一个赋值运算符函数
    //参数同拷贝构造函数
    //const左值引用才可绑定右值
    //若不用引用，则涉及形参和实参传递，会调用拷贝构造函数，增大开销
    //返回值为何要是引用？
    //若不用引用，则函数返回时，会调用拷贝构造函数，增大开销
    //返回值为何要是类类型？
    //pc1 = pc2 = pc3 其中（pc2 = pc3）的返回值也是Computer类型，可以连环赋值
    Computer& operator=(const Computer& rhs){
        //this隐藏于每个非静态成员函数第一个参数处
        //用来区分不同实例的数据成员，本质是*const指针常量
        if(this != &rhs){
            delete[] _brand;
            _brand = new char[strlen(rhs._brand)+1]();
            strcpy(_brand, rhs._brand);
            _price = rhs._price;
        }
        return *this;
    }
private:
    char* _brand;
    double _price;
};

Computer func(){
    Computer res("tmp", 100);
    return res;
}

void test1(){
    Computer pc1("Huwei", 789);
    //若执行Computer(const Computer rhs)
    //则有const Computer rhs = pc1，形参于实参结合时
    //无限循环调用复制构造函数
    Computer pc2 = pc1;
    pc1.setBrand("hell");
    pc1.setPrice(123);
    pc2.print();
    //if delete const in copy constuctor
    //error: cannot bind non-const lvalue reference of type 
    //‘Computer&’ to an rvalue of type ‘Computer’
    //lvalue 可取地址，rvalue不可取地址
    //Computer(Computer& rhs)
    //Computer& rhs = func() func返回的是临时对象
    //右值：临时对象、匿名对象、字符串常量
    Computer pc3 = func();
    pc3.print();
    pc3 = pc1;
    pc3.print();
}


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