1：什么是委托构造函数？
在C++中，委托构造函数（Delegating Constructor）是一种特殊的构造函数，它在构造函数的初始化列表中调用同一个类中的另一个构造函数，从而实现代码的复用。这种特性在C++11中引入。
class MyClass {
public:
// 委托构造函数
MyClass(int x, int y) : MyClass(x) {
// 委托给另一个构造函数
}
// 被委托的构造函数
MyClass(int x) {
// 初始化代码
}
};2. 委托构造函数在什么场景中使用？
-
代码复用： 当多个构造函数需要执行相同的初始化步骤时，可以使用委托构造函数来避免代码重复。
#include <iostream>
#include <string>
class Person {
public:
Person() : Person("Unknown", 0) {
std::cout << "Default constructor called\n";
}
Person(std::string name) : Person(name, 0) {
std::cout << "Name constructor called\n";
}
Person(std::string name, int age) : name(name), age(age) {
std::cout << "Full constructor called for " << name << std::endl;
}
private:
std::string name;
int age;
};
int main() {
Person p1;
Person p2("Alice");
Person p3("Bob", 30);
return 0;
}-
链式委托： 一个构造函数可以委托给另一个构造函数，而后者又可以委托给下一个，形成一个委托链。
class Matrix {
public:
Matrix() : Matrix(0, nullptr) {
std::cout << "Default constructor called\n";
}
Matrix(size_t rows, size_t cols) : Matrix(rows, cols, new double*[rows]) {
std::cout << "Size constructor called\n";
}
Matrix(size_t rows, size_t cols, double** data) : rows(rows), cols(cols), data(data) {
std::cout << "Data constructor called\n";
}
private:
size_t rows;
size_t cols;
double** data;
};
int main() {
Matrix mat;
return 0;
}-
继承和覆盖： 在继承的类中，可以利用委托构造函数调用基类的构造函数，以确保正确的初始化。
class Base {
public:
Base(int x) {
std::cout << "Base constructor with int called\n";
}
};
class Derived : public Base {
public:
// 委托给基类的构造函数
Derived(double x) : Base(static_cast<int>(x)) {
std::cout << "Derived constructor with double called\n";
}
};
int main() {
Derived d(3.14);
return 0;
}3. 注意事项：
-
委托目标的选择： 确保委托的目标构造函数是有效的，并且能够正确初始化对象。
#include <iostream>
#include <string>
#include <vector>
class Data {
public:
// 正确的委托目标选择
Data(const std::string& str) : Data(str.begin(), str.end()) {}
// 正确的初始化列表
Data(const char* begin, const char* end) {
// 做一些初始化工作
for (; begin != end; ++begin) {
values.push_back(*begin);
}
std::cout << "Data initialized with " << values.size() << " elements." << std::endl;
}
private:
std::vector<char> values;
};
int main() {
Data d("Hello");
return 0;
}-
构造函数的递归调用： 避免构造函数之间的无限递归调用。
class RecursiveConstructor {
public:
// 错误：递归调用自身
RecursiveConstructor() : RecursiveConstructor(42) {}
RecursiveConstructor(int) {
std::cout << "Constructor called" << std::endl;
}
};
int main() {
// RecursiveConstructor rc; // 这将导致无限递归调用
return 0;
}-
资源管理： 在委托构造函数中，确保资源被正确管理和释放。
#include <iostream>
class Resource {
public:
// 委托构造函数正确地管理资源
Resource(int id) : Resource(id, new int(id * 10)) {
std::cout << "Resource ID: " << *data << std::endl;
}
// 被委托的构造函数
Resource(int id, int* data) : id(id), data(data) {}
~Resource() {
delete data;
}
private:
int id;
int* data;
};
int main() {
Resource res(1);
return 0;
}
//在这个例子中，委托构造函数确保了资源（动态分配的整数）被正确地分配和初始化。-
异常安全： 委托构造函数需要考虑异常安全性，确保在抛出异常时对象处于一致的状态。
#include <iostream>
#include <string>
class ExceptionSafe {
public:
// 委托构造函数
ExceptionSafe(const std::string& str) : ExceptionSafe(str.begin(), str.end()) {
// 做一些可能会抛出异常的操作
if (str.empty()) {
throw std::invalid_argument("String is empty");
}
}
// 被委托的构造函数
ExceptionSafe(const char* begin, const char* end) {
// 做一些初始化工作
try {
for (; begin != end; ++begin) {
values.push_back(*begin);
}
} catch (...) {
// 异常发生时进行清理工作
std::cout << "Exception caught during initialization." << std::endl;
throw;
}
std::cout << "Data initialized with " << values.size() << " elements." << std::endl;
}
private:
std::vector<char> values;
};
int main() {
try {
ExceptionSafe es("Hello");
ExceptionSafe esEmpty("");
} catch (const std::exception& e) {
std::cout << "Caught exception: " << e.what() << std::endl;
}
return 0;
}
