c++学习：构造函数
目录
普通构造函数
带参数构造函数
拷贝构造函数
基本概念及发生条件
拷贝构造函数的典型声明如下：
示例代码
浅拷贝
深拷贝
遵循规则三则
遵循规则三则的简单示例：
避免不必要的拷贝
使用引用传递对象
使用移动语义
拷贝构造函数的隐式调用
作为函数参数传递（按值传递）
从函数返回对象（按值返回）
初始化另一个对象
禁用拷贝构造函数
使用 delete 关键字
使用 private 声明
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行，每次都会构造成员变量的初始化值，内存空间等。
构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于 为某些成员变量设置初始值
普通构造函数
#include <iostream>
#include <string>
using namespace std; // 使用std命名空间
class Car {
public:string brand; // 不需要使用std::stringint year;// 无参构造函数Car() {brand = "未知";year = 0;cout << "无参构造函数被调用" << endl; // 不需要使用std::cout和std::endl}void display() {cout << "Brand: " << brand << ", Year: " << year << endl;}
};
int main() {Car myCar; // 创建Car对象myCar.display(); // 显示车辆信息return 0;
}
带参数构造函数
默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象 赋初始值，如下面的例子所示
#include <iostream>
#include <string>
using namespace std;
class Car {public:string brand;int year;// 带参数的构造函数，使用常规的赋值方式Car(string b, int y) {brand = b;year = y;}void display() {cout << "Brand: " << brand << ", Year: " << year << endl;}
};
int main() {Car myCar("Toyota", 2020); // 使用带参数的构造函数创建Car对象myCar.display(); // 显示车辆信息return 0;
}拷贝构造函数
基本概念及发生条件
- 当一个新对象被创建为另一个同类型的现有对象的副本时：
- 例如： MyClass obj1 = obj2; 或 MyClass obj1(obj2); ，其中 obj2 是现有的对象
- 将对象作为参数传递给函数时（按值传递）：
- 当对象作为参数传递给函数，并且参数不是引用时，会使用拷贝构造函数创建函数内部的对象 副本。
- 从函数返回对象时（按值返回）：
- 当函数返回对象，并且没有使用引用或指针时，拷贝构造函数用于从函数返回值创建副本。
- 初始化数组或容器中的元素时：
- 例如，在创建一个包含对象的数组时，数组中的每个对象都是通过拷贝构造函数初始化的。
拷贝构造函数的典型声明如下：
class MyClass {
public:MyClass(const MyClass& other);
};其中， other 是对同类型对象的引用，通常是常量引用。
示例代码
#include <iostream>
#include <string>
using namespace std;
class Car {
public:string brand;int year;// 常规构造函数Car(string b, int y) : brand(b), year(y) {}// 拷贝构造函数Car(const Car& other) {brand = other.brand;year = other.year;cout << "拷贝构造函数被调用" << endl;}void display() {cout << "Brand: " << brand << ", Year: " << year << endl;}
};
int main() {Car car1("Toyota", 2020); // 使用常规构造函数Car car2 = car1; // 使用拷贝构造函数car1.display();car2.display();return 0;
}浅拷贝
浅拷贝只复制对象的成员变量的值。如果成员变量是指针，则复制指针的值（即内存地址），而不是指 针所指向的实际数据。这会导致多个对象共享相同的内存地址。
#include <iostream>
using namespace std;
class Shallow {
public:int* data;Shallow(int d) {//(d)：这是初始化表达式。在这里，分配的 int 类型内存被初始化为 d 的值。如果 d 的值是
20，那么分配的内存将被初始化为 20。data = new int(d); // 动态分配内存cout << "观察数据：" << endl;cout << d << endl;cout << *data << endl;cout << "观察内存在构造函数中：" << endl;cout << data << endl;}// 默认的拷贝构造函数是浅拷贝~Shallow() {delete data; // 释放内存}
};
int main() {Shallow obj1(20);Shallow obj2 = obj1; // 浅拷贝cout << "观察内存在main函数obj2的data地址：" << endl;cout << obj2.data << endl;cout << "obj1 data: " << *obj1.data << ", obj2 data: " << *obj2.data << endl;return 0;
}
在这个例子中， obj2 是通过浅拷贝 obj1 创建的。这意味着 obj1.data 和 obj2.data 指向相同的内 存地址。
当 obj1 和 obj2 被销毁时，同一内存地址会被尝试释放两次，导致潜在的运行时错误。
深拷贝
深拷贝复制对象的成员变量的值以及指针所指向的实际数据。这意味着创建新的独立副本，避免了共享 内存地址的问题。
#include <iostream>
using namespace std;
class Deep {
public:int* data;Deep(int d) {data = new int(d); // 动态分配内存cout << "观察数据：" << endl;cout << d << endl;cout << *data << endl;cout << "观察内存在构造函数中：" << endl;cout << data << endl;}// 显式定义深拷贝的拷贝构造函数Deep(const Deep& source) {data = new int(*source.data); // 复制数据，而不是地址cout << "深拷贝构造函数\n";}~Deep() {delete data; // 释放内存}
};
int main() {Deep obj1(20);Deep obj2 = obj1; // 深拷贝cout << "观察内存在main函数obj2的data地址：" << endl;cout << obj2.data << endl;cout << "obj1 data: " << *obj1.data << ", obj2 data: " << *obj2.data << endl;return 0;
}
在这个例子中， obj2 是通过深拷贝 obj1 创建的。这意味着 obj1.data 和 obj2.data 指向不同的内 存地址。每个对象有自己的内存副本，因此不会相互影响，避免了潜在的运行时错误。
遵循规则三则
在 C++ 中，规则三则（Rule of Three）是一个面向对象编程原则，它涉及到类的拷贝控制。规则三则指 出，如果你需要显式地定义或重载类的任何一个拷贝控制操作（拷贝构造函数、拷贝赋值运算符、析构 函数），那么你几乎肯定需要显式地定义或重载所有三个。这是因为这三个功能通常都是用于管理动态 分配的资源，比如在堆上分配的内存。
遵循规则三则的简单示例：
#include <iostream>
#include <cstring>
class MyClass {
private:char* buffer;
public:// 构造函数MyClass(const char* str) {if (str) {buffer = new char[strlen(str) + 1];strcpy(buffer, str);} else {buffer = nullptr;}}// 析构函数~MyClass() {delete[] buffer;}// 拷贝构造函数MyClass(const MyClass& other) {if (other.buffer) {buffer = new char[strlen(other.buffer) + 1];strcpy(buffer, other.buffer);} else {buffer = nullptr;}}// 拷贝赋值运算符MyClass& operator=(const MyClass& other) {if (this != &other) {delete[] buffer; // 首先删除当前对象的资源if (other.buffer) {buffer = new char[strlen(other.buffer) + 1];strcpy(buffer, other.buffer);} else {buffer = nullptr;}}return *this;}
};
int main() {MyClass obj1("Hello");MyClass obj2 = obj1; // 调用拷贝构造函数MyClass obj3("World");obj3 = obj1; // 调用拷贝赋值运算符return 0;
}
在这个例子中：
- 构造函数为成员变量 buffer 分配内存，并复制给定的字符串。
- 析构函数释放 buffer 所占用的内存，以避免内存泄露。
- 拷贝构造函数创建一个新对象作为另一个现有对象的副本，并为其分配新的内存，以避免多个对象 共享同一内存。
- 拷贝赋值运算符更新对象时，首先释放原有资源，然后根据新对象的状态分配新资源
这个类遵循规则三则，确保了动态分配资源的正确管理，避免了内存泄露和浅拷贝问题。
避免不必要的拷贝
避免不必要的拷贝是 C++ 程序设计中的一个重要原则，尤其是在处理大型对象或资源密集型对象时。使 用引用（包括常量引用）和移动语义（C++11 引入）是实现这一目标的两种常见方法。
使用引用传递对象
通过使用引用（尤其是常量引用）来传递对象，可以避免在函数调用时创建对象的副本。
#include <iostream>
#include <vector>
using namespace std;
class LargeObject {// 假设这是一个占用大量内存的大型对象
};
void processLargeObject(const LargeObject& obj) {// 处理对象，但不修改它cout << "Processing object..." << endl;
}
int main() {LargeObject myLargeObject;processLargeObject(myLargeObject); // 通过引用传递，避免拷贝return 0;
}
在这个例子中， processLargeObject 函数接受一个对 LargeObject 类型的常量引用，避免了在函数 调用时复制整个 LargeObject 。
使用移动语义
C++11 引入了移动语义，允许资源（如动态分配的内存）的所有权从一个对象转移到另一个对象，这避 免了不必要的拷贝。
#include <iostream>
#include <utility> // 对于 std::move
using namespace std;
class MovableObject {
public:MovableObject() {// 构造函数}MovableObject(const MovableObject& other) {// 拷贝构造函数（可能很昂贵）}MovableObject(MovableObject&& other) noexcept {// 移动构造函数（轻量级）// 转移资源的所有权}MovableObject& operator=(MovableObject&& other) noexcept {// 移动赋值运算符// 转移资源的所有权return *this;}
};
MovableObject createObject() {MovableObject obj;return obj; // 返回时使用移动语义，而非拷贝
}
int main() {MovableObject obj = createObject(); // 使用移动构造函数return 0;
}
在这个例子中， MovableObject 类有一个移动构造函数和一个移动赋值运算符，它们允许对象的资源 （如动态分配的内存）在赋值或返回时被“移动”而非复制。这减少了对资源的不必要拷贝，提高了效率。
通过这些方法，你可以在 C++ 程序中有效地减少不必要的对象拷贝，尤其是对于大型或资源密集型的对 象。
拷贝构造函数的隐式调用
在 C++ 中，拷贝构造函数可能会在几种不明显的情况下被隐式调用。这种隐式调用通常发生在对象需要被复制时，但代码中并没有明显的赋值或构造函数调用。了解这些情况对于高效和正确地管理资源非常重要。
作为函数参数传递（按值传递）
当对象作为函数参数按值传递时，会调用拷贝构造函数来创建参数的本地副本。
#include <iostream>
using namespace std;
class MyClass {
public:MyClass() {}MyClass(const MyClass &) {cout << "拷贝构造函数被隐式调用" << endl;}
};
void function(MyClass obj) {// 对 obj 的操作
}
int main() {MyClass myObject;function(myObject); // 调用 function 时，拷贝构造函数被隐式调用return 0;
}
从函数返回对象（按值返回）
当函数返回一个对象时，拷贝构造函数会被用于创建返回值的副本。
MyClass function() {MyClass tempObject;return tempObject; // 返回时，拷贝构造函数被隐式调用
}
int main() {MyClass myObject = function(); // 接收返回值时可能还会有一次拷贝（或移动）return 0;
}
初始化另一个对象
当用一个对象初始化另一个同类型的新对象时，会使用拷贝构造函数
int main() {MyClass obj1;MyClass obj2 = obj1; // 初始化时，拷贝构造函数被隐式调用return 0;
}在所有这些情况下，如果类包含资源管理（例如，动态内存分配），那么正确地实现拷贝构造函数是非 常重要的，以确保资源的正确复制和管理，防止潜在的内存泄漏或其他问题。此外，随着 C++11 的引 入，移动语义提供了对资源的高效管理方式，可以减少这些场景中的资源复制。
禁用拷贝构造函数
禁用拷贝构造函数是一种常用的做法，尤其是在设计那些不应该被复制的类时。这可以通过将拷贝构造函数声明为 private 或使用 C++11 引入的 delete 关键字来实现。这样做的目的是防止类的对象被拷贝，从而避免可能导致的问题，如资源重复释放、无意义的资源复制等
使用 delete 关键字
可以使用 delete 关键字明确指定不允许拷贝构造
class NonCopyable {
public:NonCopyable() = default; // 使用默认构造函数// 禁用拷贝构造函数NonCopyable(const NonCopyable&) = delete;// 禁用拷贝赋值运算符NonCopyable& operator=(const NonCopyable&) = delete;
};
int main() {NonCopyable obj1;// NonCopyable obj2 = obj1; // 编译错误，拷贝构造函数被禁用return 0;
}使用 private 声明
常见的做法是将拷贝构造函数和拷贝赋值运算符声明为 private ，并且不提供实现：
class NonCopyable {
private:// 将拷贝构造函数和拷贝赋值运算符设为私有NonCopyable(const NonCopyable&);NonCopyable& operator=(const NonCopyable&);
public:NonCopyable() {}
};
int main() {NonCopyable obj1;// NonCopyable obj2 = obj1; // 编译错误，因为无法访问私有的拷贝构造函数return 0;
}
在这个例子中，任何尝试拷贝 NonCopyable 类型对象的操作都会导致编译错误，因为拷贝构造函数和拷贝赋值运算符是私有的，外部代码无法访问它们。 通过这些方法，你可以确保你的类的对象不会被意外地拷贝，从而避免可能出现的资源管理相关的错误。