C++创建一个类(1.只能在堆上创建； 2 只能在栈上创建； 3 不能被继承(堆上和栈上都可以创建))

本文链接：https://blog.youkuaiyun.com/u011036348/article/details/11124613

本文介绍了如何在C++中通过不同方式限制对象的创建位置：1) 只允许在堆上创建，通过private构造函数并提供静态创建/删除接口实现；2) 只能在栈上创建，通过重载new为私有实现；3) 不能被继承，同时能在堆和栈上创建，利用模板和虚继承阻止继承。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1 只能在堆上创建对象(不能被继承，不能再栈上创建对象)
  将类的构造函数声明为private,但是为了
  创建该类的对象，则必须提供创建对象和释放对象的接口，
  用static函数成员实现。
 


#include<iostream>  
using namespace std;  

class HeapOnly  
{	
public:   
    static HeapOnly *CreateInstance()
    {  
        HeapOnly * obj=new HeapOnly;  
        obj->m=2;  
        return obj;  
    }  
    static void DeleteInstance(HeapOnly * obj)
    {  
        if(obj!=NULL)  
			delete obj;  
    }

private:  
    HeapOnly(){};  
    ~HeapOnly(){}; 

public:
	int m;
	
};  

int main()  
{  
	HeapOnly *obj=HeapOnly::CreateInstance();  
	cout<<obj->m<<endl;  
	HeapOnly::DeleteInstance(obj);  

	//HeapOnly test; //error
	
	system("pause");  
	return 0;  
}


2 只能在栈上创建对象(不能在堆上创建对象)
  思路：在堆上创建对象要用到new，为了在内外不能使用new，把new重载为私有

#include <iostream>  
using namespace std;  

class   StackOnly  
{  
public:  
	StackOnly() { 
		cout <<   "constructor."  <<   endl;
	}  
	~StackOnly()
	{
		cout << "destructor." <<   endl;   
	}  
private:  
	void*   operator   new   (size_t size);  
};  

int main()  
{  
	StackOnly   s;                                                   
	//StackOnly   *p   =   new   StackOnly; // error                         
    
	return   0;  
}



3 不能被继承、能在堆上创建对象，也能在栈上创建对象
// NotInheritClass 类是不能被继承、能在堆上创建对象，也能在栈上创建对象
#include <iostream>  
using namespace std;  

template <typename T> 
class MakeFinal
{
	friend T;
private:
	MakeFinal() { cout << "MakeFinal "<<endl; }
	~MakeFinal() { cout << "~MakeFinal "<<endl; }
};

class NotInheritClass: virtual public MakeFinal<NotInheritClass>
{
public:
	NotInheritClass(){ cout << "NotInheritClass "<<endl; }
	~NotInheritClass(){ cout << "~NotInheritClass "<<endl; }
};


// class Test:public NotInheritClass // 继承失败
// {
// public:
// 	Test(){};
// 	~Test(){};
// };



int main()
{	
	NotInheritClass test1;
	NotInheritClass *test2 = new NotInheritClass;
	delete test2;
	return 0;
}

// 由于类 NotInheritClass 是从类 MakeFinal <NotInheritClass> 虚继承过来的，
// 在调用 Test 的构造函数的时候，
// 会直接跳过 NotInheritClass 而直接调用 MakeFinal <NotInheritClass> 的构造函数。
// 非常遗憾的是， Test 不是 MakeFinal <NotInheritClass> 的友元，
// 因此不能调用其私有的构造函数。
// 基于上面的分析，试图从NotInheritClass 继承的类，一旦实例化，
// 都会导致编译错误，因此NotInheritClass 不能被继承。这就满足了我们设计要求。