网站做哪种推广好,wordpress 主题作者页,北京网站制作推广,台州市住房和城乡建设规划局网站文章目录 特殊类1.请设计一个类#xff0c;不能被拷贝2. 请设计一个类#xff0c;只能在堆上创建对象3. 请设计一个类#xff0c;只能在栈上创建对象 #xff08;★#xff09;4. 请设计一个类#xff0c;不能被继承5. 请设计一个类#xff0c;只能创建一个对象(单例模式… 文章目录 特殊类1.请设计一个类不能被拷贝2. 请设计一个类只能在堆上创建对象3. 请设计一个类只能在栈上创建对象 ★4. 请设计一个类不能被继承5. 请设计一个类只能创建一个对象(单例模式)1. 饿汉模式2. 懒汉模式 类型转换内置类型转为自定义类型自定义类型转换为内置类型自定义类型转为自定义类型 四种强制类型转换操作符1.static_cast2.reinterpret_cast3.const_cast4.dynamic_cast 特殊类
1.请设计一个类不能被拷贝
这个很简单直接把拷贝构造delete就行了但是我们还需要把赋值运算符重载也delete了因为在赋值过程的时候需要用到拷贝构造。
//1. 设计一个类不能别拷贝
class NoCopy
{
public:NoCopy(int x 0):_x(x){}NoCopy(const NoCopy cp) delete;NoCopy operator(const NoCopy cp) delete;~NoCopy(){cout ~NoCopy() endl;}private:int _x;
};2. 请设计一个类只能在堆上创建对象
那么我们创建的变量分为三种情况
栈堆静态区
那也就是说我们对象都需要 n e w new new出来那么我们就需要把构造函数delete就可以了。同时每次创建对象都只能 n e w new new出来。
//2. 请设计一个类只能在堆上创建对象
class HeapOnly
{
public:static HeapOnly* Getobject(int a 0){return new HeapOnly(a);}HeapOnly(const HeapOnly hp) delete;HeapOnly operator(const HeapOnly hp) delete;~HeapOnly(){delete this;}
private:HeapOnly(int a 0) //构造函数变为私有那么外层无法使用每次创建对象只能调用Getobject来创建。:_a(a){}int _a;
};还有一种思路是把析构函数设置为私有但是这种情况就需要手动释放资源了。
//2. 请设计一个类只能在堆上创建对象
class HeapOnly
{
public:static HeapOnly* Getobject(int a 0){return new HeapOnly(a);}HeapOnly(int a 0):_a(a){}HeapOnly(const HeapOnly hp) delete;HeapOnly operator(const HeapOnly hp) delete;void Destory(){delete this;}
private:~HeapOnly(){cout ~HeapOnly() endl;}int _a;
};3. 请设计一个类只能在栈上创建对象 ★
//3. 请设计一个类只能在栈上创建对象
class StackOnly
{
public:static StackOnly Getobject(int a 0){return StackOnly(a);}~StackOnly(){cout ~StackOnly() endl;}void* operator new(size_t size) delete;void operator delete(void* p) delete;
private:StackOnly(int a 0):_a(a){}int _a;
};void Test_StackOnly()
{StackOnly s1 StackOnly::Getobject(1); //由于我们需要赋值给s1所以这里我们不得不把拷贝构造放出来StackOnly* s2 new StackOnly(s1);//但是这样的情况不能避免所以此时我们只能从new下手
}由于new的本质为构造函数 operator new
delete的本质为 operator delete 析构函数
虽然operator new和operator delete为全局函数但是当局部写了的时候优先使用局部的。所以这里我们只需要把operator new和operator delete取消即可。
4. 请设计一个类不能被继承 这里有两种方法 把基类的构造私有化子类调不到父类的构造函数直接使用final关键字。 5. 请设计一个类只能创建一个对象(单例模式) 单例模式 **一个类只能创建一个对象即单例模式该模式可以保证系统中该类只有一个实例并提供一个访问它的全局访问点该实例被所有程序模块共享。**比如在某个服务器程序中该服务器的配置信息存放在一个文件中这些配置数据由一个单例对象统一读取然后服务进程中的其他对象再通过这个单例对象获取这些配置信息这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式
1. 饿汉模式
就是说不管你将来用不用程序启动时就创建一个唯一的实例对象。
class Singleton
{
public:static Singleton Getobject(int a 0){_ins._a a;return _ins;}Singleton(const Singleton sl) delete;Singleton operator(const Singleton sl) delete;void Print(){cout _a endl;cout _id endl;cout _pos endl;}~Singleton(){cout ~Singleton() endl;}private:static Singleton _ins;Singleton(int a 0):_a(a){cout Singleton() endl;}int _a 0;string _id 111111111;int _pos 100;
};
Singleton Singleton::_ins; //在程序初始化之前创建一个对象int main()
{Singleton::Getobject(1).Print(); return 0;
}2. 懒汉模式
懒汉模式和饿汉模式的区别就在于饿汉模式是提前初始化好了而懒汉模式则是调用的时候再初始化。
class Singleton
{
public:static Singleton Getobject(int a 0){static Singleton _ins; //调用的时候才初始化_ins._a a;return _ins;}Singleton(const Singleton sl) delete;Singleton operator(const Singleton sl) delete;void Print(){cout _a endl;cout _id endl;cout _pos endl;}~Singleton(){cout ~Singleton() endl;}private:Singleton(int a 0):_a(a){cout Singleton() endl;}int _a 0;string _id 111111111;int _pos 100;
};
int main()
{Singleton::Getobject(1).Print(); return 0;
}类型转换
在C语言阶段我们学了隐式类型转换和显示类型转换。
//内置类型
int main()
{//隐式类型转换int x 1;double d 2.2;x d;//显示类型转换int* p (int*)x;cout x p endl;return 0;
}而在C中我们还有自定义类型那么自定义类型和内置类型究竟是怎么转化的呢
内置类型转为自定义类型
利用自定义类型的构造函数这个其实在类和对象我们已经学过了隐式类型转换。
class A
{
public:A(int a 0):_a(a),_b(a){}A(int a,int b):_a(a),_b(b){}void Print(){cout _a _b endl;}
private:int _a;int _b;
};
int main()
{A a1 1;A a2 { 1,2 };a1.Print();a2.Print();return 0;
}如上段代码我们通过自定义类型的构造函数让内置类型转换为自定以类型。
自定义类型转换为内置类型
重载operator()但是由于operator()已经被占用所以为了和别的operator()区分出来我们需要如下定义
operator int() //注意这里的int不能写为返回值只能写在operator后面。
{return _a _b;
}
int main()
{A a1(1);A a2{ 1,2 };a1.Print();a2.Print();int x a1;int y a2;cout x y endl;return 0;
}自定义类型转为自定义类型
通过构造函数建立关联两个不同的自定义类型强转是行不通的所以得去写函数来建立两个类型之间的关系。
class B
{
public:B(int a 0):_a(a){}operator int() const{return _a;}~B(){cout ~B() endl;}int get() const{return _a;}
private:int _a;
};
class A
{
public:A(int a 0):_a(a),_b(a){}A(int a,int b):_a(a),_b(b){}A(const B bb) //直接这里的get()究竟返回的是什么由自己决定。:_a(bb.get()),_b(bb.get()){}void Print(){cout _a _b endl;}operator int() const{return _a _b;}~A(){cout ~A() endl;}
private:int _a;int _b;
};再来看如下代码
int main()
{//自己模拟实现的listbit::listint k { 1,2,3,4 };//这里我们的k.begin()为普通的iteratorbit::listint::const_iterator it k.begin(); //const_iterator iteratorwhile (it !- k.end()){cout *it ;it;}cout endl;return 0;
}如上图: 由于我们的迭代器是由我们自己写的模版那么他们的模版参数并不相同那么实例化出来的类型也不相同所以这里也属于自定义类型转换自定义类型但由于我们迭代器并没有把两种关联起来所以这里也是转换不了的 。但是库里面上面代码确可以运行那几句说明我们库中是实现了iterator-const_iterator的转换的。 //添加一个构造函数进来的参数为普通的迭代器 同时类型转化会产生临时对象所以要用const修饰//这样无论我们是普通迭代器还是const_iterator虽然参数是普通迭代器但是返回的却是按照对应类型返回。ListIteraotr(const ListIteraotrT,T,T* ls) :_node(ls._node){}四种强制类型转换操作符
标准C为了加强类型转换的可视性引入了四种命名的强制类型转换操作符。
1.static_cast static_cast用于非多态类型的转换静态转换编译器隐式执行的任何类型转换都可用 static_cast但它不能用于两个不相关的类型进行转换 int main()
{double d 12.34;int a static_castint(d);coutaendl;return 0;
}2.reinterpret_cast reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释用于将一种类型转换为另一种不同的类型 int main()
{//对应隐式类型转换数据的意义没有改变值传递double d 12.34;int a static_castint(d);cout a endl;//对应强制类型转换数据的意义改变int - int*int *p reinterpret_castint*(a);return 0;
}3.const_cast const_cast最常用的用途就是删除变量的const属性方便赋值 void Test()
{//对应强制类型转换中有风险的去调const属性const int a 2;int* p const_castint*(a);*p 3;cout a endl;cout *p endl;
}int main()
{Test();return 0;
}但是此时我们发现为什么我们的a还是2呢原因是编译器进行了优化虽然内存当中我们a的值已经发生了改变但是由于我们的a是const修饰的为常变量所以编译器会把它直接替换为2或者存入一个寄存器当中所以并没有去内存当中去取。
4.dynamic_cast
继承体系中 **向上转型子类对象指针/引用-父类指针/引用(不需要转换赋值兼容规则) ** 向下转型父类对象指针/引用-子类指针/引用(用dynamic_cast转型是安全的) 注意这里是引用或者指针如果是对象的话不可以进行强制类型转换。
在继承体系中如果我们想要把子类的指针或者引用转化为父类的指针或者引用会进行一个切片的操作就是把子类中父类的部分传过去所以不会产生临时变量。
class A
{
public:virtual void f() {}int _a 0;
};
class B : public A
{
public:int _b 0;
};
void fun(A* pa)
{// dynamic_cast会先检查是否能转换成功能成功则转换不能则返回B* pb1 (B*)pa;B* pb2 dynamic_castB*(pa);cout pb1: pb1 endl;cout pb2: pb2 endl;cout pb1-_a endl;cout pb1-_b endl;
}
int main()
{A a;B b;fun(a);cout endl;fun(b);return 0;
}如上图虽然我们static_cast也可以转换但是并没有dynamic_cast安全这时为什么呢 如上图当我们调用的是子类的指针那么我们强转之后是没有问题的但如果是父类的指针强转之后我们并没有对应的子类的值啊所以当我们想要访问的时候必然会出现报错因为访问了一个根本没有的值。
而dynamic_cast会先判断如果我们传入的是父类指针会返回空指针。
如果是子类的会会进行特殊处理把子类中父类的部分切片进行传递。
