c++期末题库三（读程序写结果）

1.

#include<iostream>
using namespace std;
class BC
{
public:
BC(int n=100){val=n;cout<<"default con."<<endl;}
BC(BC& t){val=t.val;cout<<"Copy con."<<endl;}
BC& operator = (BC&t)
{
val=t.val;
cout<<"Assignment."<<endl;
return *this;
}
private:
int val;

};
void f(BC){}
void main()
{
BC t1(3);
BC t2;
t2=t1;
f(t2);
}

• BC t1(3);
  • 调用带参数的构造函数，val 被赋值为 3，输出 "default con."。
• BC t2;
  • 调用默认构造函数，val 被赋值为 100，输出 "default con."。
• t2 = t1;
  • 调用赋值运算符重载函数，t2 的 val 被赋值为 t1 的 val（即 3），输出 "Assignment."。
• f(t2);
  • 传递 t2 对象作为参数调用 f 函数，传参时会调用拷贝构造函数，输出 "Copy con."。

总结以上分析，程序的输出顺序如下：

default con.
default con.
Assignment.
Copy con.

2.

#include<iostream>
using namespace std;
class BC{
public:
BC(){cout<<"BC's constructor\n";}
~BC(){cout<<"BC's destructor\n";}
};
class DC:public BC{
public:
DC(){cout<<"DC's constructor\n";}
~DC(){cout<<"DC's destructor\n";}
};
int main()
{
DC d;
return0;
}

步骤：

1. 当程序执行到 DC d; 时，首先会调用 DC 类的构造函数。
2. 由于 DC 类继承自 BC 类，所以在 DC 类的构造函数被调用之前，会先调用 BC 类的构造函数。
3. 因此，首先打印出 BC's constructor。
4. 然后打印出 DC's constructor。
5. 当程序执行完 main() 函数并到达 return 0; 时，对象 d 的析构函数会被调用。
6. 首先会调用 DC 类的析构函数。
7. 然后会调用 BC 类的析构函数。

输出结果

BC's constructor
DC's constructor
DC's destructor
BC's destructor

3.

class Pair{
public:
Pair(int a,int b):first(a),second(b){}
void output(){cout<<first<<"AND"<<second;}
int&operator()(int i){
if(i==1)
return first;
else if(i==2)
return second;
else throw string("wrong index");
}
private:
int first;
int second;

};
void main()
{
Pair obj(1,2);
obj(1)=obj(1)+obj(2);
obj.output();
}

1.类Pair的构造函数

构造函数Pair（int a,int b）初始化成员变量first和second，first 被初始化为 a 的值（即 1），second 被初始化为 b 的值（即 2）。

2.类 Pair 的 output 成员函数：

输出成员变量 first 和 second 的值，中间用 " AND " 连接。

3.类 Pair 的 operator() 成员函数：

该函数是一个重载的函数调用运算符，用于返回 first 或 second 的引用，取决于传入的索引 i。

4.main函数

创建一个Pair对象obj,初始化first为1，second为2。调用obj(1) = obj(1) + obj(2);obj(1)=3,即first被赋值为3

5.调用obj.output()

输出结果

3 AND 2

4.

class B{
public:
B(string s){this->s=s;}
void output(){cout<<s;}
private:
string s;

};
class D:public B{
public:
D(string a,string b):B(a+b),s(b){}
void output(){cout<<s;B::output();}
private :
string s;
};
void main()
{
D *p = new D("world","hello");
p->output();
}

输出结果

hello world hello

5.

class B
{
public:
B(){cout<<"hello";}
~B(){cout<<"bye";}

};
class D:public B
{
public:
D(){cout<<"world";}
~D(){cout<<"C++";}
};
void main()
{
D obj;
cout<<"hi";
}

输出结果

hello world hi C++ bye