限制一个类只可以在栈或者堆上创建

最新推荐文章于 2022-07-25 22:46:56 发布

BugattiEngine

最新推荐文章于 2022-07-25 22:46:56 发布

阅读量136

点赞数

CC 4.0 BY-SA版权

分类专栏： C++奇淫技巧文章标签：构造函数 operator new

本文链接：https://blog.youkuaiyun.com/shujianlove0/article/details/84564629

C++奇淫技巧专栏收录该内容

9 篇文章

订阅专栏

本文探讨了C++中通过删除默认的operatornew(size_t)方法和构造/析构函数来限制对象创建方式的技术。介绍了如何仅允许在栈上创建对象，以及如何仅允许通过new在堆上创建对象的方法。

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

删除默认的operator new(size_t) 方法后将无法创建动态对象
删除默认的构造或者析构函数则只能通过new来进行对象创建

//只可以在栈上创建 ，删除 new 重载方法
void * operator new(size_t Size) = delete;

//只在堆上 ,删除默认构造和析构函数
class heaponly {private: heaponly(); ~heaponly(); };

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

BugattiEngine

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

限制一个类的对象实例,只能在"堆"上分配,或者只能在"栈"上分配

身在边城心在编程

05-12

1008

1、只能在栈上创建 2、只能在堆上创建 3、如何防止一个类被拷贝 4、如何防止一个类被继承 5、如何让一个类只创建一个对象

C++中如何设计一个类只能在堆或者栈上创建对象

小白的Coding之旅

09-22

835

设计一个类，该类只能在堆上创建对象将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建注意在堆和栈上创建对象都会调用构造函数，为了防止在栈上创建对象我们将构造函数私有化。拷贝构造函数是在栈上创建对象。 class HeapOnly { public: static HeapOnly* CreateOb...

参与评论您还未登录，请先登录后发表或查看评论

C++每日一问：如何限制类对象只能建立在堆上或者栈上?

欧特GO

10-27

1279

在C++中，类的对象建立分为两种，一种是静态建立，如A a；另一种是动态建立，如A ptr=new A；这两种方式是有区别的。* 1)静态建立一个类对象，是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数。 2)动态建立类对象，是使用new运算符将对象建立在堆空间中。这个过程分为两步，第一步是执行operator new()函数，在堆空间中搜索合适的内存并进行分配；第二步是调用构造函数构造对象，初始化

怎么限制一个类的对象实例,只能在“堆“上分配,或者只能在“栈“上分配

weixin_44570263的博客

07-25

1003

在C++中，类的对象建立分为两种，一种是静态建立（栈），如Aa；另一种是动态建立（堆），如A*ptr=newA；这两种方式是有区别的。一个类对象，是由编译器为对象在中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，。动态建立类对象，是使用n（或malloc）将对象建立在堆空间中。这个过程分为两步，第一步是执行operatornew()函数，在堆空间中搜索合适的内存并进行分配；第二步是调用构造函数构造对象，初始化这片内存空间。...

C++ | 对象创建限制在堆或栈

大柳_的博客。

05-18

1291

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、对象的建立二、限制对象只能建立在堆上：1.解决方法 1：2.解决方法 2：二、限制对象只能建立在栈上：前言如何限制类的对象只能在堆上创建？如何限制对象只能在栈上创建？一、对象的建立说明：C++ 中的类的对象的建立分为两种：静态建立、动态建立。静态建立：由编译器为对象在栈空间上分配内存，直接调用类的构造函数创建对象。例如：A a; 动态建立：使用 new 关键字在堆空间上创建对象，底层首先调用 operator .

C++学习笔记-- 如何限制类的对象只能在堆上创建？如何限制对象只能在栈上创建？

jeason的博客

03-07

1935

引用自 leetcode 的c++面试突击。如何限制类的对象只能在堆上创建？如何限制对象只能在栈上创建？说明：C++ 中的类的对象的建立分为两种：静态建立、动态建立。静态建立：由编译器为对象在栈空间上分配内存，直接调用类的构造函数创建对象。例如：A a; 动态建立：使用 new 关键字在堆空间上创建对象，底层首先调用 operator new() 函数，在堆空间上寻找合适的内存并分配；然后，调用类的构造函数创建对象。例如：A *p = new A(); 限制对象只能建立在堆上：最直观的思想：避免直

如何限制C++类的对象只能建立在堆上或栈上

xl365t

11-21

1520

C++中，类的对象建立分为两种，一种是静态建立，如A a; 另一种是动态建立，如 A *ptr = new A; 静态建立一个类对象，是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数。动态建立一个类对象，是使用new运算符将对象建立在堆空间中。这个过程分为两步：第一步...

C++如何限制只能在堆或栈上创建对象？

sstinky的博客

12-26

1635

1.设计只能在堆（heap）上创建对象/禁止产生栈（stack）对象将构造函数也设为private或protected, 但需要让该类提供一个static成员函数专门用于产生该类型的堆对象. （设计模式中的singleton模式就可以用这种方式实现. ）让我们来看看: #include <iostream> using namespace std; class NoS...

C++对象是创建在堆上，还是在栈上？

zxh2075的专栏

12-15

9680

https://blog.youkuaiyun.com/Solo_two/article/details/79780086 如果需要在堆上创建对象，要么使用new运算符，要么使用malloc系列函数。这点没有异议。真正有异议的是下面的代码： Object obj; 此时，obj是在栈上分配的吗？要回答这个问题，我们首先要理解这个语句是什么意思。这个语句就是代表着，在栈上创建对象吗？其实，这...

C++只在栈或堆上实例化对象

心有猛虎细嗅蔷薇

09-11

2121

C++如何让类对象只能在堆（栈）上分配空间一般情况下写一个类都是可以采用new在堆上分配空间，或直接采用类名+对象名的方式在栈上分配空间。但有时候，如果想让一个类只能在栈上或者堆上分配空间，又该怎么实现呢？下面分别来介绍如何定义只能在栈上或堆上实例化的类。注： 1.静态实例化对象如 A a;的步骤为：先由编译器为对象在栈空间分配内存，移动栈顶指针，挪出适当的空间，然后在这个空间上...

如何让类对象只在栈（堆）上分配空间？

SuperWe的博客

05-25

3657

一般情况下，编写一个类，是可以在栈或者堆分配空间。但有些时候，你想编写一个只能在栈或者只能在堆上面分配空间的类。这能不能实现呢？仔细想想，其实也是可以滴。在C++中，类的对象建立分为两种，一种是静态建立，如A a；另一种是动态建立，如A* ptr=new A；这两种方式是有区别的。1、静态建立类对象：是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后（编译器）在这片内存

设计一个只能在堆上或栈上实例化的类

12-22

同时，为了防止通过 `new` 操作符在堆上创建对象，我们可以提供一个公共的 `Destroy` 方法，允许用户手动删除对象。注意，这种方式需要用户正确地管理对象生命周期，否则可能导致内存泄漏。另一种方法是将构造函数...

设计一个类：只能在堆上创建对象？只能在栈上创建对象？只能创建一个对象？

honeyJ

08-01

2415

在C++中，类的对象建立分为两种，一种是静态建立，如A a；另一种是动态建立，如A* ptr=new A；这两种方式是有区别的。静态建立一个类对象，是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数；动态建立类对象，是使用new运算符将对象建立在堆空间中。这个过程分为两步，第一步是执...

std::bind 函数参数绑定

shujianlove0的博客

11-27

2918

std::bind 可以将一个多参数的函数转化为一个少参数或者无参数函数，上面的bind之后变为func(int value,1,5),函数签名是bool (int)了而非 bool(int,int,int） 1.如果需要把一个类中的函数转换为全局函数签名，则std::bind(func,this); 2.静态函数可以直接绑定 bool fun(int value, int min, int ...

std::enable_if<bool>::type 限定模板传递的类型

shujianlove0的博客

11-27

1489

类似于C#中可以指定泛型的父类，在C++编译期间强行报错通过enable_if 实现如果std::is_arithmetic::value || std::is_convertible<T, string>::value的值为false，则会提示type 找不到，进而无法通过编译 struct Initializer { template <typename T, ty...

std::variant代替union

shujianlove0的博客

11-27

1229

std::variant<int, double, std::wstring> var1{ 1.0 }; std::variant<int, double, std::wstring> var2{ L"2" }; std::variant<int, std::wstring> var3{ 3 }; //assign var2 = L"abc"; var1 = ...

std::lock_guard对整个函数加锁访问

shujianlove0的博客

11-27

1080

std::lock_guard<std::mutex> lock(mutex_); 性能优化是最小使用原则，那么将需要使用的代码块单独拿出来作为函数 mutex_将会自动release 当超出作用范围的时候。 lock_guard 对象的拷贝构造和移动构造(move construction)均被禁用，因此 lock_guard 对象不可被拷贝构造或移动构造。 void safe_in...

operator[] 运算符返回引用和返回值得不同const修饰

shujianlove0的博客

12-03

591

对于返回值的，一般作为右值进行获取，所以这个过程中应该是不变动内部的值对于返回引用的，一般作为左值进行赋值，所以不能采用const修饰 float operator[] (const size_t i) const{ return *(&x+i); } float& operator[] (const size_t i){ return *(&x+i); } ...

不设置静态变量判断一个静态类是否已经初始化

shujianlove0的博客

12-03

387

不用静态变量的话可以增加代码的简洁度，采用静态函数代替,由于返回的是引用，所以该函数可以直接赋值， isStartedUp()=true;其次由于静态变量在函数块内部只初始化一次并存在，所以可以一直使用 /** Checks has the Module been started up. */ static bool&amp; isStartedUp() { static bool inst =...

用C++来解决，请设计一个类，只能在堆上创建对象

最新发布

04-01

<think>好的，用户想设计一个C++类，使得该类的对象只能在堆上创建。我需要回忆一下相关的知识，并参考提供的引用资料来给出正确的实现方法。首先，C++中对象的创建有两种方式：栈上（静态创建）和堆上（动态分配）。栈上的对象通过直接声明，比如`A a;`，而堆上的对象则使用`new`操作符，比如`A* ptr = new A();`。要限制对象只能在堆上创建，就必须阻止用户在栈上创建对象。根据引用[1]和[2]，通常的做法是将析构函数设为私有或者受保护。因为当对象在栈上创建时，编译器会在作用域结束时自动调用析构函数。如果析构函数不可访问（比如私有），那么栈上对象的创建会导致编译错误。但是，这样做之后，用户也无法直接使用`delete`来释放堆上的对象，所以需要提供一个公共的销毁方法，比如`destory()`，内部调用`delete this`。或者，可以将析构函数设为私有，并提供一个公有的`delete`方法。另外，引用[3]提到，还有一种方法是重载`new`和`delete`操作符，但可能不太常见。不过更常见的是控制构造函数和析构函数的访问权限。可能的步骤： 1. 将析构函数设为私有或受保护，阻止栈上的自动析构。 2. 提供静态的创建方法，返回堆对象的指针，比如`create()`方法，内部调用`new`。 3. 确保用户无法直接调用构造函数，所以构造函数也需要设为私有或受保护。 4. 可能需要禁用拷贝构造和赋值操作，避免通过其他方式创建对象。例如，类A的构造函数和析构函数设为私有，然后提供一个静态的create函数，返回A*。这样用户只能通过A::create()来生成对象，而无法直接实例化或者在栈上创建。还需要考虑拷贝的问题，防止用户复制对象导致意外创建。因此，应该将拷贝构造函数和赋值运算符声明为删除或者私有，并不予实现。参考引用[3]中的例子，正确的做法是析构函数私有，构造函数公有的话可能有问题？或者构造函数也设为私有，然后通过静态成员函数来创建对象。可能存在的矛盾点：如果构造函数是私有的，那么用户无法直接调用new，因为new会调用构造函数，但构造函数不可访问。所以这时候必须通过一个静态成员函数来调用new，因为静态成员函数可以访问私有构造函数。因此，正确的做法应该是： - 构造函数设为私有或受保护。 - 析构函数设为私有或受保护。 - 提供公共的静态成员函数来创建对象，返回指针。 - 提供公共的销毁方法，或者重载operator delete，但更常见的是提供一个destroy函数。例如： class HeapOnly { public: static HeapOnly* create() { return new HeapOnly(); } void destroy() { delete this; } private: HeapOnly() {} ~HeapOnly() {} }; 这样用户只能通过HeapOnly::create()来创建对象，而无法在栈上构造，因为构造函数和析构函数都是私有的。同时，用户必须调用destroy来释放对象，或者可以结合智能指针来管理。此外，还要防止用户通过拷贝构造函数或赋值操作来创建对象，所以需要将拷贝构造函数和赋值运算符设为删除或者私有。可能还需要禁用移动构造函数等，但根据C++11后的标准，可以显式地删除这些函数。总结步骤： 1. 私有构造函数和析构函数。 2. 静态工厂方法创建对象。 3. 公共销毁方法。 4. 禁用拷贝和赋值。这样就能确保对象只能在堆上创建。另外，引用[2]中提到，可以通过将析构函数私有化，这样栈对象无法自动析构，导致编译错误。而堆对象需要用户自己调用delete，但由于析构函数不可访问，所以必须提供一个public的destroy方法，里面执行delete。例如： class HeapOnly { public: void destroy() { delete this; // 需要析构函数可访问，所以析构函数需要是public？或者destroy是成员函数，可以访问私有析构函数？ } private: ~HeapOnly() {} }; 但这样的话，构造函数如果是public，用户仍然可以在栈上创建对象，但无法析构，导致编译错误。但构造函数如果是public，用户可以在栈上构造对象，但无法析构，所以在编译阶段就会报错。比如用户写HeapOnly obj; 会触发构造函数，而当离开作用域时，编译器尝试调用析构函数，但因为是私有的，所以报错。这样构造函数可以是public的，但析构函数是私有的。但这样用户无法直接调用析构函数，所以无法delete，必须通过destroy方法。不过，此时用户仍然可以调用new HeapOnly()，但无法delete，所以必须通过destroy函数。但这种方法的问题在于，构造函数如果是public的，用户还是可以在栈上创建对象，尽管析构时会失败。所以更安全的方法是将构造函数设为私有，这样无论是栈还是堆，用户都无法直接构造对象，必须通过静态方法创建。所以正确的做法应该是： 构造函数和析构函数都设为private，然后提供静态方法创建对象，并提供一个destroy方法。例如： class HeapOnly { public: static HeapOnly* create() { return new HeapOnly(); } void destroy() { delete this; } private: HeapOnly() {} ~HeapOnly() {} }; 这样用户无法在栈上创建对象，因为构造函数不可访问。也无法直接调用new HeapOnly()，因为构造函数是私有的，只能通过静态方法create来创建对象。此时，用户必须通过HeapOnly* obj = HeapOnly::create(); 来创建对象，然后通过obj->destroy()来释放。这种情况下，拷贝构造函数和赋值运算符应该被禁用，否则用户可能通过拷贝创建栈对象。例如： HeapOnly* obj1 = HeapOnly::create(); HeapOnly obj2 = *obj1; // 调用拷贝构造函数，但如果是私有的，就会报错。因此，需要将拷贝构造函数和赋值运算符设为private或者delete： class HeapOnly { public: static HeapOnly* create() { return new HeapOnly(); } void destroy() { delete this; } // 删除拷贝构造函数和赋值运算符 HeapOnly(const HeapOnly&) = delete; HeapOnly& operator=(const HeapOnly&) = delete; private: HeapOnly() {} ~HeapOnly() {} }; 这样，用户无法通过拷贝来创建对象，进一步确保只能在堆上创建。总结：通过私有构造函数和析构函数，静态工厂方法，以及禁用拷贝构造和赋值，可以实现类只能在堆上创建对象。另外，引用[3]中的方法可能也是类似的，所以最终的实现应该是这样的结构。</think>要设计一个C++类使其对象只能在堆上创建，核心思路是**限制栈对象的构造和析构**，具体实现步骤如下： --- ### 一、禁用栈上构造的3个关键步骤 1. **私有化析构函数** 当析构函数不可访问时，编译器会阻止栈对象的自动析构[^2]。例如： ```cpp class HeapOnly { private: ~HeapOnly() {} // 析构函数私有化 }; ``` 此时声明栈对象`HeapOnly obj;`会因无法调用析构函数而编译报错。 2. **提供静态工厂方法** 通过静态成员函数`create()`动态创建堆对象，并返回指针： ```cpp class HeapOnly { public: static HeapOnly* create() { return new HeapOnly(); // 调用私有构造函数 } private: HeapOnly() {} // 构造函数私有化 ~HeapOnly() {} }; ``` 用户只能通过`HeapOnly* obj = HeapOnly::create();`创建对象。 3. **禁用拷贝和赋值操作** 通过`= delete`禁止拷贝构造函数和赋值运算符，防止通过拷贝创建对象： ```cpp class HeapOnly { public: // ...其他代码 HeapOnly(const HeapOnly&) = delete; HeapOnly& operator=(const HeapOnly&) = delete; }; ``` --- ### 二、完整代码示例 ```cpp class HeapOnly { public: static HeapOnly* create() { return new HeapOnly(); } void destroy() { delete this; // 手动释放堆对象 } // 禁用拷贝和赋值 HeapOnly(const HeapOnly&) = delete; HeapOnly& operator=(const HeapOnly&) = delete; private: HeapOnly() = default; // 构造函数私有 ~HeapOnly() = default; // 析构函数私有 }; ``` --- ### 三、使用方法 1. **创建对象** ```cpp HeapOnly* obj = HeapOnly::create(); // 正确：堆上创建 ``` 2. **销毁对象** ```cpp obj->destroy(); // 正确：调用私有析构函数 ``` 3. **禁止的操作** ```cpp HeapOnly obj1; // 错误：构造函数私有 HeapOnly obj2(*obj); // 错误：拷贝构造函数被删除 HeapOnly* obj3 = new HeapOnly(); // 错误：构造函数私有 ``` --- ### 四、原理解析 1. **栈对象限制** 栈对象在生命周期结束时需要自动调用析构函数，而私有析构函数阻止了这一过程。 2. **堆对象控制** 通过静态工厂方法`create()`，将构造过程封装在类内部，确保用户只能通过`new`创建对象[^3]。 3. **内存管理** 提供`destroy()`方法替代直接`delete`操作，解决私有析构函数导致的释放问题。 ---