构造函数的巧用

1:定义一个不能被继承的类

我们可以声明一个辅助的类A，把类A这个类的构造函数声明为私有的，并使得B是A的友元类，且B虚继承A。这样的话别的类就不能继承B了。

假设现在有一个类D继承B，在D初始化的时候会先调用B类的构造函数，但是由于B虚继承A，所以为了防止产生二义性，D必须先调用A的构造函数，由于A的构造函数是私有的不可访问，所以会产生错误，继承会失败。

#include<iostream>
#include<iomanip>
using namespace std;
 
 
//设计一个不能被继承的类
 
class B;//前向声明
class A{
	friend B;
private:
	A(){}
};
class B : virtual public A{
public:
	B(){cout << "Hello" << endl;}
};
//class D : public B{//error C2248: “A::A”: 无法访问【private 成员】
//public://A的构造函数不可访问，产生错误
//	D(){}
//};
 
void main()
{
	B b;
	//D d;
}

2:一个只能在栈上生成对象的类

对象可以在栈上生成也可以由我们在堆上new出来。要想只在栈上生成对象而不能在堆上生成对象在类外

是无法完成的，我们必须从类的内部入手。

我们知道类对象的构造是由构造函数完成的，如果我们把构造函数声明为保护的，使得不能在类外调用

构造函数，这样的话就不能在类外new出对象了，但这同时也不能在类外定义对象了。

为此，我们可以在类内生成一个对象并提供一个公有的接口来返回这个对象。接下来如果在类外定义类

对象的话，只需要调用这个函数即可。貌似这样做还是行不通，因为在类外只能由类对象调用类成员函数，这

该怎么办呢？？？我们可以将这个接口声明为静态成员函数，这样就可以了。

#include<iostream>
#include<iomanip>
using namespace std;
 
 
class CObjOnlyInStack{
public:
	static CObjOnlyInStack GetObjInst(int data){return CObjOnlyInStack(data);}
	void DispSelf(){cout << "data : " << iData << endl;}
protected:
	CObjOnlyInStack(int data){iData = data;}
private:
	int iData;
};
 
 
void main()
{
	//“CObjOnlyInStack::CObjOnlyInStack”: 无法访问【protected 成员】
	//CObjOnlyInStack oObjOnlyInStack(10);
	//CObjOnlyInStack* pObjOnlyInStack = new CObjOnlyInStack(100);
	
	CObjOnlyInStack oObjOnlyInStack = CObjOnlyInStack::GetObjInst(1000);
	oObjOnlyInStack.DispSelf();
}

3:一个只能在堆上生成对象的类(分析同上)

#include<iostream>
#include<iomanip>
using namespace std;
 
class CObjOnlyInHeap{
public:
	static CObjOnlyInHeap* GetObjInst(int data){return new CObjOnlyInHeap(data);}
	void DispSelf(){cout << "data : " << iData << endl;}
protected:
	CObjOnlyInHeap(int data){ iData = data;}
private:
	int iData;
};
 
void main()
{
	//“CObjOnlyInHeap::CObjOnlyInHeap”: 无法访问【protected 成员】
	//CObjOnlyInHeap* pObjOnlyInHeap = new CObjOnlyInHeap(10);
 
	CObjOnlyInHeap* pObjOnlyInHeap = CObjOnlyInHeap::GetObjInst(100);
	pObjOnlyInHeap->DispSelf();
}

猜你喜欢