C++ 从私有类变量释放内存 #包括 #包括 #包括 使用名称空间std； 类myClass{ 公众： int*num1； myClass（）； }; myClass:：myClass（）{ num1=新整数[1]； num1[0]=10； } int main（） { myClass*myClass； myclass=新的myclass[10]； cout

在类中创建一个函数，处理其私有成员的删除，可能称为

FreeMem（int-index）

但是老实说，在这种程序中不使用析构函数释放对象的内存是危险的，而且是非常糟糕的做法。我建议释放析构函数中的内存，因此当对象终止时，它会释放内存

void myClass::FreeMem()
{
    delete [] num1
}

另一件需要注意的事情是，如果您只在动态变量中创建一个值，那么将其编写为：

myClass::~myClass()
{
    delete [] num1;
}

---

除其他事项外，您的程序中存在许多缺陷。我建议您重新阅读类。

您不能仅删除使用

new

new

创建的数组的一部分。该数组分配了一块只能一起删除的内存

如果你想让一个对象释放它自己的内部数据，你就必须安排这个类，这个类应该封装并隐藏它自己的内部资源

如果您想要一个较小的内存块来保存分配的数组，则必须分配一个较小的内存块，并将希望保留的内容移动到新的内存块中，然后删除整个旧的内存块：

int * pnum = new int;
//or in your class..
pnum = new int;

---

你需要设计你的类来管理它自己的资源，并处理复制或移动。你当前的

myClass

分配了一个数组，但依赖于其他代码来处理清理。这不是一个好方法，因为通常没有其他代码可以做正确的事情，即使你可以，你也可以这样做经常犯错误

由于您在构造函数中分配，需要一个处理解除分配的析构函数。然后，既然实现了三个特殊操作之一（复制cTor、复制赋值、析构函数），则需要考虑将它们全部实现。（这被称为“三个规则”。在C++11中，通过添加移动因子和移动赋值，它变成了“五个规则”。）

您可以像以前一样实现构造函数，也可以使用初始值设定项列表和C++11统一初始化：

class myClass {
public:
    myClass();

    // destructor to handle destroying internal resources correctly
    ~myClass();

    // copy constructor and copy assignment operator, to handle copying correctly
    myClass(myClass const &rhs);
    myClass &operator=(myClass const &rhs);

    // move constructor and move assignment operator, to handle moves correctly (C++11)
    myClass(myClass && rhs);
    myClass &operator= (myClass &&rhs);

private:
   int *num1; // private so external code can't screw it up

public:
   // limited access to num1
   int size() const { if (num1) return 1; else return 0; }
   int &operator[] (size_t i) { return num1[i]; }
};

现在，你想要的析构函数取决于你想要的类的语义，以及你想要维护的特定不变量。“值”语义是C++中的规范（如果你熟悉java或C语言），这些语言鼓励或要求用户定义类型的“引用”语义。。如果您想要值语义，并且如果您维护num1始终拥有内存或为null的不变量，则可以使用此析构函数

myClass::myClass() : num1(new int[1]{10}) {}

复制和移动可以用不同的方式处理。如果你想完全禁止它们，你可以说（在C++11中）：

或者，如果希望允许复制和/或移动（并维护上述值语义和不变量），则可以实现以下两对函数中的一对或两对：

myClass::myClass(myClass const &rhs) = delete;
myClass &myClass::operator=(myClass const &rhs) = delete;

myClass::myClass(myClass && rhs) = delete;
myClass &myClass::operator= (myClass &&rhs) = delete;

使用此实现，您现在可以像对待

int

或任何其他“值”类型一样对待myClass对象。您不再需要担心管理其内部资源；它将自己处理这些资源

myClass::myClass(myClass const &rhs) : num1( rhs.size() ? new int[1]{rhs[0]} : nullptr) {}
myClass &myClass::operator=(myClass const &rhs) {
    if (num1)
        num1[0] = rhs[0];
}

myClass::myClass(myClass && rhs) : num1(rhs.num1) { rhs.num1 = nullptr; } // remember to maintain the invariant that num1 owns the thing it points at, and since raw pointers don't handle shared ownership only one thing can own the int, and therefore only one myClass may point at it. rhs.num1 must be made to point at something else...
myClass &myClass::operator= (myClass &&rhs) { std::swap(num1, rhs.num1); } // steal rhs.num1 and leave it to rhs to destroy our own num1 if necessary. We could also destroy it ourselves if we wanted to.

intmain（）{
std:：vector myclassvec（10）；
你不能只删除第一个实例吗？你有一个
delete
用于每个
new
。你可以释放内存块，而不是对象。使用
delete[]myClass
来释放所有内存和其中的每个对象。作为一个附带问题，
myClass
有自己的漏洞。你需要
delete[]DUT1中的NUM1；。另一个方面的问题是：如果你不熟悉C++，请注意，可以使用堆栈分配的对象和集合（向量、地图等）来完成大多数事情。当然可以。这样做可以使您的代码100x更安全。您通常不需要调用
new
。我的程序有点太深，无法修复此设计。但是您的FreeMem（）建议会起作用的，谢谢。好的，它似乎在我上面的小程序中起作用。但是当我在我的主程序中尝试它时，我发现***glibc检测到***错误。=/@user1773070您的代码可能是双重释放的，因为您没有设计
myClass
来正确管理自己的资源，包括复制。
myClass::~myClass() { delete num1; }

myClass::myClass(myClass const &rhs) = delete;
myClass &myClass::operator=(myClass const &rhs) = delete;

myClass::myClass(myClass && rhs) = delete;
myClass &myClass::operator= (myClass &&rhs) = delete;

myClass::myClass(myClass const &rhs) : num1( rhs.size() ? new int[1]{rhs[0]} : nullptr) {}
myClass &myClass::operator=(myClass const &rhs) {
    if (num1)
        num1[0] = rhs[0];
}

myClass::myClass(myClass && rhs) : num1(rhs.num1) { rhs.num1 = nullptr; } // remember to maintain the invariant that num1 owns the thing it points at, and since raw pointers don't handle shared ownership only one thing can own the int, and therefore only one myClass may point at it. rhs.num1 must be made to point at something else...
myClass &myClass::operator= (myClass &&rhs) { std::swap(num1, rhs.num1); } // steal rhs.num1 and leave it to rhs to destroy our own num1 if necessary. We could also destroy it ourselves if we wanted to.

int main() {
    std::vector<myClass> myclassvec(10);

    cout << myclassvec[0][0] << '\n';

    myclassvec.erase(myclassvec.begin()); // erase the first element

    cout << myclassvec[0][0] << '\n'; // access the new first element (previously the second element);
}