Question

我有以下代码：

#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;
}

以上代码的问题：

基于上面的源代码，实现该方法 funcByref（）。然后在你的主要 function使用不同的构造函数创建至少两个对象，调用funcByVal（），funcByRef（），并在屏幕上打印结果。然后确保对象占用的内存将是在该计划结束时发布。

我创建了2个对象，但它们当前使用的是相同的构造函数。我该怎么做才能使用不同的构造函数？另外，我如何创建funcByRef（）并调用它？最后，如何在程序结束时释放对象占用的内存？

期待您的回答。

谢谢

Answer 1

我该怎么做才能使用不同的构造函数？

这不是必要的。为什么你认为你需要那个？

另外，我如何创建funcByRef（）并调用它？

Web上有很多资源描述了如何通过C ++中的引用传递。请参阅functions in c++ call by value and call by reference作为示例。

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

无所事事。将为每个对象调用析构函数，该对象应释放任何内存。你班上还没有这样做。有关详细信息，请参阅What is The Rule of Three?。

Answer 2

你想调用第二个构造函数，但是你要传递一个char *，你需要传递一个NaiveString＆amp;像这样

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;
}

Answer 3

我该怎么做才能使用不同的构造函数？

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

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

因此，您可以通过向其传递不同类型的参数来调用其中一个构造函数。

另外，我如何创建funcByRef（）并调用它？

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

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

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

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

delete a;
delete b;

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

~NaiveString()
{
    delete str;
}

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

3 个答案: