实现对对象的克隆
移动构造（移动语义实现的）:通过移动语义实现移动构造，旧对象的资源的拥有权转移给新对象
拷贝构造 ：通过旧对象初始化新对象，可能会存在浅拷贝和深拷贝的问题
赋值运算符：把一个对象的属性赋值给另一个对象，实现对前一个对象的拷贝
自定义一个clone方法：对于基类和派生类的层次结构，定义一个虚函数 clone()，在派生类中重写该函数，以确保多态克隆。
#include <iostream>
#include <string>class Base {
public:virtual ~Base() {}virtual Base* clone() const = 0;virtual void display() const = 0;
};class Derived : public Base {
private:int value;std::string name;public:Derived(int v = 0, const std::string& n = "") : value(v), name(n) {}// 实现克隆方法Base* clone() const override {return new Derived(*this);}void display() const override {std::cout << "Value: " << value << ", Name: " << name << std::endl;}
};int main() {Derived obj1(42, "Derived Object");std::cout << "Original object: ";obj1.display();// 使用 clone 方法进行克隆Base* obj2 = obj1.clone();std::cout << "Cloned object: ";obj2->display();delete obj2;return 0;
}使用模板和完美转发：使用模板函数进行克隆，通过完美转发将参数传递给对象的构造函数，实现通用的克隆机制。
完美转发：在 C++ 中，完美转发（Perfect Forwarding）是一种将参数以其原始的类型和值类别（左值或右值）传递给另一个函数的技术。它主要使用 std::forward 函数模板和转发引用（也称为万能引用，Forwarding Reference）来实现。
#include <iostream>
#include <utility>template <typename T, typename... Args>
T* clone(Args&&... args) {return new T(std::forward<Args>(args)...);
}class SimpleClass {
private:int value;public:SimpleClass(int v = 0) : value(v) {}void display() const {std::cout << "Value: " << value << std::endl;}
};int main() {SimpleClass obj1(10);std::cout << "Original object: ";obj1.display();// 使用模板函数进行克隆SimpleClass* obj2 = clone<SimpleClass>(obj1);std::cout << "Cloned object: ";obj2->display();delete obj2;return 0;
}如何实现单例模式？
懒汉式（线程不安全）
#include <iostream>class Singleton {
private:static Singleton* instance;Singleton() {} // 构造函数私有，防止外部实例化public:static Singleton* getInstance() {if (instance == nullptr) {instance = new Singleton();}return instance;}void display() const {std::cout << "This is a singleton instance." << std::endl;}
};Singleton* Singleton::instance = nullptr;int main() {Singleton* s1 = Singleton::getInstance();Singleton* s2 = Singleton::getInstance();s1->display();s2->display();// 注意：没有释放内存，可能导致内存泄漏return 0;
}懒汉式（线程安全，使用互斥锁）
#include <iostream>
#include <mutex>class Singleton {
private:static Singleton* instance;static std::mutex mtx;Singleton() {} // 构造函数私有，防止外部实例化public:static Singleton* getInstance() {std::lock_guard<std::mutex> lock(mtx);if (instance == nullptr) {instance = new Singleton();}return instance;}void display() const {std::cout << "This is a singleton instance." << std::endl;}
};Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;int main() {Singleton* s1 = Singleton::getInstance();Singleton* s2 = Singleton::getInstance();s1->display();s2->display();// 注意：没有释放内存，可能导致内存泄漏return 0;
}饿汉式
#include <iostream>class Singleton {
private:static Singleton* instance;Singleton() {} // 构造函数私有，防止外部实例化public:static Singleton* getInstance() {return instance;}void display() const {std::cout << "This is a singleton instance." << std::endl;}
};Singleton* Singleton::instance = new Singleton();int main() {Singleton* s1 = Singleton::getInstance();Singleton* s2 = Singleton::getInstance();s1->display();s2->display();// 注意：没有释放内存，可能导致内存泄漏return 0;
}Meyers' Singleton （C++11 及以后）
#include <iostream>class Singleton {
private:Singleton() {} // 构造函数私有，防止外部实例化public:static Singleton& getInstance() {static Singleton instance;return instance;}void display() const {std::cout << "This is a singleton instance." << std::endl;}
};int main() {Singleton& s1 = Singleton::getInstance();Singleton& s2 = Singleton::getInstance();s1.display();s2.display();return 0;
}