C++设计一个只能在栈上创建对象的类

最新推荐文章于 2021-05-21 19:45:33 发布

原创最新推荐文章于 2021-05-21 19:45:33 发布 · 177 阅读

0 ·

CC 4.0 BY-SA版权

C++ 专栏收录该内容

66 篇文章

订阅专栏

本文介绍了两种在C++中限制对象仅能在栈上创建的方法：一是通过将构造函数设为私有并提供公有静态方法；二是重载并删除new操作符。这两种方法有效地防止了对象在堆上的创建。

只能在栈上创建对象的类

方式一:

构造函数私有
提供一个公有的静态的栈上创建对象的方法

class StackOnly
{
public:
 static StackOnly getInstance()
 {
  return StackOnly();
 }
private:
 StackOnly(){};
};

void creatStackOnly()
{
 StackOnly so = StackOnly::getInstance();
}

方式二:

把operator new函数声明为delete函数

class StackOnly2
{
public:
StackOnly() {}
private:
void* operator new(size_t n) = delete;
};

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

loreal8

关注关注

0
点赞
踩
0

收藏

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

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

C++只能在栈上或者堆上创建对象

我不是码农的博客~~~

11-22

685

只能在堆上创建对象 C++中存放变量的地方有三个，分别是全局/静态变量存储区，局部变量存储区即栈，new存放的变量存放在堆上，解题的思路是：如果只在栈上创建对象则禁止在堆上创建，重写operator new 和operator delete 如果只在堆上创建对象则把析构函数定义为私有的，但是一定要定义一个函数把new的对象删除掉 void distory () const { delete this; } #include <iostream> using namespac

C++实现一个只能在堆/栈上创建对象的类

imp0128的博客

05-16

1298

C++实现一个只能在堆/栈上创建对象的类1.C++中类对象的创建2.设计一个类，该类只能在堆上创建对象3.设计一个类，该类只能在堆上创建对象 1.C++中类对象的创建在C++中，类的对象创建可以静态创建在栈区, 如A a；还可以动态创建在堆区，如A* ptr=new A；这两种方式是不同的。静态建立一个类的对象，是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数。动态建立类对象，是使用new运算

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

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

Horizon_wing的博客

03-10

3504

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

【C++】只能在堆（栈）上创建对象的类

yulong__li的博客

12-02

277

1.请设计一个类，该类只能在堆上创建对象 #include <iostream> using namespace std; class Test { public: static Test* CreateInstance(int date) { return new Test(date); } private: Test(int d...

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

爱上小公举

10-23

1939

目录只能在堆上生成对象的类只能在栈上生成对象的类在C++中，类的对象创建可以静态创建在栈区, 如A a；还可以动态创建在堆区，如A* ptr=new A；这两种方式是不同的, 具体来静态建立一个类的对象，是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数。动态建立类对象...

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

小白的Coding之旅

09-22

849

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

c++如何控制对象的创建方式（禁止创建栈对象or堆对象）和创建的数量

08-18

禁止创建栈对象意味着只能在堆上创建对象。可以将析构函数声明为private，以限制栈对象的生成。但是，如果将构造函数也设为私有，那么我们也不能用new来直接产生堆对象了。最佳的方法是将析构函数声明为private，而...

如何定义一个只能在堆/栈上生成对象的类？

shanghx_123的博客

01-15

1244

C++中，建立对象可以分为两种，一种是在栈上，一种是在堆上。在栈上成为静态建立，而后者成为动态建立。静态建立一个累的对象，是由编译器自动为对象在栈空间中分配内存，然后调用该对象的构函数形成一个对象，这种方法是直接调用类的构造函函数。动态建立对象，则是通过new运算符在堆上建立对象。具体步骤是：先执行operator new（）函数，在堆上先开辟一段空间；然后然后调用构造函数进行初始化。这种方法...

C++定义一个只能在堆上（栈上）生成对象的类

鸟恋旧林的博客

07-26

1679

如何定义一个只能在堆上（栈上）生成对象的类? 1.C++中类的对象如何建立？（1）静态建立class A{ ... };A a;静态建立一个类的对象，编译器为该对象在栈中分配内存，通过直接移动栈顶指针，挪出适当空间；然后调用类的构造函数形成一个栈上的对象。注意：直接调用类的构造函数。当销毁对象时，调用类的析构函数。（2）动态建立动态建立类对象，使用new运算符将对象简历在堆空间中。class

【C++】设计一个类，只能在栈(堆)上创建对象

Cheng_913的博客

07-17

416

设计一个类，只能在栈上创建对象 使用new运算符，对象会建立在堆上，也就是说只要不用new去创建对象就可以实现，我们知道new和delete分别调用了operator new和operator delete，如果我们把这两个函数声明为私有的，操作符new就不能用了。 class A { public: A() { cout << "A()" <...

设计一个C++类,要求该类只能在栈(堆)上创建或者只有一个对象

Keep Moving~

01-16

1086

类只能在栈上创建我们知道一个对象可在堆上创建或者栈上创建，c++中创建一个堆对象需要使用new运算符才可以，因为malloc不会调用构造和析构函数。因此想要达到该类只能在栈上创建，需要屏蔽new/delete运算符。我们将new/delete设置为private属性，我们在类外就无法调用该运算符，也就达到了这个类只能在栈上创建的效果。 //如何设计类只能建立在栈 class CClassIns...

[C++系列] 41. 详解OJ---请设计一个类，该类只能在栈上创建对象

Y-puyu 的博客

04-22

593

1）不论是只能在堆上创建对象、只能在栈上创建对象，构造函数必须得封死。如果不封死构造函数，在任何地方均可创建对象，包括在类外也能够创建对象。 class Stack { private: Stack(){} // 封死构造函数 }; int main() { system("pause"); return 0; } 2）现在也无法再任何地点创建对象...

C++ 中只能在堆或栈上创建的对象

binling的专栏

01-06

582

1.只能在堆上创建的对象 1) 把析构函数声明为private 2)定义一个destroy()函数，用这个函数来delete对象， void destroy() { delete this; } 2.只能在栈上创建的对象 1）覆盖operator new 和 operator delete 为priavate

建立一个栈类

laocooon的博客

05-21

262

class Empty(Exception): pass class ArrayStack: def __init__(self): self._data = [] def __len__(self): return len(self._data) def is_mepty(self): return len(self._data) == 0 def push(self, e): self._.

C++如何只在堆上或者栈上生成对象

only_do_IT

09-06

1570

这个是个面试题，不知道的时候确实会一比较懵；那么具体如何实现呢？栈和堆这两种内存的使用想象大家都了解吧，栈一般是静态建立一个对象的时候会有编译器自动创建，而堆是需要调用new来达到目的的。首先若是不能调用new，那么就无法在堆上生成对象了，那么...，我们重载一下operator new以及operator delete 置为私有部分，类外就无法调用new来在堆上生成对象了，所以只

C++中的几个特殊类(在堆上，栈上创建对象)

weixin_42357849的博客

07-25

651

1. 设计一个类只能在堆上创建对象。实现方式：（1）将类的构造函数，拷贝构造函数设置为私有，防止别人调用，防止别人调用拷贝在栈上生成对象。（2）提供静态成员函数，在函数中完成堆对象的创建。 class Base { private: Base() {} Base(const Base&) { } Base(const Base& a) = delete;//C++11的做法； public: static Base* fun() { return new Ba

创建栈

北街lhy的博客

03-24

1282

用C语言创建一个栈

weixin_51275821的博客

05-08

7970

非常感谢我浪哥手把手教会我建栈下面的代码只是建立一个栈而已利用栈实现二进制与十进制的转化，请看这篇超详细的博文首先定义一个结构体叫做sqstack，这个结构体中的数据包含一个top指针，和一个base指针，还有这个结构体本身的大小，其实就是栈的定义 typedef struct { Elemtype *top; Elemtype *base; int stacksize; }sqstack; 对栈进行初始化，给栈分配一个存储空间，在未存储数据时，栈顶指针与栈底指针重合 int initsta

C++：设计一个类，只在堆上 / 栈上创建对象

ETalien_的博客

03-06

403

设计一个类，只在堆上创建对象 class HeapOnly { public: static HeapOnly* GetHeapObj() { return new HeapOnly; } private: //构造函数私有 HeapOnly() {} //C++98：拷贝构造函数只声明不实现,并且声明成私有的 HeapOnly(const HeapOnly&amp;); /...

用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`操作，解决私有析构函数导致的释放问题。 ---