C++实现一个只能在堆(栈)上生成对象的类

川长思鸟来 2023-05-31 06:39 22阅读 0赞

**目录**

只能在堆上生成对象的类

只能在栈上生成对象的类

--------------------

> 在C++中，类的对象创建可以静态创建在栈区, 如A a；还可以动态创建在堆区，如A\* ptr=new A；这两种方式是不同的, 具体来
> 
> 静态建立一个类的对象，是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数。
> 
> 动态建立类对象，是使用new运算符将对象建立在堆空间中, 是程序员主动申请的堆空间. 这个过程分为两步，第一步是执行operator new()函数，在堆空间中搜索合适的内存并进行分配 ; 第二步是调用构造函数构造对象，初始化这片内存空间。这种方法，会间接调用类的构造函数。

### 只能在堆上生成对象的类 ###

> 总的思路就是使其不能在栈上创建, 在堆上可以

> **思路一: 构造函数私有化**
> 
> 1. 不能让这个类在栈上创建, 由于在栈上创建对象要直接调用构造函数, 如果我们把构造函数私有化, 就 无法在栈上创建对象了   
> 2. 那么我们又如何在堆上创建对象呢, 由于创建对象必定要调用构造函数, 在我们不定义其他构造函数时, 我们已经将两个默认构造函数已经私有, 在类外肯定是调用不到构造函数,  我们只有定义一个公有的静态成员函数 ,在其内部用new在堆区创建对象并返回其指针, (这里有很难以理解的一点, 在静态成员函数中用new 创建一个对象时, 也会调用构造函数, 我们知道, 静态成员函数不能调用成员函数, 那么new是如何调到构造函数的呢? 这得从静态成员函数为什么不能访问成员函数说起, 每一个对象都有一个隐含的this指针, 访问成员函数实际上时通过this指针调用的, 而在构造函数调用前还没有实例化出对象, 也就没有this指针, 所以构造函数不需要this指针调用, 静态成员函数也就可以调用构造函数了), 这点解释通了
> 
> 还值得注意的是,  还必须将拷贝构造私有化, 不然会出现 用堆上创建好的对象拷贝构造一个栈上的对象这种情况发生
> 
> 上代码

class.h

#pragma once
    class T1 {
    	T1(int val):b(val) {
    
    	}
    	T1(T1& x):b(x.b){
    		
    	}
    public:
    	int b;
    	static T1* newT1_p(int val = 0) {
    		return new T1(val);
    	}
    	static T1& newT1(int val = 0) {
    		return *new T1(val);
    	}
    };

测试入口main.cpp

#include<iostream>
    #include"class.h"
    int main() {
    	T1* t1_p = T1::newT1_p(10);
    	cout << t1_p->b << endl;
    	T1& t1 = T1::newT1(20);
    	cout << t1.b << endl;
    	system("pause");
    	return 0;
    }

运行结果 :

![20191023103842161.png][]

如果我们静态创建在栈上的话编译不过, 如下:

#include<iostream>
    #include"class.h"
    using namespace std;
    
    int main() {
    	T1 t2;
    	T1 t3(10);
    	system("pause");
    	return 0;
    }

运行结果: 编译未通过, 原因是构造函数私有化, 无法在类外访问

![20191023104246117.png][]

> **思路二: 析构函数私有化**
> 
> 将析构函数私有化, 在栈上也就不能直接创建对象了, 因为编译器在编译时会进行检测,  那没有析构函数也是不行的, 我们还需要实现一个函数来调用私有的析构函数, (这个思路就比构造函数私有好理解多了)
> 
> 上代码

class.h

class T2 {
    	~T2() {
     		delete this;
    	}
    public:
    	int b;
    	T2(int val = 0) :b(val) {
     
    	}
    	void Destroy() {
           this->~T2();
    	}
    };

测试入口 main.cpp

#include<iostream>
    #include"class.h"
    using namespace std;
    
    int main() {
    	T2* t2_p = new T2(10);
    	t2_p = t2_p->Destroy();
    	cout << t2_p->b << endl;
    	system("pause");
    	return 0;
    }

![2019110411404823.png][]

尝试在栈上创建

#include<iostream>
    #include"class.h"
    using namespace std;
    
    int main() {
    	T2 a;
    	T2 b(10);
    	system("pause");
    	return 0;
    }

![20191023111102813.png][]

--------------------

### 只能在栈上生成对象的类 ###

> 总体思路就是一个普通的类, 不让其在堆上创建对象, 在堆上创建对象必定要用到new ,那我们直接在这个类内部将new重载成一个私有的成员函数, 目的就是让在类外使用不到原来的操作符new, 这样在类外就无法在堆上创建这个对象了
> 
> 上代码

class.h

#pragma once
    class T3 {
    	void* operator new(size_t val) {}
    public:
    	int a;
    	T3(int val = 0) :a(val) {
    
    	}
    };

测试入口main.cpp

#include<iostream>
    #include"class.h"
    using namespace std;
    
    int main() {
    	T3 a;
    	cout << a.a << endl;
    	T3 b(10);
    	cout << b.a << endl;
    	system("pause");
    	return 0;
    }

![20191023114314182.png][]

尝试用new在堆上创建

#include<iostream>
    #include"class.h"
    using namespace std;
    
    int main() {
    	T3* p1 = new T3;
    	T3* p2 = new T3(10);
    	system("pause");
    	return 0;
    }

运行结果: 创建不成功

![20191023114338709.png][]

[20191023103842161.png]: /images/20230531/5171f5e2149e4fd5a12075c764399b76.png
[20191023104246117.png]: /images/20230531/db4133efb844491cb701214a9b49d809.png
[2019110411404823.png]: /images/20230531/221dd208fd2d4caf9ac018530257ef8c.png
[20191023111102813.png]: /images/20230531/fe627fedd0144d44bbf1c5d2bba6a44a.png
[20191023114314182.png]: /images/20230531/345d98784bc444c897e1b05654e75de0.png
[20191023114338709.png]: /images/20230531/50c4a8a843a6443e953270b0cf908008.png