【more effective c++读书笔记】【第5章】技术(2)——限制某个class所能产生的对象数量

2023-10-18 05:32
文章标签 c++ 技术 数量 对象 读书笔记 产生 限制 class effective 所能

本文主要是介绍【more effective c++读书笔记】【第5章】技术(2)——限制某个class所能产生的对象数量，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、允许零个对象

每当产生一个对象时会有一个构造函数被调用，因此阻止某个类产出对象的最简单方法就是将该类的构造函数声明为private。

例子：

class CantBeInstantiated{
private:CantBeInstantiated();CantBeInstantiated(const CantBeInstantiated&);....
};

二、允许一个对象

1、对于声明为private的构造函数，可以引入友元函数来进行访问，并利用静态成员变量保证对象的唯一性。

例子：

//Printer.h
#ifndef PRINTER_H
#define PRINTER_H
#include<iostream>class Printer{
public:friend Printer& thePrinter();void print();
private:Printer();Printer(const Printer& rhs);
};
Printer::Printer(){std::cout << "Printer()" << std::endl;
}
Printer::Printer(const Printer& rhs){std::cout << "Printer(const Printer& rhs)" << std::endl;
}
void Printer::print(){std::cout << "print..." << std::endl;
}
Printer& thePrinter(){static Printer p;return p;
}#endif//main.cpp
#include "Printer.h"
using namespace std;int main(){thePrinter().print();thePrinter().print();system("pause");return 0;
}

运行结果：


从运行结果中可以看出构造函数只被调用了一次，所以只产生了一个对象。

上述程序的设计有3个成分：

第一，Printer class的constructor属性private,可以压制对象的产生；

第二，全局函数thePrinter被声明为class的一个friend，致使thePrinter不受private constructors的约束；

第三，thePrinter内含一个static Printer对象，意思是只有一个Printer对象会被产生出来。

2、对于声明为private的构造函数，可以引入静态成员函数来进行访问，并利用静态成员变量保证对象的唯一性。

例子：

//Printer.h
#ifndef PRINTER_H
#define PRINTER_H
#include<iostream>class Printer{
public:static Printer& thePrinter();void print();
private:Printer();Printer(const Printer& rhs);
};
Printer::Printer(){std::cout << "Printer()" << std::endl;
}
Printer::Printer(const Printer& rhs){std::cout << "Printer(const Printer& rhs)" << std::endl;
}
void Printer::print(){std::cout << "print..." << std::endl;
}
Printer& Printer::thePrinter(){static Printer p;return p;
}#endif
//main.cpp
#include "Printer.h"
using namespace std;int main(){Printer::thePrinter().print();Printer::thePrinter().print();system("pause");return 0;
}

运行结果：


上述两种实现思想是一致的，都是通过thePrint函数来完成客户端访问打印机的需求。thePrinter函数的实现有两点值得探讨：

第一，形成唯一一个Printer对象的是函数中的静态对象而不是类中的静态成员。类中的静态对象有两个缺点，一个总是被构造（及析构），即使不使用该对象；另一个缺点是它的初始化时间不确定。而函数拥有一个静态对象的意思是此对象在函数第一次调用时才产生，如果该函数从未被调用，这个对象就绝不会产生。函数内的静态对象的初始化时机是在该函数第一次被调用时，并且在该静态对象被定义处。

第二、thePrinter函数没有声明为内联函数，因为内联意味编译器用函数本体代替对函数的每一个调用，这对于非成员函数来说有内部连接。而函数如果有内部连接，可能在程序中被复制，可能会使程序有多份该函数的静态对象的副本。

三、允许多个对象

1、引入计数器简单地计算目前存在的对象个数，并当外界申请太多对象时，在构造函数内抛出一个异常。

例子：

//Printer.h
#ifndef PRINTER_H
#define PRINTER_H
#include<iostream>class Printer{
public:class TooManyObjects{};//当外界申请太多对象时，抛出这种异常类  Printer();~Printer();void print();
private:static size_t numObjects;Printer(const Printer& rhs);//这里限制个数为1，所以不允许复制
};
size_t Printer::numObjects = 0;
Printer::Printer(){try{if (numObjects >= 1)//这里限制个数为1，可根据需要改throw TooManyObjects();}catch (TooManyObjects& e){std::cout << "对象个数超过限制" << std::endl;exit(1);}std::cout << "Printer()" << std::endl;++numObjects;
}
Printer::~Printer(){std::cout << "~Printer()" << std::endl;--numObjects;
}
Printer::Printer(const Printer& rhs){std::cout << "Printer(const Printer& rhs)" << std::endl;
}
void Printer::print(){std::cout << "print..." << std::endl;
}#endif
//main.cpp
#include "Printer.h"
using namespace std;int main(){Printer printer1;printer1.print();//Printer printer2;//导致程序中断//printer2.print();system("pause");return 0;
}

上述方法也会出现问题，因为Printer对象能存在于三种不同状态下：1）它自己，2）派生类的基类，3）内嵌于较大的对象之中。

例子：

class ColorPrinter :public Printer{...
};
Printer p;
ColorPrinter cp;

上述例子定义了两个Printer对象，一个是p，一个是cp的Printer成分。一旦执行，在cp的基类成分构造时，会有一个TooManyObjects exception被抛出，这可能不是程序员想要的。

四、出现的问题及改进方案

利用thePrinter函数将Printer对象的数量限制为1，却也限制我们在每次执行程序时只能有唯一一个Printer对象。因此我们不可能写出这样的代码：

建立Printer对象p1;

使用p1;

释放p1;

建立Printer对象p2;

使用p2;

释放p2;

....

我们可以将对象计数和伪构造函数结合起来解决上述问题。

例子：

//Printer.h
#ifndef PRINTER_H
#define PRINTER_H
#include<iostream>class Printer{
public:class TooManyObjects{};//当外界申请太多对象时，抛出这种异常类  static Printer* makePrinter();~Printer();void print();
private:static size_t numObjects;Printer();Printer(const Printer& rhs);//不要定义此函数，因为不希望允许复制行为
};
size_t Printer::numObjects = 0;
Printer::Printer(){try{if (numObjects >= 1)//这里限制个数为1，可根据需要改throw TooManyObjects();}catch (TooManyObjects& e){std::cout << "对象个数超过限制" << std::endl;exit(1);}std::cout << "Printer()" << std::endl;++numObjects;
}
Printer* Printer::makePrinter(){return new Printer;
}
Printer::~Printer(){std::cout << "~Printer()" << std::endl;--numObjects;
}void Printer::print(){std::cout << "print..." << std::endl;
}#endif
//main.cpp
#include "Printer.h"
using namespace std;int main(){//Printer p1;//错误，默认构造函数是privatePrinter* p2 = Printer::makePrinter();p2->print();//Printer* p3 = p2;//错误，拷贝构造函数是private且没定义delete p2;Printer* p4 = Printer::makePrinter();p4->print();delete p4;system("pause");return 0;
}

可将上述例子泛化为任意个数的对象，只需将原来的1改成其他数值，然后将复制对象的限制去掉。

例子：

//Printer.h
#ifndef PRINTER_H
#define PRINTER_H
#include<iostream>class Printer{
public:class TooManyObjects{};//当外界申请太多对象时，抛出这种异常类  static Printer* makePrinter();static Printer* makePrinter(const Printer& rhs);~Printer();void print();
private:static size_t numObjects;static const size_t maxObjects = 10;Printer();Printer(const Printer& rhs);
};
size_t Printer::numObjects = 0;
const size_t Printer::maxObjects;
Printer::Printer(){try{if (numObjects >= maxObjects)throw TooManyObjects();}catch (TooManyObjects& e){std::cout << "对象个数超过限制" << std::endl;exit(1);}std::cout << "Printer()" << std::endl;++numObjects;
}
Printer::Printer(const Printer& rhs){try{if (numObjects >= maxObjects)throw TooManyObjects();}catch (TooManyObjects& e){std::cout << "对象个数超过限制" << std::endl;exit(1);}std::cout << "Printer(const Printer& rhs)" << std::endl;++numObjects;
}
Printer* Printer::makePrinter(){return new Printer;
}
Printer* Printer::makePrinter(const Printer& rhs){return new Printer(rhs);
}
Printer::~Printer(){std::cout << "~Printer()" << std::endl;--numObjects;
}void Printer::print(){std::cout << "print..." << std::endl;
}#endif
//main.cpp
#include "Printer.h"
using namespace std;int main(){Printer* p1 = Printer::makePrinter();p1->print();Printer* p2 = Printer::makePrinter(*p1);p2->print();delete p2;delete p1;system("pause");return 0;
}

上述方案基本上完善了，但是如果我们有大量像Printer需要限制对象数量的类，就必须为每一个类编写一样的代码，，应该避免这种重复性的工作，所以需要一个一个用来计算对象个数的基类。

五、一个用来计算对象个数的基类

//Counted.h
#ifndef COUNTED_H
#define COUNTED_Htemplate<typename T>
class Counted{
public:class TooManyObjects{};static int objectCount(){ return numOfObjects; }
protected:Counted();Counted(const Counted& rhs);~Counted(){ --numOfObjects; }
private:static int numOfObjects;static const size_t maxObjects;void init();
};
template<typename T>
Counted<T>::Counted(){init();
}
template<typename T>
Counted<T>::Counted(const Counted& rhs){init();
}
template<typename T>
void Counted<T>::init(){if (numOfObjects >= maxObjects)throw TooManyObjects();++numOfObjects;
}
template<typename T>
int Counted<T>::numOfObjects = 0;#endif
//Printer.h
#ifndef PRINTER_H
#define PRINTER_H#include "Counted.h"
#include<iostream>class Printer:private Counted<Printer>{
public:static Printer* makePrinter();static Printer* makePrinter(const Printer& rhs);~Printer();using Counted<Printer>::objectCount;using Counted<Printer>::TooManyObjects;
private:Printer();Printer(const Printer& rhs);
};
Printer::Printer(){std::cout << "Printer()" << std::endl;
}
Printer::Printer(const Printer& rhs){std::cout << "Printer(const Printer& rhs)" << std::endl;
}
Printer* Printer::makePrinter(){return new Printer;
}
Printer* Printer::makePrinter(const Printer& rhs){return new Printer(rhs);
}
Printer::~Printer(){std::cout << "~Printer()" << std::endl;
}const size_t Counted<Printer>::maxObjects = 10;#endif
//main.cpp
#include "Printer.h"
using namespace std;int main(){Printer* p1 = Printer::makePrinter();Printer* p2 = Printer::makePrinter();Printer* p3 = Printer::makePrinter(*p2);cout << Printer::objectCount() << endl;delete p3;delete p2;delete p1;system("pause");return 0;
}



                                    

                                        这篇关于【more effective c++读书笔记】【第5章】技术(2)——限制某个class所能产生的对象数量的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
                                    

                                    

                                

                            

                            

                        

                    

                    

                        

                            

                            http://www.chinasem.cn/article/230503。
                            
                        

                    

                    
                    

                        
                            
                        
                    

                

                

                    相关文章
                

                    

                        

                            

                                

                                    
                                        C++11范围for初始化列表auto decltype详解
                                    
                                

                            

                            

                                

                                    C++11范围for初始化列表auto decltype详解
                                

                                

                                    《C++11范围for初始化列表autodecltype详解》C++11引入auto类型推导、decltype类型推断、统一列表初始化、范围for循环及智能指针,提升代码简洁性、类型安全与资源管理效...																									目录C++11新特性1. 自动类型推导auto1.1 基本语法2. decltype3. 列表初始化3
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        C++11右值引用与Lambda表达式的使用
                                    
                                

                            

                            

                                

                                    C++11右值引用与Lambda表达式的使用
                                

                                

                                    《C++11右值引用与Lambda表达式的使用》C++11引入右值引用,实现移动语义提升性能,支持资源转移与完美转发；同时引入Lambda表达式,简化匿名函数定义,通过捕获列表和参数列表灵活处理变量...																									目录C++11新特性右值引用和移动语义左值 / 右值常见的左值和右值移动语义移动构造函数移动复制运算符
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        springboot自定义注解RateLimiter限流注解技术文档详解
                                    
                                

                            

                            

                                

                                    springboot自定义注解RateLimiter限流注解技术文档详解
                                

                                

                                    《springboot自定义注解RateLimiter限流注解技术文档详解》文章介绍了限流技术的概念、作用及实现方式,通过SpringAOP拦截方法、缓存存储计数器,结合注解、枚举、异常类等核心组件,...																									目录什么是限流系统架构核心组件详解1. 限流注解 (@RateLimiter)2. 限流类型枚举 (
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        go动态限制并发数量的实现示例
                                    
                                

                            

                            

                                

                                    go动态限制并发数量的实现示例
                                

                                

                                    《go动态限制并发数量的实现示例》本文主要介绍了Go并发控制方法,通过带缓冲通道和第三方库实现并发数量限制,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面...																									目录带有缓冲大小的通道使用第三方库其他控制并发的方法因为go从语言层面支持并发，所以面试百分百会问到
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        Python实现PDF按页分割的技术指南
                                    
                                

                            

                            

                                

                                    Python实现PDF按页分割的技术指南
                                

                                

                                    《Python实现PDF按页分割的技术指南》PDF文件处理是日常工作中的常见需求,特别是当我们需要将大型PDF文档拆分为多个部分时,下面我们就来看看如何使用Python创建一个灵活的PDF分割工具吧...																									目录需求分析技术方案工具选择安装依赖完整代码实现使用说明基本用法示例命令输出示例技术亮点实际应用场景扩
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        C++中detach的作用、使用场景及注意事项
                                    
                                

                            

                            

                                

                                    C++中detach的作用、使用场景及注意事项
                                

                                

                                    《C++中detach的作用、使用场景及注意事项》关于C++中的detach,它主要涉及多线程编程中的线程管理,理解detach的作用、使用场景以及注意事项,对于写出高效、安全的多线程程序至关重要,下...																									目录一、什么是join()？它的作用是什么？类比一下：二、join()的作用总结三、join()怎么
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        C++中全局变量和局部变量的区别
                                    
                                

                            

                            

                                

                                    C++中全局变量和局部变量的区别
                                

                                

                                    《C++中全局变量和局部变量的区别》本文主要介绍了C++中全局变量和局部变量的区别,全局变量和局部变量在作用域和生命周期上有显著的区别,下面就来介绍一下,感兴趣的可以了解一下...																									目录一、全局变量定义生命周期存储位置代码示例输出二、局部变量定义生命周期存储位置代码示例输出三、全局变量和局部变量的区别作用域
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        C++中assign函数的使用
                                    
                                

                            

                            

                                

                                    C++中assign函数的使用
                                

                                

                                    《C++中assign函数的使用》在C++标准模板库中,std::list等容器都提供了assign成员函数,它比操作符更灵活,支持多种初始化方式,下面就来介绍一下assign的用法,具有一定的参考价...																									目录​1.assign的基本功能​​语法​2. 具体用法示例​​​(1) 填充n个相同值​​(2)
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        c++ 类成员变量默认初始值的实现
                                    
                                

                            

                            

                                

                                    c++ 类成员变量默认初始值的实现
                                

                                

                                    《c++类成员变量默认初始值的实现》本文主要介绍了c++类成员变量默认初始值,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧...																									目录C++类成员变量初始化c++类的变量的初始化在C++中，如果使用类成员变量时未给定其初始值，那么它将被
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        C++中NULL与nullptr的区别小结
                                    
                                

                            

                            

                                

                                    C++中NULL与nullptr的区别小结
                                

                                

                                    《C++中NULL与nullptr的区别小结》本文介绍了C++编程中NULL与nullptr的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编...																									目录C++98空值——NULLC++11空值——nullptr区别对比示例 C++98空值——NUL
                                

                                

                                    阅读更多...
                                

                            

                        

                    

            

        

    


    


    

        

            Copyright China编程   23002807@qq.com
        

        

            沪ICP备2023033072号-2