#include <iostream> using namespace std; class MyClass{ int val; public: MyClass(int i){ val=i; cout<<"构造函数！\n"; } MyClass(const MyClass &p){ val=p.val; cout<<"拷贝构造函数！\n"; } ~MyClass(){ cout<<"**析构函数\n";} int getval(){ return val;} MyClass MkBigger(){ MyClass o(val*2); //正常构造 return o; //局部变量返回时，复制构造 } }; void display(MyClass ob){ //值传递：发生1次复制构造 cout<<"val="<<ob.getval()<<endl; } int main(){ MyClass a(10); //正常构造 cout<<"调用display()之前.\n"; display(a); cout<<endl; a=a.MkBigger(); cout<<"调用MkBigger()之后.\n"; display(a); cout<<"第2次调用display()之后.\n"; cout<<endl; }怎么输出的，为什么怎么输出

这段代码的输出结果和上一段代码的输出结果是一样的。输出结果为：

构造函数！
调用display()之前.
拷贝构造函数！
val=10
**析构函数

构造函数！
拷贝构造函数！
**析构函数
调用MkBigger()之后.
拷贝构造函数！
val=20
**析构函数
第2次调用display()之后.
**析构函数
**析构函数

这是因为程序中使用了值传递的方式来传递 MyClass 对象，这会导致复制构造函数被调用。在调用 display() 函数时，会发生一次复制构造，因此会输出一次拷贝构造函数的信息。在调用 MkBigger() 函数时，由于局部变量 o 是在函数内部创建的，因此在返回时会发生一次复制构造，也会输出一次拷贝构造函数的信息。

相关问题

#include <iostream> using namespace std; class MyClass { int val; public: MyClass(int i) { val = i; cout << "inside constructor \n"; } int getval() { return val; } ~MyClass() { cout << "Destructor\n"; } }; MyClass MkBigger(MyClass a) { MyClass o(a.getval() * 2); return o; } void display(MyClass ob) { cout << ob.getval() << endl; } void main() { MyClass a(10); cout << "Before calling display().\n"; display(a); a = MkBigger(a); cout << "after display returns.\n"; }这段代码的结果是什么

这段代码的结果输出如下：

inside constructor
Before calling display().
10
inside constructor
Destructor
after display returns.
Destructor

其中，输出的 "inside constructor" 是 MyClass 的构造函数被调用的标志，"Destructor" 是 MyClass 的析构函数被调用的标志。代码中首先创建了一个 MyClass 对象 a，然后调用了 display 函数，display 函数接受一个 MyClass 对象 ob 作为参数，将 ob 的 val 值输出到屏幕上。接着，调用了 MkBigger 函数，该函数接受一个 MyClass 对象 a 作为参数，并返回一个新的 MyClass 对象 o，该对象的 val 值是 a 的 val 值的两倍。在调用 MkBigger 函数时，会先调用一次 MyClass 的构造函数，创建一个临时对象，然后将这个临时对象作为参数传递给 MkBigger 函数。在 MkBigger 函数内部，又会创建一个新的 MyClass 对象 o，然后将这个对象作为返回值返回。在返回值时，会将 o 对象复制一份，即调用复制构造函数，然后将这个复制的对象作为返回值返回。最后，程序结束时会依次调用 a 和 o 对象的析构函数。

#include <iostream> using namespace std; class MyClass { int* p; const int N; public: // ERROR **********found********** MyClass(int val) : N=1 { p = new int; *p = val; } // ERROR **********found********** ~MyClass() { delete *p; } friend void print(MyClass& obj); }; // ERROR **********found********** void MyClass::print(MyClass& obj) { cout << "value = " << *(obj.p) << endl; cout << "number = " << obj.N << endl; } int main() { MyClass obj(63); print(obj); return 0; }

在这段代码中，有三个错误：

1. 在 MyClass 类的构造函数中，使用了 const 成员初始化列表，但是 N 是一个非静态成员变量，不能在初始化列表中初始化。正确的做法是在构造函数的函数体中给 N 赋值。

2. 在 MyClass 类的析构函数中，使用了 delete *p，但是 p 是一个指向 int 的指针，应该使用 delete p。

3. 在 MyClass 类的友元函数 print() 中，应该将其定义为 MyClass 类的成员函数，而不是独立的函数。

下面是修改后的代码：

#include <iostream>
using namespace std;

class MyClass {
    int* p;
    const int N;
public:
    MyClass(int val) : N(1) {
        p = new int;
        *p = val;
    }
    ~MyClass() { delete p; }
    void print() {
        cout << "value = " << *p << endl;
        cout << "number = " << N << endl;
    }
};

int main() {
    MyClass obj(63);
    obj.print();
    return 0;
}