编写C++中的两个类 一个只能在栈中分配空间 一个只能在堆中分配

[feiyun1987]

笔试的大题 想的复杂点吧 兄弟们 去考试的本科生全挂 只有9个研究生过了

[kiffa]

只在栈上的类：
// 私有重载new即可,但只是限制了不能建立在new出的堆上，并没有限制全局以及局部静态类，因此严格
// 来说不能算“只在栈上”
class A
{
    private:
             static   void   *operator   new   (size_t   size){};  
};

只在堆上的类：
// 私有化析构函数，通过一个public函数来进行实际的析构。
class B
{
    public:
            void del()const{ };
    private:
            ~B(){};
};

[帅得不敢出门]

这个more effective c++上有
摘自网上

//HeapOnly.cpp  
  #include   <iostream>  
  using   namespace   std;  
   
  class   HeapOnly  
  {  
  public:  
  HeapOnly()   {   cout   <<   "constructor."   <<   endl;   }  
  void   destroy   ()   const   {   delete   this;   }  
  private:  
  ~HeapOnly()   {}    
  };  
   
  int   main()  
  {  
  HeapOnly   *p   =   new   HeapOnly;  
  p->destroy();  
  // HeapOnly   h;  
  // h.Output();  
   
  return   0;  
  }  
  //StackOnly.cpp  
  //2005.07.18------2009.06.05  
  #include   <iostream>  
  using   namespace   std;  
   
  class   StackOnly  
  {  
  public:  
  StackOnly()   {   cout   <<   "constructor."   <<   endl;   }  
  ~StackOnly()   {   cout   <<   "destructor."   <<   endl;   }  
  private:  
  void*   operator   new   (size_t);  
  };  
   
  int   main()  
  {  
  StackOnly   s;                                                             //okay  
  StackOnly   *p   =   new   StackOnly;                           //wrong  
   
  return   0;  
  }

[Vegertar]

UP

[jia_xiaoxin]

[Quote=引用 2 楼 zmlovelx 的回复:]
这个more effective c++上有
摘自网上

C/C++ code
//HeapOnly.cpp
#include <iostream>
using namespace std;

class HeapOnly
{
public:
HeapOnly() { cout << "constructor." << endl; }
void destroy () const { delete this; }
private:
~HeapOnly() {}
};

int main()
{
HeapOnly *p = …
[/Quote]

支持

[appleshao]

2楼的代码不行的私有的new运算符得通过成员函数来实现.

[MilanSpiRiT]

2楼的代码HeapOnly不是也能在栈中分配空间吗~
StackOnly的意思是把new运算符重写，让他什么也不做吗？

请赐教

[appleshao]

2L的代码应该不全

[czbever]

有没人做一下补充啊　

[重返IT路]

那个 new重载怎么回事？

还有把重载的new 私有化了 MAIN方法怎么又实用到了NEW呢 不明白

[霍大脚]

我是本科生，看来是搞不来了

[Icee_sun]

他的意思是，若有两个类A和B，那么对A来说，无论如何创建他的对象，这些对象总是栈中的数据，而对B，他的所有对象都是堆中的？

[Icee_sun]

若果是这样，那么对AB分别重载new不就行了？

[hityct1]

mark

[sinux_1983]

//只在栈上
class stackonly
{
private:
    void * operator new(size_t Size)
    {
    }
};

//只在堆上
class heaponly
{
private:
    heaponly(){}
    ~heaponly(){}
};

其实道理很简单，前者利用了c++的重载机制+访问控制机制。后者利用了c++的访问控制机制。
前者重载了new运算符，并设为私有，因此，当用 new stackonly；时编译器就会报错。
后者则将构造函数设为私有，因此，当你 heaponly h;时会自动调用构造函数，这时编译器也会报错。

这种技巧在c++中是很常用的比如设计模式中的单件模式。

[wanglikun]

重载了new，就不能用new在堆中申请内存了？
不能实例化h，就能保证只在堆中分配空间了？

[lgccaa]

mark

[aurora001]

class Foo_stack{
~Foo_stack(){
}
};

class Foo_heap{
void* operator new(size_t);
void* operator new[](size_t);
};