在C++中，为了让某个类只能通过new来创建（即如果直接创建对象，编译器将报错），应该（）

最新推荐文章于 2024-08-13 20:37:22 发布
原创 最新推荐文章于 2024-08-13 20:37:22 发布 · 716 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

文章讨论了如何在C++中通过将构造函数设为私有来确保类的对象只能通过`new`创建，避免直接创建对象。同时指出，虽然析构函数设为私有会导致直接创建对象报错，但new创建的实例由于间接内存管理需要自定义释放函数。

在C++中，为了让某个类只能通过new来创建（即如果直接创建对象，编译器将报错），应该（） A. 将构造函数设为私有

B. 将析构函数设为私有

C. 将构造函数和析构函数均设为私有

D. 没有办法能做到

选择B

A、若将构造函数设为私有，则直接创建对象与通过new来创建都不可行，两者都要调用构造函数

B、将析构函数设为私有，直接创建对象会报错，因为最终程序结束前要调用析构函数释放对象。而通过new来创建对象不会报错，虽然析构函数是私有的，但实际对象是存储在类指针类型中的，程序结束时销毁指针的空间不会调用类的析构函数，自然不会报错。但new开辟的空间是没有释放的，所以还需要在类中定义一个成员函数去释放new出来的内存。

精选资源
2.const对象-NULL和nullptr-C++中创建对象数组.docx
11-21
在上面的代码中，我们定义了一个名为myclassA的类，并使用new操作符来创建一个对象。我们还使用delete操作符来释放该对象。 我们还使用了malloc和free函数来分配和释放内存。malloc函数会分配一块内存，但是不会...
C++中如何设计一个类只能在堆或者栈上创建对象
小白的Coding之旅
09-22 849
设计一个类，该类只能在堆上创建对象 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建 注意 在堆和栈上创建对象都会调用构造函数，为了防止在栈上创建对象我们将构造函数私有化。 拷贝构造函数是在栈上创建对象。 class HeapOnly { public: static HeapOnly* CreateOb...
《More Effective C++》条款27：如何让类对象只在栈（堆）上分配空间？
彦祖老师
10-26 9477
昨天一个同学去网易面试C++研发，问到了这么一个问题：如何限制一个类对象只在栈（堆）上分配空间？ 一般情况下，编写一个类，是可以在栈或者堆分配空间。但有些时候，你想编写一个只能在栈或者只能在堆上面分配空间的类。这能不能实现呢？仔细想想，其实也是可以滴。 在C++中，类的对象建立分为两种，一种是静态建立，如A a；另一种是动态建立，如A* ptr=new A；这两种方式是有区别的。
C++ 只能new / 只能定义 的方式生成新对象
ustb_atrx的博客
12-27 1083
// new_delete.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; // 只能定义，不能new class A{ public: A(){ cout << "A()" << endl; } ~A(){ cout << "~A()" << endl; } private:
让类只能用new来创建实例
weixin_30834019的博客
08-03 405
让类只能用new来创建实例 在C++中，类的对象建立分为两种，一种是静态建立，如A a；另一种是动态建立，如A* ptr=new A；这两种方式是有区别的。 1、静态建立类对象：是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数。 2...
【C/C++笔试练习】new和deleted底层原理、静态数据成员、运算符重载、只能使用new创建的类、模版声明、另类加法、走方格的方案数
Crocodile1006的博客
11-02 426
C/C++笔试练习、new和deleted底层原理、静态数据成员、运算符重载、程序分析、静态数据成员、只能使用new创建的类、模版声明、另类加法、走方格的方案数
常见嵌入式面试题之C++基础篇 ——第1期
weixin_44524004的博客
04-06 1487
常见嵌入式面试题之C++基础篇 ——第1期前言第1期问题：1.什么是平衡二叉树2.什么函数不能声明为虚函数？3.队列和栈有什么区别，常见用法及其他延伸4.让类只在堆或栈上创建5.乐观锁与悲观锁6.类外部访问权限7.解决哈希冲突8.map和unordermap的区别9. set和unordered_set10.new和malloc的区别11.什么是平衡二叉树12.局部变量能否和全局变量重名？13.对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现?14.什么是多态（延伸）15.面向接口
工厂模式是一种创建对象的设计模式，使用工厂类来创建对象，而不是直接使用 new 关键字来创建对象。
小秋 AI SLAM 入门实战教程
11-27 1320
通过工厂类来创建对象，可以降低代码中的耦合度，并使得添加新的产品类型更加容易，只需在工厂方法中添加新的创建逻辑即可。这样做的好处是，它可以提高代码的模块化和可扩展性。的含义是：这是一个必须在派生类中实现的虚函数，它返回一个字符串，不会修改对象的状态，并且基类提供的是一个接口而非具体实现。在派生类中声明了一个重写了基类虚函数的成员函数，这个函数返回一个字符串，不会修改对象的状态，并且确保了这是一个重写基类中相应虚函数的正确声明。是一个成员函数的声明，它出现在派生类中，并重写了基类中声明的虚函数。
c++使用new和不使用new创建对象的区别
m0_49634090的博客
02-16 879
c++使用new和不使用new创建对象的区别以及二叉搜索树插入
【C++】特殊类设计 — 不能被拷贝的类 ， 只能在堆/栈上创建对象的类 ，不能被继承的类
叫我龙翔的博客
08-13 1171
本文讲解了一些特殊的类设计：不能被拷贝的类， 只能在堆/栈上创建对象的类 ，不能被继承的类！通过实践场景生动讲述！
C++设计一个类：只能在堆上创建对象、只能在栈上创建对象、只能创建一个对象
cherrydreamsover的博客
08-23 3902
在C++中，创建类的对象有两种方法，一种是静态建立，A a; 另一种是动态建立，调用new 操作符。 一、只能在堆上创建对象 就是动态建立类的对象，使用new操作符来完成。 做法一：将该类的构造函数和析构函数权限设为protected，(可以让该类可以被继承)，然后定义两个static 函数来调用new ，delete 来创建和销毁对象。 class A { protected: ...
C++两种方式创建对象(new和申明)
yanghuidang
11-13 710
环境：VS2010 问题： 1.如何让一个类的对象只能够在堆上创建（即使用new创建，如：T *p=new T;）， 而不能在栈上创建（即直接申明方式，如：T t;）; 2.如何让一个类的对象只能够在栈上创建（即直接申明方式，如：T t;），而不能在堆上创建（即使用new方式，如：T *p=new T;）; 解决： 1.只能使用new创建，而不能使用申明明方式，只需要把类T的析构函数设为...
【每日一练】---- 3.02 3.03 3.04oj总结（类知识点）
m0_52751535的博客
03-09 1016
new与delete的功能 问题：为了让某个类只能通过new来创建（即如果直接创建对象，编译器将报错），应该（） A. 将构造函数设为私有 B. 将析构函数设为私有 C. 将构造函数和析构函数均设为私有 D. 没有办法能做到 new一个对象时，本质是： 申请一块空间给这个对象 调用该对象的构造函数去初始化这块空间 显然若将构造函数设为私有则无法通过new来创建对象。 delete一个对象的本质是： 调用该对象的析构函数 回收分配给该对象的空间 那么将析构函数设为私有，有办法回收.
c++基础知识回顾
wenge1988的博客
08-31 428
1、在类的继承机制中，父类的析构函数要设置成虚析构函数 父类指针绑定子类对象，若父类中析构函数不是虚函数，则静态编译，只会调用父类的析构函数不会调用子类的析构函数，所以会造成内存泄露！ 若父类析构函数为虚函数，则指针会动态编译，调用子类的析构函数，调用子类的析构函数后会自动调用父类的析构函数。（子类对象创建会自动调用父类的构造函数，先调用父类的构造函数！子类析构函数调用完成后会自动调用父类的析
c++new失败处理
sjhuangx的专栏
03-29 1791
在C语言中如果malloc/calloc分配内存失败的时候，会返回一个空指针，但是在Ｃ＋＋中使用 new 分配内存的时候，标准规定new分配失败时会抛出异常，因此不能使用如下的方式判断new是否成功， int *p = new int[SIZE]; if(NULL == p) { return; } 如果分配失败，则以上代码将是没有意义的，因为new失败是会抛出bad_alloc异常，
C++ new失败的处理
weixin_30896825的博客
07-06 791
总体分两个部分，一个是：http://hi.baidu.com/bellgrade/item/179ff5374b74eef6e7bb7aa6写的比较容易理解。 另一个是 http://book.51cto.com/art/201202/317767.htm有具体代码说明，更具体。 ————————————————————————————————————————————————————...
【笔试题】【day9】
芊樱烛渊的博客
10-21 364
C++语言中，类ClassA的构造函数和析构函数的执行次数分别为（）A 5,1B 1,1C 5,5D 1,5一定要匹配使用，否则程序可能会产生内存泄漏，程序可能会崩溃如果是new T：1.调用operator new(size)申请空间内部其实是用malloc循环申请2.调用T的构造函数对申请的空间进行初始化delete p：1.调用析构函数释放p指向对象中的资源。2.调用operator delete释放p所指向的空间内部是调用free的。
C++ 笔试题集锦（1）
一只程序猿
03-09 7087
本篇Blog旨在收集平时遇到的一些“稀奇古怪”的面试题。 问题1问题表述： 在C++中，为了让某个类只能通过new来创建（即如果直接创建栈上对象，编译器将报错），应该如何做？解析： 将析构函数设为私有。 因为new的过程中，编译器不会检测析构函数是否可访问，但要注意的是，这将导致不能调用delete删除该对象所占用的内存，所以需要在该类的内部自己增加一个成员函数，在该自
牛客网练习题整理（1）
咸鱼梦想
02-18 711
（1）关于浮点型double 以下数字在表示为double（8字节的双精度浮点数）时存在舍入误差的有（）。 2的平方根 10的30次方 0.1 0.5 100 A. 2的平方根，本身就是无限小数，因此肯定有舍入误差 B. 10的30次方，明显超出了double的数据存储范围，故有舍入误差 C. 0.1不能用2的负整数次方来表示，因此有误差 D.0.5 = 2^...
用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`操作，解决私有析构函数导致的释放问题。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值