云南住房与建设厅网站,苏州建站公司精选苏州聚尚网络,电子商务网站设计规划书,工信部的网站备案信息查询特殊类的设计与类型转换 特殊类的设计请设计一个类#xff0c;只能在堆上创建对象请设计一个类#xff0c;只能在栈上创建对象请设计一个类#xff0c;只能创建一个对象(单例模式) C的类型转换 特殊类的设计
请设计一个类#xff0c;只能在堆上创建对象
通过new创建的类就… 特殊类的设计与类型转换 特殊类的设计请设计一个类只能在堆上创建对象请设计一个类只能在栈上创建对象请设计一个类只能创建一个对象(单例模式) C的类型转换 特殊类的设计
请设计一个类只能在堆上创建对象
通过new创建的类就是堆上的。 方法一
#includeiostreamusing namespace std;
class HeapOnly
{
public:static HeapOnly* func()//这里如果不用静态就无法创建对象了也导致这个函数无法被调用{return new HeapOnly;}
private:HeapOnly()//防止随意的创建对象{}HeapOnly(const HeapOnly a) delete;//如果不删除拷贝函数创建的对象还是在栈上
};
int main()
{HeapOnly* p1 HeapOnly::func();//HeapOnly p2(*p1);//这样避免了p2对象创建在栈上return 0;
}这里主要以封禁构造函数为主让外部只能通过调用func函数方式去创建对象func函数的内部是通过new创建的这里要注意的就是拷贝构造的问题。 赋值重载不用删除因为需要现有一个对象才能赋值给另一个对象上面的代码只会创建出堆上的对象。 方法二
#includeiostreamusing namespace std;class HeapOnly
{
public:HeapOnly(){}void Delete(){this-~HeapOnly();}
private:~HeapOnly(){}HeapOnly(const HeapOnly a) delete;
};int main()
{HeapOnly* p1 new HeapOnly;p1-Delete();return 0;
}封禁析构函数需要自己手动释放内存。
请设计一个类只能在栈上创建对象
这里要注意一点静态区也不行。 方法一
#include iostream
using namespace std;
class NonInherit
{
public:static NonInherit func(){return NonInherit();}void Pintf(){cout Pintf endl;}
private:NonInherit(){}NonInherit(const NonInherit p) delete;
};
int main()
{NonInherit::func().Pintf();//static NonInherit p1 NonInherit::func();//防止p1创建在静态区上return 0;
}这里就像匿名对象的感觉如果不封拷贝构造就会出现注释上的问题。 方法二
#include iostream
using namespace std;
class NonInherit
{
public:static NonInherit func(){return NonInherit();}void Pintf() const{cout Pintf endl;}
private:NonInherit(){}NonInherit(const NonInherit p) delete;
};
int main()
{const NonInherit p1 NonInherit::func();//用引用接收p1.Pintf();//然后在使用return 0;
}请设计一个类只能创建一个对象(单例模式)
设计模式 设计模式Design Pattern是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。 单例模式 一个类只能创建一个对象即单例模式该模式可以保证系统中该类只有一个实例并提供一个访问它的全局访问点该实例被所有程序模块共享。比如在某个服务器程序中该服务器的配置信息存放在一个文件中这些配置数据由一个单例对象统一读取然后服务进程中的其他对象再通过这个单例对象获取这些配置信息这种方式简化了在复杂环境下的配置管理。 单例模式有两种实现模式 饿汉模式 就是说不管你将来用不用程序启动时就创建一个唯一的实例对象。
#includeiostream
#includemap
#includestring
using namespace std;
class Singleton
{
public:static Singleton func(){return _a;//拿到对象本身}void Insert(string str, int salary){arr[str] salary;}void Printf(){for (auto e : arr){cout e.first : e.second endl;}}
private:Singleton(){}Singleton(const Singleton) delete;Singleton operator(const Singleton) delete;mapstring, int arr;static Singleton _a;
};
Singleton Singleton::_a;//在外部初始化对象同类对象只会调用一次构造函数int main()
{Singleton::func().Insert(aaa, 111);Singletonp Singleton::func();p.Insert(bbb, 222);p.Insert(ccc, 333);p.Insert(ddd, 444);p.Insert(eee, 555);p.Printf();return 0;
}这个模式缺点 如果数据量太大启动就会非常的缓慢。 如果有多个文件一起都有饿汉模式的代码他们互相之间有依赖但是编译器很难控制先初始化谁。
懒汉模式 如果单例对象构造十分耗时或者占用很多资源比如加载插件啊 初始化网络连接啊读取文件啊等等而有可能该对象程序运行时不会用到那么也要在程序一开始就进行初始化就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式延迟加载更好。
#includeiostream
#includemap
#includestring
#includemutex
using namespace std;
templateclass T
class Lock
{
public:Lock(T p)//因为锁不允许拷贝:_p(p){_p.lock();}~Lock(){_p.unlock();}
private:T _p;//所以这里成员用引用
};
class Singleton
{
public:static Singleton func(){if (_a nullptr)//避免每次调用的时候都进行加锁的操作提高效率{Lockmutex p(mex);//用智能指针是为了防止下面的new出现异常导致未解锁//如果不加锁容易发生内存泄露开辟多个空间最终指针只会指向一处空间if (_a nullptr)//第一次调用创建对象{_a new Singleton;}}return *_a;}void Insert(string str, int salary){arr[str] salary;}void Printf(){for (auto e : arr){cout e.first : e.second endl;}}
private:Singleton(){}Singleton(const Singleton) delete;Singleton operator(const Singleton) delete;mapstring, int arr;static Singleton* _a;static mutex mex;//锁
};
Singleton* Singleton::_a nullptr;//在外部初始化对象同类对象只会调用一次构造函数
mutex Singleton::mex;//定义锁
int main()
{Singleton::func().Insert(aaa, 111);Singleton p Singleton::func();p.Insert(bbb, 222);p.Insert(ccc, 333);p.Insert(ddd, 444);p.Insert(eee, 555);p.Printf();return 0;
}并且一般单例对象不用考虑释放因为一个进程在结束的时候资源会回收给OS。 如果有需要处理的资源需要在内部定义一个函数去处理某个资源然后其他资源不用处理
static void Delete()//手动释放资源
{Lockmutex p(mex);if (_a ! nullptr){delete _a;_a nullptr;}
}假如忘记回收这个资源了呢 在内部定义一个GC的类这个类的析构函数内部调用上面的Delete函数。
class GC
{
public:~GC(){if (_a){cout ~GC() endl;Delete();}}
};然后再外部定义一个全局的GC类的对象在程序结束的时候就会去调用析构函数。 主要是帮助检查有没有手动释放掉这一出资源。 注意C11前是无法保证线程静态的初始化是安全的C11之后可以。 也就是说懒汉还有这种写法
static Singleton func()
{static Singleton _a;return _a;
}函数的成员也就不用了静态对象。
C的类型转换
C语言有两种类型转换一个是隐式类型转换另一个是强制类型转换。
#includeiostream
using namespace std;int main()
{//隐式类型int a 1;double b a;//强制类型int c 10;int* p c;int d (int)p;return 0;
}C有四种类型转换是期望大家能够规范使用的。 为什么C需要四种类型转换 C风格的转换格式很简单但是有不少缺点的 1.隐式类型转化有些情况下可能会出问题比如数据精度丢失。 2.显式类型转换将所有情况混合在一起代码不够清晰。 因此C提出了自己的类型转化风格注意因为C要兼容C语言所以C中还可以使用C语言的转化风格。 static_cast static_cast用于非多态类型的转换静态转换编译器隐式执行的任何类型转换都可用。 static_cast但它不能用于两个不相关的类型进行转换。 reinterpret_cast reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释用于将一种类型转换 为另一种不同的类型。 const_cast const_cast最常用的用途就是删除变量的const属性方便赋值。 这里看起来并没有被赋值成功是因为编译器进行了优化认为const的变量不会被修改所以这个值一直放在了寄存器中并没有从内存中获取数据一直未被更新到寄存器当中。 dynamic_cast dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换) 向上转型子类对象指针/引用-父类指针/引用(不需要转换赋值兼容规则) 向下转型父类对象指针/引用-子类指针/引用(用dynamic_cast转型是安全的) 注意 1.dynamic_cast只能用于父类含有虚函数的类 2. dynamic_cast会先检查是否能转换成功能成功则转换不能则返回0 #includeiostream
using namespace std;
class A
{
public:virtual void f() {}int a;
};
class B : public A
{
public:int b;
};
void fun(A* pa)
{// dynamic_cast会先检查是否能转换成功能成功则转换不能则返回B* pb dynamic_castB*(pa);//子类指向父类访问父类的内容的时候虚表可能会越界产生报错if (pb)//检查是否合法其实就是拒绝了子类指向父类{pb-a;pb-b;cout a b endl;}
}
int main()
{A a;B b;fun(a);fun(b);return 0;
}注意 强制类型转换关闭或挂起了正常的类型检查每次使用强制类型转换前程序员应该仔细考虑是 否还有其他不同的方法达到同一目的如果非强制类型转换不可则应限制强制转换值的作用 域以减少发生错误的机会。强烈建议避免使用强制类型转换。
