关于delete运算符的下列描述中，（）是错误的。 A. 它必须用于new返回的指针； B. 使用它删除对象时要调用析构函数； C. 对一个指针可以使用多次该运算符； D. 指针名前只有一对方括号符号，不管所删除数组的维数。

C. 对一个指针可以使用多次该运算符；是错误的。

delete运算符必须用于new返回的指针，并且使用它删除对象时要调用析构函数。针对一个数组，必须使用delete[]运算符。每个new表达式都应该有一个相应的delete表达式，否则就会产生内存泄漏。对同一个指针使用delete运算符多次是未定义的行为，可能导致程序崩溃。指针名前只有一对方括号符号，但必须在delete[]运算符中使用数组的维数。

相关问题

用c++方法解决下列问题：编写字符串运算符“+=”的重载函数，使运算符“+=”用于字符串的拼接运算，实现字符串的S1+=S2操作运算。分别用友元函数和成员函数实现。

好的，以下是代码示例：

#include <iostream>
#include <cstring>

using namespace std;

class MyString {
private:
    char* str;          // 字符串指针
public:
    MyString(const char* s) {
        str = new char[strlen(s) + 1];
        strcpy(str, s);
    }
    ~MyString() {
        delete [] str;
    }
    // 友元函数实现
    friend MyString operator+=(MyString& s1, const MyString& s2) {
        char* temp = new char[strlen(s1.str) + strlen(s2.str) + 1];
        strcpy(temp, s1.str);
        strcat(temp, s2.str);
        delete [] s1.str;
        s1.str = temp;
        return s1;
    }
    // 成员函数实现
    MyString& operator+=(const MyString& s) {
        char* temp = new char[strlen(str) + strlen(s.str) + 1];
        strcpy(temp, str);
        strcat(temp, s.str);
        delete [] str;
        str = temp;
        return *this;
    }
    void print() {
        cout << str << endl;
    }
};

int main() {
    MyString s1("Hello"), s2("World");
    s1 += s2;
    s1.print();     // 输出 HelloWorld

    s2 += "!";
    s2.print();     // 输出 World!
    return 0;
}

以上代码定义了一个 MyString 类，其中包含了两个实现“+=”运算符的方法：一个是友元函数，一个是成员函数。在 main 函数中，我们可以看到对于两个 MyString 对象的“+=”操作，都可以实现字符串的拼接运算。

需要注意的是，在代码中我们使用了动态内存分配，需要在适当的时候进行 delete 操作，避免内存泄漏。

逐行分析下列程序，并显示结果：#include <iostream.h> class BASE{ int m_base; public: BASE( int m_b=0 ) { m_base=m_b; cout<<"BASE Constructor! m_base="<<m_base<<endl; } virtual void f(){ cout<<"BASE::f() called!"<<endl; } virtual ~BASE(){ cout<<"BASE Destructor!"<<endl; } }; class DERIVE: public BASE{ int m_derive; public: DERIVE ( int a, int b=1 ):BASE(a) { m_derive=b; cout<<"DERIVE Constructor! m_derive="<<b<<endl; } void f( ) { cout<<"DERIVEL::f() called!"<<endl; } ~DERIVE() { cout<<"DERIVE Destructor!"<<endl; } }; void main() { BASE b[2]; b[0].f(); BASE *pb = new DERIVE(2,3); pb->f(); delete pb; }

这是一个 C++ 程序，包含两个类：BASE 和 DERIVE。

程序的主函数 main() 中定义了一个 BASE 类的数组 b，数组长度为 2，并依次调用了两个 BASE 类的构造函数 BASE()。然后调用了数组 b 的第一个元素的 f() 函数，输出 BASE::f() called!。

接下来，定义了一个指向基类 BASE 的指针 pb，并使用 new 运算符在堆上创建了一个 DERIVE 对象，构造函数 DERIVE() 中调用了基类 BASE 的构造函数 BASE()，并输出了 BASE Constructor! m_base=2 和 DERIVE Constructor! m_derive=3。

接着，通过指针 pb 调用了 DERIVE 类的 f() 函数，输出 DERIVEL::f() called!。

最后，使用 delete 运算符释放了 pb 所指向的内存，并在 DERIVE 类的析构函数 DERIVE::~DERIVE() 中输出了 DERIVE Destructor! 和 BASE Destructor!。

程序的输出结果如下：

BASE Constructor! m_base=0
BASE Constructor! m_base=0
BASE::f() called!
BASE Constructor! m_base=2
DERIVE Constructor! m_derive=3
DERIVEL::f() called!
DERIVE Destructor!
BASE Destructor!
BASE Destructor!