c + +不允许栈实例，但允许新删除

Question

基本上我想要的是：

class MyClass{ 
    public: 
     MyClass() = default; 
    // what should I do? 
} 

MyClass mc; // compile time error; 
auto pmc = new MyClass; //OK 
delete pmc; //OK too 

我知道我可以把它堆只能通过隐藏的构造函数（不能现在新的类外）或隐藏的析构函数（现在不能在课程外部删除）或隐藏两者。如果我不想介绍一些新的命名功能，只想要新的旧的删除功能，该怎么办？是否有可能（即使有黑客）？

Answer 1

我 “就像一个智能指针，而不是” 的想法：

#include <iostream> 

class MyClass_ { 
    private: 
    /**/  MyClass_(void) { } 
    /**/ ~MyClass_(void) { } 
    public: 
    void  func(void) const { std::cout << "Hello" << std::endl; } 

    friend class MyClass; 
} ; 

class MyClass { 
    public: 
    /**/  MyClass(void) : p(new MyClass_) { } 
    /**/ ~MyClass(void) { delete p; } 

    // Tricky implementation details follow... 
    // The question in all cases is, who owns the MyClass_ that has been 
    // allocated on the heap? Do you always allocate a new one, and then 
    // copy the guts? (That might be expensive!) Do you change ownership? 
    // Then what about the other MyClass? What does it point to? 
    // Or do you share ownership? Then you need to ref-count so you don't 
    // delete too soon. (And this whole thing turns into an ordinary 
    // shared_ptr<MyClass_>) 

    /**/  MyClass(const MyClass &o) { } 
    /**/  MyClass(MyClass &&o) { } 
    MyClass &operator=(const MyClass &o) { } 
    MyClass &operator=(MyClass &&o) { } 

    MyClass_ * operator->(void) { return p; } 
    const MyClass_ * operator->(void) const { return p; } 

    private: 
    MyClass_ *p; 
} ; 

int 
main(int, char **) 
{ 
    MyClass a;     // this will be destroyed properly 
    MyClass *b = new MyClass; // this will leak if you don't delete it 

    a->func(); 
    (*b)->func(); 

    return 0; 
} 

Answer 2

这听起来像不是你想要的，而是将它包围在另一个类中。通过这种方式，您可以强制将存储分配到堆中，并将这些细节远离API用户。

Answer 3

通常的方法是让你的构造函数private，并添加一些static成员函数（你可以称之为工厂或制作函数）返回一个指针。

，以便类会是什么样子

class MyClass{ 
    private: 
     MyClass() = default; 
    public: 
     static MyClass* make() { return new MyClass; }; 
    // what should I do? 
} 

，你会代码：

auto mc = MyClass::make(); 

其他地方（的new MyClass代替）

等，但要注意的rule of five，并考虑使用（作为MyClass::make的返回类型）<memory> header中的一些smart pointer。

你也可以拥有自己的一元operator ->和operator *和自己variadic templates通过std::make_shared灵感定义自己的智能指针类...

只想好老new和delete

在真正的C++ 11中，这是令人不悦的，可能被认为是糟糕的风格。你应该避免在库外使用明确的new，并采用一些智能指针的编码方式。