类 —— 封装、四类特殊成员函数、this指针、匿名对象、深浅拷贝问题

类

将同一类对象的所有属性都封装起来。
类中最基础的内容包括两部分，一个是属性、一个是行为。
● 属性：表示一些特征项的数值，比如说：身高、体重、性别、肤色。这些属性都是名词。属性一般都以名词存在。属性的数值，也被称为“成员变量”。
● 行为：表示能执行的动作，能干什么？比方说：吃饭、睡觉、唱跳rap，篮球。打游戏。打架。这些行为一般通过函数实现，也被称为“成员函数”。行为一般以动词存在。
成员 = 成员变量+成员函数。

定义

class 类名
{
访问权限:
成员属性;
访问权限:
成员方法;
};

封装

封装指的是，将类的一些属性和细节隐藏，重新提供外部访问的接口。封装可以提升代码的安全性，并且可以让程序员更关注于上层架构而非内部细节。

访问权限：public、private、protected

public：共有的，类内、类外和子类中都可以访问
private：私有的，类内可以访问，类外和子类中都不能访问（类中的默认权限是私有权限）
protected：受保护的，类内和子类中可以访问，类外不可以访问

类和结构体的区别

1、类的封装性比结构体更好，类中的默认权限是私有权限，结构体中默认权限是公有权限；
2、结构体默认是公有继承，类默认是私有继承；
3、C++中，类就是由结构体演变来的；
4、结构体一般用于实现某种数据结构，类一般用于描述一类对象的性质（属性、方法的封装）；

对象的创建

C++中存在两种类型对象：
● 栈内存对象
对象所在的 {} 执行完毕后，自动被销毁。
● 堆内存对象
必须使用 new 关键字创建，使用指针保存。如果不使用 delete 关键字将其销毁，则堆内存对象会持续存在。

堆内存对象调用成员，使用 "->"。
栈内存对象调用成员，使用 "."。

💡 练习 1

定义一个长方形类，包含 私有属性：长、宽；
公有方法：设置长和宽，
定义一个 show 函数，获取长方形的长和宽；
输出长方形的面积和周长。

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
public:
    void set(float new_width, float new_height);
    void show();
    float area();
    float perimeter();
};

void rectangle::set(float new_width, float new_height)
{
    width = new_width;
    height = new_height;
}
void rectangle::show()
{
    cout << "Width: " << width << endl;
    cout << "Height: " << height << endl;
}
float rectangle::area()
{
    return width * height;
}
float rectangle::perimeter()
{
    return (width + height) * 2;
}

int main()
{
    rectangle rec;
    float w, h;
    cout << "Input width and height:" << endl;
    cin >> w >> h;

    rec.set(w, h);
    rec.show();
    cout << "S = " << rec.area() << endl;
    cout << "C = " << rec.perimeter() << endl;

    return 0;
}

运行结果如下：

💡 练习 2

在 练习1 的基础上，设置新的函数，判断两个类对象是否完全相等（长 = 长，宽 = 宽）。

#include <iostream>

using namespace std;

class rectangle
{
private:
    float width;
    float height;
public:
    void set(float new_width, float new_height);
/*    void show();
    float area();
    float perimeter();	*/
    bool whether_same(rectangle &r1, rectangle &r2);	// 也可以定义为全局函数
                                                        // 但需要额外定义获取长、宽的方法
	// float get_wid();
	// float get_hgt();
};

void rectangle::set(float new_width, float new_height)
{
    width = new_width;
    height = new_height;
}
float rectangle::get_wid()
{
    return width;
}
float rectangle::get_hgt()
{
    return height;
}
bool rectangle::whether_same(rectangle &r1, rectangle &r2)	// 也可以定义为全局函数
{															// 但需要调用获取长、宽的方法
    return (r1.width == r2.width && r1.height == r2.height);
    // return (r1.get_wid() == r2.get_wid() && r1.get_hgt() == r2.get_hgt());
}

int main()
{
    rectangle rec1, rec2, rec;
    float w1, h1, w2, h2;
    cout << "Input width and height twice:" << endl;
    cin >> w1 >> h1;
    cin >> w2 >> h2;

    rec1.set(w1, h1);
    rec2.set(w2, h2);

    if (rec.whether_same(rec1, rec2))		// 若定义为全局函数，则不需要利用对象 rec 调用
        cout << "Rectangle1 & rectangle2 are same." << endl;
    else
        cout << "Rectangle1 & rectangle2 are different." << endl;

    return 0;
}

this 指针

每一个类中的非静态成员函数，都有一个 this 指针，指向调用者（谁调用 this 就指向谁）。
this 指针是一个特殊的指针，指向当前类对象的首地址。只能在类内使用。
成员函数（包括构造函数与析构函数）中都有 this 指针，this 指针指向的就是当前运行的成员函数所绑定的对象。

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

using namespace std;
class Test
{
private:
    string name;
public:
    Test(string n)
    {
        name = n;
    }

    void test_this()
    {
        cout << this << endl; 
    }
};

int main()
{
    Test t1("小明");
    cout << &t1 << endl; 		// 0x61fe84
    t1.test_this();				// 0x61fe84

    cout << "-----------" << endl;
    
    Test *t2 = new Test("张三");
    cout << t2 << endl; 		// 0x742698
    t2->test_this();    		// 0x742698
    delete t2;
    
    return 0;
}

原型：

类的类型 *const this； // 指针的指向不能修改

使用 this 指针的场合：

1、当形参和成员属性同名；

#include <iostream>

using namespace std;

class rectangle
{
private:
    float width;
    float height;
public:
    void set(float width, float height);
    void show();
    float area();
    float perimeter();	
    bool whether_same(rectangle &r1, rectangle &r2);	
};

void rectangle::set(float width, float height)
{
    this->width = width;
    this->height = height;
}
void rectangle::show()
{
    cout << "Width: " << width << endl;
    cout << "Height: " << height << endl;
}

2、函数，需要返回自身的引用；

支持链式调用的成员函数特点：返回值是当前类的引用。
■ 返回值是当前类的引用。
■ return *this;

1）拷贝赋值函数

2）其他链式调用

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

using namespace std;

class Test
{
private:
    int val = 0;
public:
    Test &add(int i)
    {
        val += i;   		// val = val + i;
        return *this; 		// this是一个指针，需要解引用返回对象的引用
    }

    int get_val()
    {
        return val;
    }
};

int main()
{
    Test t1;
    t1.add(1);
    t1.add(2);
    t1.add(100);

    cout << t1.get_val() << endl; 							// 103

    // 链式调用
    Test t2;
    cout << t2.add(2).add(3).add(200).get_val() << endl;	// 205

    return 0;
}

类中的特殊成员函数

类中会默认提供一些特殊的成员函数：构造函数、析构函数、拷贝构造函数、拷贝赋值函数。

构造函数（支持函数重载、默认参数）

在实例化类对象时，系统默认调用无参构造函数。若自定义了构造函数，则系统将不提供构造函数。

类名()
{
// 函数体
}
------------------------------------------
类名(参数列表)
{
// 函数体
}

显示调用 & 隐式调用

显示调用：类名 对象名(实参列表);
隐式调用：类名 对象名 = {实参列表}; | 类名 对象名 = 实参;

建议使用显示调用，可以使用 explicit 关键字屏蔽隐式调用语法：

explicit 类名(参数列表)
{
// 构造函数
}

调用时机

类的嵌套：内层类先构造，外层类后构造；
类的继承：父类先调用构造，子类后调用构造

栈区：实例化类对象时（不初始化），调用无参构造函数
堆区：使用 new 申请空间时（不初始化），调用无参构造函数

初始化列表的机制

在函数体内部给成员属性赋值，是一个赋值的过程，不是初始化的过程。

类名(参数列表):成员1的属性(形参1的值), 成员2的属性(形参2的值), …

需要使用初始化列表的情况

1、形参和成员属性同名

2、类中有引用成员时，必须使用初始化列表

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
    float &diagonal;
public:
    rectangle():diagonal(diagonal)
    {
        cout << "A constructor without parameters." << endl;
    }
    // 构造函数可以被重载
    rectangle(float width, float height, float diagonal):width(width),height(height),diagonal(diagonal)
    {
        cout << "A constructor with parameters." << endl;
    }
};

int main()
{
    rectangle rec1;
    rectangle rec2(12, 5, 13);
//    rectangle rec3 = {12, 5, 13};       // 部分版本报错

    return 0;
}

3、类中有 const 修饰的成员时，必须使用初始化列表

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
    const float diagonal;
public:
    rectangle():diagonal(diagonal)
    {
        cout << "A constructor without parameters." << endl;
    }
    // 构造函数可以被重载
    rectangle(float width, float height, float diagonal):width(width),height(height),diagonal(diagonal)
    {
        cout << "A constructor with parameters." << endl;
    }
};

int main()
{
    rectangle rec1;
    rectangle rec2(12, 5, 13);
//    rectangle rec3 = {12, 5, 13};       // 部分版本报错

    return 0;
}

4、类中含有其他类的子对象时，必须使用初始化列表

如果内部类只有有参构造，需要在外部类的有参构造、无参构造的初始化列表中宏显性调用；
如果内部类存在无参构造，外部类可以不写无参构造的初始化列表。

#include <iostream>
using namespace std;

class polygon
{
    string type;
public:
    // 注意：因为存在自定义的有参构造函数，系统不再提供无参构造函数
    polygon(string type)
    {
        this->type = type;
        cout << "Inner constructor." << endl;
    }
};

class rectangle
{
private:
    float width;
    float height;
    polygon p_type;
public:
    rectangle():p_type("a default value")				// 注意此行
    {
        cout << "A constructor without parameters." << endl;
    }
    // 构造函数可以被重载
    rectangle(float width, float height, string type):width(width),height(height), p_type(type)
    {
        cout << "A constructor with parameters." << endl;
    }
};

int main()
{
    rectangle rec1;
    rectangle rec2(12, 5, "rectangle");
//    rectangle rec3 = {12, 5, "rectangle"};       // 部分版本报错

    return 0;
}

#include <iostream>
using namespace std;

class polygon
{
    string type;
public:
    // 注意：加上自定义的无参构造函数后，外部类可以不写无参构造的初始化列表。见 L27.
    polygon()
    {
        cout << "There's nothing." << endl;
    }
    polygon(string type)
    {
        this->type = type;
        cout << "Inner constructor." << endl;
    }
};

class rectangle
{
private:
    float width;
    float height;
    polygon p_type;
public:
    rectangle()//:p_type("a default value")
    {
        cout << "A constructor without parameters." << endl;
    }
    // 构造函数可以被重载
    rectangle(float width, float height, string type):width(width),height(height), p_type(type)
    {
        cout << "A constructor with parameters." << endl;
    }
};

int main()
{
    rectangle rec1;
    rectangle rec2(12, 5, "rectangle");
//    rectangle rec3 = {12, 5, "rectangle"};       // 部分版本报错

    return 0;
}

构造函数 v.s. 析构函数

析构函数（不支持重载）

在类对象空间消亡时，系统自动调用。

~类名()
{
// 函数体
}

调用时机（先构造的后析构，后构造的先析构）

栈区：类对象消亡时，系统自动调用
堆区：使用 delete 释放空间时，系统调用析构函数

#include <iostream>
using namespace std;

class polygon
{
    string type;
public:
    polygon()
    {
        cout << "There's nothing." << endl;
    }
    ~polygon()
    {
        cout << "Destructor of polygon." << endl;
    }
};

class rectangle
{
private:
    float width;
    float height;
    polygon p_type;
public:
    rectangle()
    {
        cout << "A constructor without parameters." << endl;
    }
    ~rectangle()
    {
        cout << "Destructor of rectangle." << endl;
    }
};

int main()
{
    rectangle rec1;
    
    rectangle *p;
    p = new rectangle;
    delete p;

    return 0;
}

需要显性写出析构函数的情况（类指针成员指向堆区空间）

类中有指针成员，并且指针成员指向堆区空间。

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
    int *ptr;
public:
    rectangle():ptr(new int)		// 保证指针成员 指向 堆区空间
    {
        cout << "A constructor without parameters." << endl;
        cout << "New address: " << ptr << endl;
    }
    ~rectangle()
    {
        cout << "Delete address: " << ptr << endl;
        delete ptr;
        cout << "Destructor of rectangle." << endl;
    }
};

int main()
{
    rectangle rec1;

    return 0;
}

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
    int *ptr;
public:
    rectangle():ptr(new int)			// 保证指针成员 指向 堆区空间
    {
        cout << "A constructor without parameters." << endl;
        cout << "New address: " << ptr << endl;
    }
    rectangle(float width, float height, int ptr):width(width), height(height), ptr(new int(ptr))
    {									// 不能用 int *ptr
        cout << ptr << endl;
        cout << "A constructor with parameters." << endl;
    }
    ~rectangle()
    {
        cout << "Delete address: " << ptr << endl;
        delete ptr;
        cout << "Destructor of rectangle." << endl;
    }
};

int main()
{
    int num = 69;
    int *p = &num;
    rectangle rec1(12, 5, *p);

    return 0;
}

拷贝构造函数

利用 一个类对象 给另一个类对象初始化时，自动调用拷贝构造函数（浅拷贝）。
如果自定义了拷贝构造，则系统不再提供默认的拷贝构造。

类名 ( 被拷贝的同类对象的引用 )
{
// 函数体
}

浅拷贝构造（系统自动完成）

// 浅拷贝构造（系统自动完成）

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
    int *ptr;
public:
    void show();
    rectangle():ptr(new int)		// 保证指针成员 指向 堆区空间
    {
        cout << "A constructor without parameters." << endl;
        cout << "New address: " << ptr << endl;
    }
    rectangle(float width, float height, int ptr):width(width), height(height), ptr(new int(ptr))
    {
        cout << ptr << endl;
        cout << "A constructor with parameters." << endl;
    }
    ~rectangle()
    {
        cout << "Delete address: " << ptr << endl;
        delete ptr;
        cout << "Destructor of rectangle." << endl;
    }
};

void rectangle::show()
{
    cout << "Width: " << width << endl;
    cout << "Height: " << height << endl;
    cout << "Ptr = " << ptr << endl;
}

int main()
{
    rectangle rec1(12, 5, 13);
    cout << "Show rec1: " << endl;
    rec1.show();

    rectangle rec2 = rec1;
    cout << "Show rec2: " << endl;
    rec2.show();

    return 0;
}

尝试手动添加拷贝构造函数

// 半成品（累了请忽略）

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
    int *ptr;
public:
    void show();
    rectangle():ptr(new int)
    {
        cout << "A constructor without parameters." << endl;
        cout << "New address: " << ptr << endl;
    }
    rectangle(float width, float height, int ptr):width(width), height(height), ptr(new int(ptr))
    {
        cout << ptr << endl;
        cout << "A constructor with parameters." << endl;
    }
    ~rectangle()
    {
        cout << "Delete address: " << ptr << endl;
        delete ptr;
        cout << "Destructor of rectangle." << endl;
    }
    rectangle(rectangle &other)						// 注意此行
    {
        this->width = other.width;
        this->height = other.height;
        this->ptr = other.ptr;
        cout << "Duplicate of rectangle. " << endl;
    }
};

void rectangle::show()
{
    cout << "Width: " << width << endl;
    cout << "Height: " << height << endl;
    cout << "Ptr = " << ptr << endl;
}

int main()
{
    rectangle rec1(12, 5, 13);
    cout << "Show rec1: " << endl;
    rec1.show();

    rectangle rec2 = rec1;
    cout << "Show rec2: " << endl;
    rec2.show();

    return 0;
}

深拷贝构造

// 深拷贝构造

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
    int *ptr;
public:
    void show();
    rectangle():ptr(new int)
    {
        cout << "A constructor without parameters." << endl;
        cout << "New address: " << ptr << endl;
    }
    rectangle(float width, float height, int ptr):width(width), height(height), ptr(new int(ptr))
    {
        cout << ptr << endl;
        cout << "A constructor with parameters." << endl;
    }
    ~rectangle()
    {
        cout << "Delete address: " << ptr << endl;
        delete ptr;
        cout << "Destructor of rectangle." << endl;
    }
    rectangle(rectangle &other):width(other.width), height(other.height), ptr(new int(*(other.ptr)))
    {							// 使用同类其他对象的指针成员解引用后的值，给自己的指针成员的内容初始化
//        this->width = other.width;
//        this->height = other.height;
//        this->ptr = new int (*(other.ptr));			// 也可以，是赋值，不是初始化列表
        cout << "Duplicate of rectangle. " << endl;
    }
};

void rectangle::show()
{
    cout << "Width: " << width << endl;
    cout << "Height: " << height << endl;
    cout << "Ptr = " << ptr << endl;
}

int main()
{
    rectangle rec1(12, 5, 13);
    cout << "Show rec1: " << endl;
    rec1.show();

    rectangle rec2 = rec1;
    cout << "Show rec2: " << endl;
    rec2.show();

    return 0;
}

【思考】 深拷贝的代码是否存在隐患？

存在，new 开辟的空间无法释放，造成内存泄漏的问题。所以需要显性写出析构函数（见上面）。

调用时机（利用 一个类对象 给另一个类对象初始化）

1、使用已有的类对象，给新的类对象初始化
2、函数的参数是一个类对象时，也会调用拷贝构造函数
3、函数的返回值是一个类对象时，也会调用拷贝构造函数

#include <iostream>
using namespace std;

class rectangle
{
    private:
    float width;
    float height;
public:
    void show();
    rectangle()
    {
        cout << "A constructor without parameters." << endl;
    }
    rectangle(float width, float height):width(width), height(height)
    {
        cout << "A constructor with parameters." << endl;
    }
    rectangle(rectangle &other):width(other.width), height(other.height)
    {
        cout << "Duplicate of rectangle. " << endl;
    }
};

void rectangle::show()
{
    cout << "Width: " << width << endl;
    cout << "Height: " << height << endl;
}

rectangle fun(rectangle s1)			// 应该这样写：rectangle &fun(rectangle &s1)
{
    return s1;
}

int main()
{
    rectangle s(12, 5);
    fun(s).show();
    // rectangle s2(fun(s));        // 会报错，因为 fun(s) 的返回值是一个临时值，不能引用

    return 0;
}

深浅拷贝问题**

当类中有指针成员，会涉及到深浅拷贝问题。
默认的拷贝构造函数会导致两个对象的成员变量指向同一处。不符合面向对象的设计规范。这种现象被称为“浅拷贝”。
必须手动重写拷贝构造函数，使每次赋值都创建一个新的副本，从而每个对象单独持有自己的成员变量。这种方式就是“深拷贝”。

浅拷贝：两个（多个）对象的指针成员，指向同一片空间。
（不写拷贝构造函数或拷贝赋值函数，系统自动生成）
产生问题：同一片空间被两个不同的类对象占用，发生资源抢占。析构时会发生二次释放问题。

深拷贝：两个（多个）对象的指针成员，指向不同的空间，但保存的是同样的数据。
（手动书写拷贝构造函数或拷贝赋值函数）

● 在需求不受影响的前提下，可以直接通过屏蔽拷贝构造函数（私有化）来解决浅拷贝问题，但不建议如此。

拷贝赋值函数

使用 已有的类对象 给另外一个已有的类对象 赋值。系统默认提供一个拷贝赋值函数。
本质：赋值运算符的重载。

类名 &operator = (const 类名 &other)
{
// 函数体
}

浅拷贝赋值

// 浅拷贝赋值（默认缺省，系统自动完成）

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
    int *ptr;
public:
    void show();
    rectangle():ptr(new int)
    {
        cout << "A constructor without parameters." << endl;
        cout << "New address: " << ptr << endl;
    }
    rectangle(float width, float height, int ptr):width(width), height(height), ptr(new int(ptr))
    {
        cout << ptr << endl;
        cout << "A constructor with parameters." << endl;
    }
    ~rectangle()
    {
        cout << "Delete address: " << ptr << endl;
        delete ptr;
        cout << "Destructor of rectangle." << endl;
    }
    rectangle(rectangle &other):width(other.width), height(other.height), ptr(new int(*(other.ptr)))
    {
        cout << "Duplicate of rectangle. " << endl;
    }
};

void rectangle::show()
{
    cout << "Width: " << width << endl;
    cout << "Height: " << height << endl;
    cout << "Ptr = " << ptr << endl;
}

int main()
{
    rectangle rec1(12, 5, 13);
    cout << "Show rec1: " << endl;
    rec1.show();

    rectangle rec2;
    rec2 = rec1;
    cout << "Show rec2: " << endl;
    rec2.show();

    return 0;
}

深拷贝赋值

// 深拷贝赋值

#include <iostream>
using namespace std;

class rectangle
{
private:
    float width;
    float height;
    int *ptr;
public:
    void show();
    rectangle():ptr(new int)
    {
        cout << "A constructor without parameters." << endl;
        cout << "New address: " << ptr << endl;
    }
    rectangle(float width, float height, int ptr):width(width), height(height), ptr(new int(ptr))
    {
        cout << ptr << endl;
        cout << "A constructor with parameters." << endl;
    }
    ~rectangle()
    {
        cout << "Delete address: " << ptr << endl;
        delete ptr;
        cout << "Destructor of rectangle." << endl;
    }
    rectangle(rectangle &other):width(other.width), height(other.height), ptr(new int(*(other.ptr)))
    {
        cout << "Duplicate_constructor of rectangle. " << endl;
    }
    rectangle &operator = (const rectangle &other)
    {
        this->width = other.width;
        // this->height = other.height;
        *ptr = *(other.ptr);
        cout << "Duplicate_operator of rectangle. " << endl;
        return *this;
    }
};

void rectangle::show()
{
    cout << "Width: " << width << endl;
    cout << "Height: " << height << endl;
    cout << "Ptr = " << ptr << endl;
}

int main()
{
    rectangle rec1(12, 5, 13);
    cout << "Show rec1: " << endl;
    rec1.show();

    rectangle rec2;
    rec2 = rec1;				// 注意：拷贝构造函数是定义对象的同时初始化，拷贝赋值函数是先定义对象再赋值
    cout << "Show rec2: " << endl;
    rec2.show();

    return 0;
}

对象的创建与销毁流程

#include <iostream>
using namespace std;

class Value
{
private:
    string str;
public:
    Value(string str):str(str)
    {
        cout << str << "构造函数" << endl;
    }

    ~Value()
    {
        cout << str << "析构函数" << endl;
    }
};

class Father
{
public:
    static Value s_value;

    Value val = Value("Father 成员变量");

    Father()
    {
        cout << "Father 构造函数被创建了"  << endl;
    }

    ~Father()
    {
        cout << "Father 析构函数被调用了" << endl;
    }
};

Value Father::s_value = Value("静态FatherValue被创建了");

class Son:public Father
{
public :
    static Value s_value;

    Value val = Value("son 成员变量");

    Son()
    {
        cout << "Son 构造函数被创建了" << endl;
    }
    ~Son()
    {
        cout << "Son 析构函数被调用了" <<endl;
    }

};

Value Son::s_value = Value("静态 SonValue被创建了");

int main()
{
    cout << "主函数开始执行"<< endl;
    
    {
        Son s;
        cout << "对象执行中"<<endl;
    }									// Son s 的生命周期到此为止
    
    cout << "主函数结束了" << endl;

    return 0;
}

匿名对象

没有对象名，通过类名实例化出来的对象，生命周期短。 e.g. rectangle();

用作全局函数传参

// 方法一：

class rectangle
{	
	// ......
    rectangle(rectangle &other):width(other.width), height(other.height), ptr(new int(*(other.ptr)))
    {
        cout << "Duplicate_constructor of rectangle. " << endl;
    }
	// ......
}

void func(rectangle &&rec)						// 注意此行
{
    // ......
}

int main()
{
	func(rectangle());
    return 0;
}

// 方法二：

class rectangle
{	
	// ......
    rectangle(const rectangle &other):width(other.width), height(other.height), ptr(new int(*(other.ptr)))
    {
        cout << "Duplicate_constructor of rectangle. " << endl;
    }
	// ......
}

void func(rectangle rec)
{
    // ......
}

int main()
{
	func(rectangle());
    return 0;
}

临时使用类中的成员函数

rectangle().show();

给类对象的数组赋值

rectangle arr[2] = {rectangle(12, 5), rectangle(3, 4)};

给新的类对象赋值

rectangle recn(rectangle(6, 8));

💡 练习

定义一个 Person 类，包含私有属性：姓名、年龄、身高（通过指针实现）、性别（const成员）。
要求：写出类的构造函数，析构函数，拷贝构造函数 和 拷贝赋值函数。

#include <iostream>
using namespace std;

class person
{
private:
    string name;
    int age;
    float *height;
    const string gender;
public:
    void show();
    person();
    person(string name, int age, float height, string gender);
    ~person();
    person(person &other);
    person &operator = (const person &other);
};

void person::show()
{
    cout << "Name: " << name << endl;
    cout << "Age: " << age << endl;
    cout << "Height: " << height << endl;
    cout << "Gender: " << gender << endl;
}
person::person():height(new float)
{
    cout << "A constructor without parameters." << endl;
    cout << "Height: " << height << endl;
}
person::person(string name, int age, float height, string gender):name(name), age(age), \
								height(new float(height)), gender(gender)
{
//  cout << height << endl;
    cout << "A constructor with parameters." << endl;
}
person::~person()
{
    cout << "Delete address: " << height << endl;
    delete height;
    cout << "Destructor of person." << endl;
}
person::person(person &other):name(other.name), age(other.age), \
								height(new float(*(other.height))), gender(other.gender)
{
    cout << "Duplicate_constructor of person. " << endl;
}
person &person::operator = (const person &other)
{
    this->name = other.name;
    this->age = other.age;
    *height = *(other.height);				// *(this->height) = *(other.height);
    string *p = (string *)&this->gender;
    *p = other.gender;

    cout << "Duplicate_operator of person. " << endl;
    return *this;
}

int main()
{
    person per1("He Yanwei", 23, 180, "man");
    cout << "Show per1: " << endl;
    per1.show();

    person per2 = per1;
    cout << "Show per2: " << endl;
    per2.show();

    person per3;
    per3 = per1;
    cout << "Show per3: " << endl;
    per3.show();

    return 0;
}