1.设计一个类，不能被拷贝
-
拷贝只会发生在两个场景中：拷贝构造函数以及赋值运算符重载
-
因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
-
方式一：C++98中， 将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
class CopyBan
{
//......
private：
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//......
};
原因：
-
设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
-
只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。
- 方式二：C++11
C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。
class CopyBan
{
// ...
// 这里禁止编译器默认生成拷贝构造函数和赋值运算符重载
CopyBan(const CopyBan&)=delete;
CopyBan& operator=(const CopyBan&)=delete;
//...
};
2. 设计一个类，只能在堆上创建对象
实现方式：
-
将类的构造函数设置为私有成员函数，拷贝构造
声明成私有成员函数。防止别人调用拷贝在栈上生成对象。 -
提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
// 只能在堆上创建对象的类
class HeapOnly
{
public:
// 静态成员函数，不需要通过类对象来调用，通过类域就可以进行调用
static HeapOnly* CreateObj()
{
// 在静态成员函数中创建一个HeapOnly类对象，通过关键词new在堆上申请空间
return new HeapOnly;
}
private:
// 将构造函数设置为私有
// 这样，用户无法在类外创建HeapOnly类对象（因为无法调用构造函数进行初始化）
HeapOnly()
{}
// 防止拷贝防止别人调用拷贝在栈上生成对象
HeapOnly(const HeapOnly&) = delete;
};
int main()
{
// 在静态成员函数中完成堆对象的创建
// 对于静态成员函数，是不需要先创建对象，通过类域就可以直接进行调用
HeapOnly* php4 = HeapOnly::CreateObj();
// 已经进行了防拷贝，因此不能够进行拷贝
// HeapOnly hp5(*php4);
delete php4;
cout << sizeof(php4) << endl;
cout << sizeof(size_t) << endl;
return 0;
}
3.设计一个类，只能在栈上创建对象
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class StackOnly
{
public:
static StackOnly CreateObj()
{
// 在堆上调用构造函数，创建一个匿名对象，并返回
return StackOnly();
}
void Print() const
{
cout << "StackOnly::Print()" << endl;
}
private:
StackOnly()
{}
};
int main()
{
StackOnly::CreateObj().Print();
// 在栈上创建
StackOnly so1 = StackOnly::CreateObj();
// 无法禁止掉在静态区创建
static StackOnly so4 = StackOnly::CreateObj();
return 0;
}
4. 请设计一个类，不能被继承
- C++98方式
// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承class NonInherit
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
// 将构造函数私有化
NonInherit()
{}
}
- c++11的方式
在C++11中，final 是用来修饰类、虚函数和虚继承的关键字，用于表示某个类或虚函数是最终版本，不能被继承或覆盖。
- 修饰类：在类的定义中，使用
final关键字可以阻止其他类继承它。例如：
class Base final {
// ...
};
class Derived : public Base { // 错误，Base 类被声明为 final，不能被继承
// ...
};
- 修饰虚函数：在虚函数的声明或定义中，使用
final关键字可以阻止子类重写该虚函数。例如：
class Base {
public:
virtual void foo() final {
// ...
}
};
class Derived : public Base {
public:
// 错误，无法重写 final 函数 foo
// void foo() override {
// // ...
// }
};
- 修饰虚继承：在虚继承的声明中，使用
final关键字可以阻止子类继承该虚基类。例如：
class Base {
// ...
};
class Derived : public virtual Base final {
// ...
};
class MostDerived : public Derived {
// 错误，无法继续继承 final 虚基类 Base
};
总之，final 关键字用于在类层次结构中显式地指定某个类、虚函数或虚继承关系不可被修改或继承。
5. 请设计一个类，只能创建一个对象(单例模式）
设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
单例模式：
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式：
- 饿汉模式
就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<map>
using namespace std;
// 单例模式的类：全局只有一个唯一对象
// 饿汉模式：因为对象是全局对象，因此程序刚一开始(main函数之前)就创建对象
// 缺点：1、单例对象初始化时数据太多，导致启动慢（需要先对全局对象进行创建）
// 2、多个单例类有初始化依赖关系，饿汉模式无法控制
// 假设有两个类，A类和B类，要求先初始化A类，再初始化B类，B类依赖于A类，但是饿汉模式无法控制顺序
class InfoSingleton
{
public:
static InfoSingleton& GetInstance()
{
// 返回静态成员变量
return _sins;
}
void Insert(string name, int salary)
{
_info[name] = salary;
}
void Print()
{
for (auto kv : _info)
{
cout << kv.first << ":" << kv.second << endl;
}
cout << endl;
}
private:
// 将构造函数设置为私有成员函数
InfoSingleton()
{}
// 禁止生成默认拷贝函数和默认赋值运算重载
InfoSingleton(const InfoSingleton& info) = delete;
InfoSingleton& operator=(const InfoSingleton& info) = delete;
map<string, int> _info;
// ...
private:
// 静态成员变量（这是这个类的对象），在类里面进行声明，在类外进行初始化
static InfoSingleton _sins;
};
// 进行定义（静态成员变量或者函数，必须在类外进行定义），这是一个全局变量
// 可以通过类内静态成员来创建对象
// 类内静态成员也属于全局部变量
// 通过这种方式，则只能够创建一个对象，即_sins
InfoSingleton InfoSingleton::_sins;
int main()
{
// 这里无法创建，因为构造函数是私有成员函数
// InfoSingleton info1;
// InfoSingleton info2;
// InfoSingleton info3;
// InfoSingleton::GetInstance() 返回静态的InfoSingleton类对象
InfoSingleton::GetInstance().Insert("张三", 10000);
InfoSingleton& infosl = InfoSingleton::GetInstance();
infosl.Insert("李四", 15000);
infosl.Insert("赵六", 12000);
infosl.Insert("王五", 8000);
infosl.Print();
InfoSingleton::GetInstance().Insert("张三", 13000);
InfoSingleton::GetInstance().Print();
// 已经禁用了拷贝构造和赋值拷贝，因此是不能够进行赋值的
/*
InfoSingleton copy = InfoSingleton::GetInstance();
copy.Insert("孙七", 50000);
copy.Print();
*/
infosl.Print();
return 0;
}
- 懒汉模式
如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。
#include<iostream>
#include<mutex>
#include<map>
using namespace std;
// 锁的类模板
// RAII锁管理类
template<class Lock>
class LockGuard
{
public:
// 锁的构造函数
LockGuard(Lock& lk)
:_lk(lk)
{
_lk.lock();
}
// 锁的析构函数
~LockGuard()
{
_lk.unlock();
}
private:
Lock& _lk;
};
//懒汉模式：第一次获取单例对象的时候创建对象
// 1、对象在main函数之后才会创建，不会影响启动顺序
// 2、可以主动控制创建顺序
class InfoSingleton
{
public:
// 多个线程一起调用GetInstance，存在线程安全的风险
// 如果t1 t2 两个线程同时调用new InfoSingleton时，那么可能就会出现线程安全问题
static InfoSingleton& GetInstance()
{
// 第一次获取单例对象的时候创建对象
// 为了保证线程安全，因此此时需要进行加锁
// 静态成员函数，没有this指针，只能调用静态成员变量
// 因此，将成员变量的锁设置为静态锁，这样静态成员函数就可以直接调用，而不需要通过this指针
// 双检查加锁（减少多次加锁的消耗，）
// 对象new出来以后，避免每次都加锁的检查，提高性能
if (_psins == nullptr)
{
// t1 t2
// 我们自定义的RAII锁，和库里面的RAII锁效果是一样的，使用一个即可
// 除了当前的作用域块之后，锁的声明周期结束，会自动调用其析构函数释放资源
LockGuard<mutex> lock(_smtx);
// 库里面的RAII锁，出作用域之后，锁会被自动解锁
// 使用这种RAII锁，是为了防止new时，抛异常，锁没有被解锁，导致内存泄漏
// lock_guard<mutex> lock(_smtx);
if (_psins == nullptr) // 保证线程安全且只new一次
{
_psins = new InfoSingleton;
}
}
return *_psins;
}
// 一般单例对象不考虑释放（一般情况下，会经常使用），当进程结束后，会被释放，资源会被回收
// 单例对象不用时，必须手动处理，一些资源需要保存
static void DelInstance()
{
// 保存数据到文件
// ...
// 加锁，防止多个线程多次释放
std::lock_guard<mutex> lock(_smtx);
if (_psins)
{
delete _psins;
_psins = nullptr;
}
}
// 也可以让InfoSingleton的单例对象自己在程序结束时，自动回收申请的资源
// class GC是class InfoSingleton的内部类
// 内部类是外部类的友元，因此GC可以调用InfoSingleton的成员变量，以及成员函数
// 当定义的GC对象，出其作用域之后，则会调用析构函数，也就会执行DelInstance()
// 保存数据到文件，再释放对象_psins
class GC
{
public:
~GC()
{
if (_psins)
{
cout << "~GC()" << endl;
DelInstance();
}
}
};
void Insert(string name, int salary)
{
_info[name] = salary;
}
void Print()
{
for (auto kv : _info)
{
cout << kv.first << ":" << kv.second << endl;
}
cout << endl;
}
private:
// 构造函数（私有成员函数）
InfoSingleton()
{}
// 禁止拷贝构造函数和赋值重载函数
InfoSingleton(const InfoSingleton& info) = delete;
InfoSingleton& operator=(const InfoSingleton& info) = delete;
map<string, int> _info;
private:
// InfoSingleton类对象指针
static InfoSingleton* _psins;
// 静态的锁
static mutex _smtx;
// 自动回收资源，保存数据的类
static GC _gc;
};
// 此时全局变量初始化的是一个指针，并不会创建对象
InfoSingleton* InfoSingleton::_psins = nullptr;
// 对静态成员变量，锁进行初始化
mutex InfoSingleton::_smtx;
// GC是InfoSingleton的内部类，因此类的类型也需要指明作用域
InfoSingleton::GC InfoSingleton::_gc;
int main()
{
InfoSingleton::GetInstance().Insert("张三", 10000);
InfoSingleton& infosl = InfoSingleton::GetInstance();
infosl.Insert("李四", 15000);
infosl.Insert("赵六", 12000);
infosl.Insert("王五", 8000);
infosl.Print();
InfoSingleton::GetInstance().Insert("张三", 13000);
InfoSingleton::GetInstance().Print();
// 如果我们自己释放了InfoSingleton的单例对象的资源，那么则不会再被内部类对象的析构函数GC释放，因为我们自己释放后，_psins = nullptr
// GC的内部有判断，_psins为空，则不会再次释放
// InfoSingleton::DelInstance();
return 0;
}
6.内部类和外部类
- 案例1
在C++中，内部类指的是在另一个类内部定义的类。内部类可以访问外部类的私有成员，并且可以被外部类的成员函数使用。
以下是内部类的基本用法示例：
#include <iostream> class Outer { private: int outer_private; // 内部类的定义 class Inner { public: void display(Outer& obj) { // 内部类可以访问外部类的私有成员 std::cout << "Outer private member: " << obj.outer_private << std::endl; } }; public: // 外部类的成员函数 void access_inner() { Inner inner; // 内部类对象 inner.display(*this); // 调用内部类的成员函数 } }; int main() { Outer outer; outer.access_inner(); // 调用外部类的成员函数来访问内部类 return 0; }在上面的示例中，
Inner是Outer的内部类，Outer的成员函数access_inner()创建了Inner类的对象，并调用了其display()成员函数来访问Outer的私有成员outer_private。内部类可以在外部类的成员函数中进行实例化和访问，但不能独立于外部类之外实例化。内部类的作用范围被限制在外部类的作用域内。
- 案例2
在C++中，内部类是定义在另一个类的内部的类。内部类可以访问外部类的所有成员，包括私有成员，而外部类也可以访问内部类的成员。内部类的作用范围被限制在外部类的作用域内，这意味着外部类的成员函数可以直接实例化内部类，并访问其成员，但在外部类之外，不能直接访问内部类。
让我们通过一个示例来详细解释：
#include <iostream> class Outer { private: int outer_private; // 内部类的定义 class Inner { public: void display(Outer& obj) { // 内部类可以访问外部类的私有成员 std::cout << "Outer private member: " << obj.outer_private << std::endl; } }; public: // 外部类的成员函数 void access_inner() { Inner inner; // 内部类对象 inner.display(*this); // 调用内部类的成员函数 } }; int main() { Outer outer; outer.access_inner(); // 调用外部类的成员函数来访问内部类 // 在外部类之外，无法直接访问内部类 // Inner inner; // 错误！内部类不能在外部类之外直接实例化 return 0; }在上面的示例中，
Inner是Outer的内部类。在Outer的成员函数access_inner()中，我们可以直接实例化Inner类，并调用其display()成员函数来访问Outer的私有成员outer_private。然而，在main()函数中，我们不能直接实例化Inner类，因为Inner类的作用范围被限制在Outer类的作用域内，不能在外部类之外直接访问。
- 案例3
内部类的析构函数在其对象生命周期结束时被调用。具体来说，内部类对象的析构函数在包含它的外部类对象的析构函数被调用时被调用。这是因为内部类的生命周期通常是依赖于外部类对象的，当外部类对象被销毁时，它包含的所有内部类对象也会被销毁，从而触发内部类对象的析构函数调用。
让我们通过一个示例来说明：
#include <iostream> class Outer { private: class Inner { public: ~Inner() { std::cout << "Inner destructor called" << std::endl; } }; Inner inner; // 内部类对象 public: ~Outer() { std::cout << "Outer destructor called" << std::endl; } }; int main() { Outer outer; // 外部类对象 return 0; }在这个示例中，
Outer类包含了一个名为Inner的内部类。当Outer类的对象outer被创建时，它同时创建了一个Inner类的对象inner。当outer对象的生命周期结束时（即main()函数结束时），它的析构函数被调用，而在Outer类的析构函数中，它包含的Inner类对象的析构函数也会被调用。因此，上述示例会先打印 “Inner destructor called”，然后打印 “Outer destructor called”。
2537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
