C++ 通过使用不同的构造函数创建对象，并最终释放对象的内存

我有以下代码：

#include <iostream>
#include <cstring>

using namespace std;

// Class declaration
class NaiveString {
    private:
        char *str;

    public:
        NaiveString(const char*);
        NaiveString(const NaiveString&);
        void update(char, char);
        void print();
};

// Constructors
NaiveString::NaiveString(const char* t) {
    str = new char[strlen(t) + 1];
    strcpy(str, t);
    cout << "First constructor is being invoked." << endl;
}

NaiveString::NaiveString(const NaiveString& src) {
    str = new char[strlen(src.str) + 1];
    strcpy(str, src.str);
    cout << "Second copy constructor is being invoked." << endl;
}

// Methods
/* The following method replaces occurrences of oldchar by newchar */
void NaiveString::update(char oldchar, char newchar) {
    unsigned int i;
    for (i = 0; i < strlen(str); i++) {
        if (str[i] == oldchar) {
            str[i] = newchar;
        }
    }
}

/* The following method prints the updated string in the screen */
void NaiveString::print() {
    cout << str << endl;
}

// Function
void funcByVal(NaiveString s) {
    cout << "funcbyval() being called" << endl;
    s.update('B', 'C');
    // Printing the results
    s.print();
}

int main() {

    NaiveString a("aBcBdB");
    a.print();

    NaiveString b("test, second object");
    b.print();

    cout << "About to call funcbyval(): " << endl;
    // Calling funcByVal
    funcByVal(a);

    // Printing the results
    a.print();


    return 0;
}

#包括
#包括
使用名称空间std；
//类声明
类字符串{
私人：
char*str；
公众：
字符串（常量字符*）；
NaiveString（const NaiveString&）；
无效更新（char，char）；
作废打印（）；
};
//建设者
NaiveString:：NaiveString（常量字符*t）{
str=新字符[strlen（t）+1]；
strcpy（str，t）；
库特
我怎样才能让他们使用不同的构造函数呢

那是不必要的。你为什么认为你需要它

另外，如何创建并调用该funcByRef（）

网络上有很多资源描述了如何在C++中引用引用。
最后，如何在程序结束时释放对象占用的内存

无需执行任何操作。将为每个对象调用析构函数，这将释放所有内存。这在您的类中尚未执行。有关详细信息，请参阅

我怎样才能让他们使用不同的构造函数呢

那是不必要的。你为什么认为你需要它

另外，如何创建并调用该funcByRef（）

网络上有很多资源描述了如何在C++中引用引用。
最后，如何在程序结束时释放对象占用的内存

无需执行任何操作。将为每个对象调用析构函数，这将释放所有内存。这在您的类中尚未完成。有关详细信息，请参阅。
如果要调用第二个构造函数，但要向其传递一个char*，则需要传递一个NaiveString&如下所示

NaiveString a("aBcBdB");
a.print();

NaiveString b(a);   // a is a NaiveString reference here
b.print();

这就是funcByRef（）的用法，只需通过引用传递即可

void funcByRef(NaiveString& s){
    s.update('B', 'C');
    s.print();
}

最后，要释放字符串，需要创建一个类似于此的析构函数

NaiveString::~NaiveString()
{
    delete[] str;
}

您想调用第二个构造函数，但要向其传递char*，需要传递一个字符串&如下所示

NaiveString a("aBcBdB");
a.print();

NaiveString b(a);   // a is a NaiveString reference here
b.print();

这就是funcByRef（）的用法，只需通过引用传递即可

void funcByRef(NaiveString& s){
    s.update('B', 'C');
    s.print();
}

最后，要释放字符串，需要创建一个类似于此的析构函数

NaiveString::~NaiveString()
{
    delete[] str;
}

我怎样才能让他们使用不同的构造函数呢

为了调用不同的构造函数，必须重载它们，这可以通过使用不同的参数列表来实现

例如，在类中，有两个不同的构造函数，其中一个接收字符串，另一个接收对对象的引用

因此，您可以通过向这些构造函数传递不同类型的参数来调用它们中的任何一个

另外，如何创建并调用该funcByRef（）

我设想funcByRef应该接收对对象的引用，例如

void funcByRef(NaiveString& s)
{
    s.update(A,B);
    s.print();
}

最后，如何在程序结束时释放对象占用的内存

首先，您不需要释放内存，因为您的程序已经完成，整个内存堆栈都将被释放。但是，我假设这是某种赋值，因此，为了释放内存，您应该调用
delete
。如中所示：

delete a;
delete b;

但是，请注意，
delete
调用未定义的类的析构函数。默认析构函数可能会丢失char数组。因此，在析构函数中，必须从该数组中释放内存。我会说：

~NaiveString()
{
    delete str;
}

我怎样才能让他们使用不同的构造函数呢

为了调用不同的构造函数，必须重载它们，这可以通过使用不同的参数列表来实现

例如，在类中，有两个不同的构造函数，其中一个接收字符串，另一个接收对对象的引用

因此，您可以通过向这些构造函数传递不同类型的参数来调用它们中的任何一个

另外，如何创建并调用该funcByRef（）

我设想funcByRef应该接收对对象的引用，例如

void funcByRef(NaiveString& s)
{
    s.update(A,B);
    s.print();
}

最后，如何在程序结束时释放对象占用的内存

首先，您不需要释放内存，因为您的程序已经完成，整个内存堆栈都将被释放。但是，我假设这是某种赋值，因此，为了释放内存，您应该调用
delete
。如中所示：

delete a;
delete b;

但是，请注意，
delete
调用未定义的类的析构函数。默认析构函数可能会丢失char数组。因此，在析构函数中，必须从该数组中释放内存。我会说：

~NaiveString()
{
    delete str;
}

阅读有关复制构造函数（您的第二个构造函数）的内容。此外，不要忘记添加析构函数以删除str。我想您需要详细了解构造函数和析构函数。但是，只需添加析构函数即可解决问题。与构造函数不同，只有一个析构函数。阅读有关复制构造函数（您的第二个构造函数）的内容另外，不要忘了添加析构函数来删除str。我想你需要详细了解构造函数和析构函数。不过，只需添加析构函数就可以解决这个问题。与构造函数不同，只有一个析构函数。str是在堆上分配的，因此类需要一个析构函数来释放它。没错，我错过了构造函数中的新函数r、 谢谢，我会编辑我的答案，因为我的答案是在堆上分配的，所以类需要一个析构函数来释放它。没错，我错过了构造函数中的新答案，谢谢，我会编辑我的答案