这篇博客简要记录下C++对象的相关内容，以便回顾时使用。
C++类的定义
我们使用C++定义一个矩形(Rectangle)类，它的基本属性有：长(width)，宽(width), 对矩形的基本操作有：计算其周长(circumference), 计算其面积(area). 矩形类的定义如下：
class Rectangle {
public:
Rectangle(unsigned int width, unsigned int height) {
m_width = width;
m_height = height;
}; // 构造函数
~Rectangle() = default; // 析构函数
unsigned int get_circumference();
unsigned int get_area();
private:
unsigned int m_width; // 矩形的宽
unsigned int m_height; // 矩形的高
};
unsigned int Rectangle::get_circumference() {
return 2 * (m_width + m_height);
}
unsigned int Rectangle::get_area() {
return m_width * m_height;
}
一般来说，类由一系列数据以及对数据的一系列操作构成，我们希望隐藏数据，而提供对数据的操作。C++的public和private正起着这样的作用，使用public修饰的成员可以被外界访问，而使用private修饰的成员不可以被外界访问。
小提示：有的人习惯将类的成员变量名以
m_开头，这样写看起来比较直观，但这也只是一种编程风格，我们使用了这样的风格，例如m_width和m_height.
对于类中的方法，可以将方法的具体实现直接写在类的声明中，例如这里的Rectangle(unsigned int width, unsigned int height)； 也可以在类的声明外另写，不过此时需要在方法名的前面加上类的名称后跟两个冒号，例如这里的Rectangle::get_area, 表示这个方法是类Rectangle中的方法。
构造函数
如何根据类的声明创建一个对象（或者说这个类的一个实例）？这就是构造函数需要做的事情。构造函数是一个特殊的函数，在对象被创建时调用一次，通常用于初始化类中的数据成员或者做一些其它初始化的工作，它没有返回值，也没有返回值类型。它的声明由类名和参数列表构成:
ObjectName(type1 param1, type2 param2, ...);
例如这里的Rectangle(unsigned int width, unsigned int height).
可以定义多个构造函数，只要它们的参数列表不同，在调用时编译器会选择合适的构造函数。
析构函数
对象在销毁之前，会调用一次析构函数。因为有的对象可能占用了某些资源，例如占用了堆中的一部分空间（在销毁前应当释放空间）、打开了文件（在销毁前应当关闭文件）等等，或是完成其它的工作。它在对象被销毁前调用一次，它的声明通常由一个波浪号~和对象名构成，而且析构函数没有参数：
~ObjectName();
例如这里的~Rectangle(). 在C++中，如果某些特殊方法没有被定义，例如构造函数和析构函数，C++编译器会为这些特殊方法创建一个默认的版本。这里定义的矩形类很简单，在对象销毁前并不需要做额外的操作，因此可以直接使用默认的版本。为了使用C++编译器创建的默认版本，你可以什么都不写，或是像这里的写法：
~Rectangle() = default;
在后面加上 = default 从而告诉编译器我们将使用默认的版本。
创建第一个对象
好了，现在可以创建一个矩形对象。在此之前，我们更改下矩形类的实现，在调用构造函数和析构函数时，输出此函数被调用的语句：
// 其它部分保持不变
Rectangle(unsigned int width, unsigned int height) {
std::cout << "调用构造函数\n";
m_width = width;
m_height = height;
}; // 构造函数
~Rectangle() {
std::cout << "调用析构函数\n";
}; // 析构函数
现在，在main()中创建一个矩形对象：
int main() {
Rectangle rect(2, 3);
std::cout << "矩形的面积为" << rect.get_area() << std::endl;
}
你会看到这样的输出结果：
调用构造函数
矩形的面积为6
调用析构函数
看到了吧，对象被创建时会调用构造函数，对象被销毁时会调用析构函数。
拷贝构造函数
在C++中，可以根据一个已经存在的对象构造一个新的对象，例如：
Rectangle rect1(2, 3);
Rectangle rect2(rect1);
Rectangle rect3 = rect1;
可以利用rect1构造rect2, 这是通过拷贝构造函数实现的。
拷贝构造函数的声明如下：
ObjectName(const ObjectName& obj);
例如，矩形类的拷贝构造函数声明如下：
Rectangle(const Rectangle& rect);
可能你已经看出来了，从形式上来看，它和拷贝函数的形式是一样的，只不过参数是一个矩形对象罢了。通常来说，对象通过引用传递更高效（接下来我们将会看到），而且从概念上来说，一个拷贝构造函数不应当修改传入的参数（也就是用于构造新对象的原对象），所以这里的参数有&和const修饰。
我们为矩阵类的拷贝构造函数添加具体实现：
Rectangle::Rectangle(const Rectangle& rect) {
std::cout << "调用拷贝构造函数\n";
m_width = rect.m_width;
m_height = rect.m_height;
}
下面用一个例子看一下拷贝构造函数何时被调用：
int main() {
Rectangle rect1(2, 3);
std::cout << "矩形1的面积为" << rect1.get_area() << std::endl;
std::cout << "\n";
Rectangle rect2(rect1);
std::cout << "矩形2的面积为" << rect2.get_area() << std::endl;
std::cout << "\n";
}
输出为：
调用构造函数
矩形1的面积为6
调用拷贝构造函数
矩形2的面积为6
调用析构函数
调用析构函数
总之一句话，将拷贝构造函数看作构造函数的一种，只不过这种函数比较特殊，我们单独拿出来强调下而已。
小提示：如果你需要实现自己的析构函数或是拷贝构造函数，那么绝大多数情况下你需要同时实现这两个，至于其中的原因，应该很容易想到。
赋值运算符重载
下面的这种写法也很常见：
Rectangle rect1(2, 3);
Rectangle rect2(1, 1);
rect2 = rect1;
要想支持这种写法，必须实现用于运算符重载的函数，这里我们需要重载赋值运算符，也就是=, 对于矩形类，其声明如下：
Rectangle& operator=(const Rectangle& rect);
这里，返回值的类型为Rectangle&是为了支持多重赋值，也就是rect3 = rect2 = rect1这样的写法。下面给出此函数的一个实现：
Rectangle& operator=(const Rectangle& rect) {
std::cout << "调用赋值运算符重载函数\n";
m_width = rect.m_width;
m_height = rect.m_height;
return *this;
}
这里出现了一个新的关键词this. this是一个指向当前对象的指针，例如this->m_width表示使用此对象的m_width成员。因此，*this自然就是this指向的对象本身，这也是C++为我们提供的引用对象自身的方法。
好了，现在我们写一个用例测试下：
int main() {
Rectangle rect1(2, 3);
Rectangle rect2(1, 1);
rect2 = rect1;
}
这个例子的输出为：
调用构造函数
调用构造函数
调用赋值运算符重载函数
调用析构函数
调用析构函数
小提示：
Rectangle rect2 = rect1;没有调用赋值运算符重载函数，而是直接调用拷贝构造函数，相当于Rectangle rect2(rect1);. 由于这里的rect2此时刚被定义，如果有两个选择：（1）直接调用拷贝构造函数，通过rect1构造rect2；（2）首先调用构造函数构造rect2, 再调用赋值运算符重载函数通过rect1重新设置rect2. 你会怎么选？
禁止复制
如果你不希望创造的对象被复制，可以在拷贝构造函数和赋值运算符重载的声明中添加= delete, 表示你想要删除这个函数。例如：
Rectangle(const Rectangle& rect) = delete;
Rectangle& operator=(const Rectangle& rect) = delete;
从而，任何尝试调用此函数的行为，都会引发编译器报错。
慎用友元
正常情况下，外界无法访问对象的private成员，但是，如果被类认为是朋友(friend)的外部对象或是函数是可以访问private成员的。比如下面这个函数：
void print_size(const Rectangle& rect) {
std::cout << "Rectangle(" << rect.m_width << ", " << rect.m_height << ")\n";
}
它会访问矩形对象的m_width和m_height成员，C++编译器是不会允许这种情况的，因此会编译失败，但是，如果我们将函数print_size声明为友元，使用friend关键词，就可以了。在Rectangle类的定义中添加如下声明：
friend void print_size(const Rectangle& rect);
但是，这种行为会破坏数据的封装，使用时一定要谨慎！
小坑：小心潜在的类型转换
正方形也是长方形的一种，但正方形的长和宽相同，因此构造函数只需要一个参数即可，具体实现如下：
Rectangle::Rectangle(unsigned int width) {
std::cout << "调用构造函数[正方形]\n";
m_width = m_height = width;
}
现在再看以下代码：
int main() {
print_size(1);
}
这段代码的输出为：
调用构造函数[正方形]
Rectangle(1, 1)
调用析构函数
什么情况？print_size接收的不是一个Rectangle对象吗？这里传入的是1, 为什么也可以？通过输出我们可以看到，C++通过调用我们刚才定义的用于初始化正方形的构造函数，将1转化为Rectangle(1), 这里发生了隐式的类型转换。
对于具有一个参数的构造函数，都有可能出现上述的情况，可以通过在函数前添加关键词explicit禁止这种类型转换。在这里，也就是：
explicit Rectangle(unsigned int width);
现在重新编译这段代码，编译是不会通过的。
静态成员
简单地说，静态成员是与类绑定的成员，与具体的对象无关。通过关键词static定义静态成员，静态数据成员只能通过由static修饰的方法访问。
使用静态成员可以实现很好玩的事情。例如，记录目前存在多少个矩形对象，具体实现如下：
class Rectangle {
public:
Rectangle(unsigned int width, unsigned int height) {
m_id = get_id();
print_id();
std::cout << "调用构造函数[矩形]\n";
m_width = width;
m_height = height;
} // 构造函数
explicit Rectangle(unsigned int width) {
m_id = get_id();
print_id();
std::cout << "调用构造函数[正方形]\n";
m_width = m_height = width;
}
Rectangle(const Rectangle& rect) {
m_id = get_id();
print_id();
std::cout << "调用拷贝构造函数\n";
m_width = rect.m_width;
m_height = rect.m_height;
}
~Rectangle() {
print_id();
std::cout << "调用析构函数\n"; // 析构函数
num_rects -= 1;
}
Rectangle& operator=(const Rectangle& rect) {
print_id();
std::cout << "调用赋值运算符重载函数(传入矩形对象的id=" << rect.m_id << ")\n";
m_width = rect.m_width;
m_height = rect.m_height;
return *this;
}
void print_area(){
print_id();
std::cout << "面积为" << m_width * m_height << std::endl;
}
static unsigned int get_rects() { return num_rects; };
private:
static unsigned int num_rects; // 目前有多少个矩形对象
static unsigned int get_id() {
num_rects += 1;
return num_rects;
}
unsigned int m_width; // 矩形的宽
unsigned int m_height; // 矩形的高
unsigned int m_id; // 矩形对象的id
void print_id(){
std::cout << "ID(" << m_id << "): ";
}
};
unsigned int Rectangle::num_rects = 0;
这里，我们在矩形类中定义了一个static类型的变量num_rects用于记录创建了矩形对象的数量，在每个构造函数中，将num_rects加1, 且在析构函数中，将num_rects减1. 此外，使用static修饰的方法get_rects返回num_rects的大小。
注意：这里的静态变量num_rects在类的外部初始化，如果有头文件和对应的具体实现文件，那么静态变量应当在具体实现文件中初始化，这是为了防止头文件被多次包含，从而静态变量被多次初始化。不过，在C++17及以后，可以在类的内部初始化静态变量，不过要这样写：
class Rectangle {
private:
static inline unsigned int num_rects = 0;
}
具体可以在网上查查其它资料。
有了静态属性，我们可以在每个矩形对象创建时为每个矩形分配一个id, 这样在输出时可以知道具体是哪个矩形对象输出的。总的实现如下：
class Rectangle {
public:
Rectangle(unsigned int width, unsigned int height) {
m_id = get_id();
print_id();
std::cout << "调用构造函数[矩形]\n";
m_width = width;
m_height = height;
} // 构造函数
explicit Rectangle(unsigned int width) {
m_id = get_id();
print_id();
std::cout << "调用构造函数[正方形]\n";
m_width = m_height = width;
}
Rectangle(const Rectangle& rect) {
m_id = get_id();
print_id();
std::cout << "调用拷贝构造函数\n";
m_width = rect.m_width;
m_height = rect.m_height;
}
~Rectangle() {
print_id();
std::cout << "调用析构函数\n"; // 析构函数
num_rects -= 1;
}
Rectangle& operator=(const Rectangle& rect) {
print_id();
std::cout << "调用赋值运算符重载函数(传入矩形对象的id=" << rect.m_id << ")\n";
m_width = rect.m_width;
m_height = rect.m_height;
return *this;
}
static unsigned int get_rects() { return num_rects; };
private:
static unsigned int num_rects; // 目前有多少个矩形对象
static unsigned int get_id() {
num_rects += 1;
return num_rects;
}
unsigned int m_width; // 矩形的宽
unsigned int m_height; // 矩形的高
unsigned int m_id; // 矩形对象的id
void print_id() {
std::cout << "ID(" << m_id << "): ";
}
};
unsigned int Rectangle::num_rects = 0;
有了这个类，我们就可以探究许多有意思的事情了。
连续赋值
C++中的连续赋值(例如rect1 = rect2 = rect3)具体是怎么工作的？下面这个例子：
int main() {
Rectangle rect1(2, 3), rect2(1), rect3(3);
rect1 = rect2 = rect3;
}
它的输出为：
ID(1): 调用构造函数[矩形]
ID(2): 调用构造函数[正方形]
ID(3): 调用构造函数[正方形]
ID(2): 调用赋值运算符重载函数(传入矩形对象的id=3)
ID(1): 调用赋值运算符重载函数(传入矩形对象的id=2)
ID(3): 调用析构函数
ID(2): 调用析构函数
ID(1): 调用析构函数
从输出可以看出，rect1 = rect2 = rect3具体可以分为以下两步：
rect2.operator=(rect3);
rect1.operator=(rect2);
执行是从右往左进行的，而且表达式rect2 = rect3的返回值是rect2, 从而可以继续执行调用rect1 = rect2, 这也是在赋值运算符重载函数中，需要返回*this的原因。
对象传参
对象作为函数的参数，按值传参与按引用传参有何区别呢？下面我们看一个例子：
void call_rect_by_value(Rectangle rect) {
rect.print_area();
}
在如下的程序中：
int main() {
Rectangle rect(2, 3);
call_rect_by_value(rect);
}
输出为：
ID(1): 调用构造函数[矩形]
ID(2): 调用拷贝构造函数
ID(2): 面积为6
ID(2): 调用析构函数
ID(1): 调用析构函数
可以看出，按值传参时，调用了一次拷贝构造函数。而按引用传递的参数：
void call_rect_by_ref(Rectangle& rect) {
rect.print_area();
}
同样使用上面的测试程序，只不过将call_rect_by_value换成call_rect_by_ref, 输出为：
ID(1): 调用构造函数[矩形]
ID(1): 面积为6
ID(1): 调用析构函数
按引用传递时，没有创建多余的对象，因此效率更高。
事实上，引用的底层必然是通过指针实现的，不过相较于指针，用户可以采用更简洁方便的写法。因此，引用是个好语法！
返回对象的值也会调用一次拷贝构造函数，而返回对象的引用并不会，可以自己试一下，在此不再赘述。
标签：调用,封装,函数,int,C++,rect2,之谜,Rectangle,构造函数 From： https://www.cnblogs.com/overxus/p/17320273.html