1、一、类型、返回值类型 二、参数表、函数重载
2、一、实例化 二、实例化的类型或类类是对象的蓝图，对象是类的实例化
3、const
4、一个 两个
5、一、公有继承 二、私有继承、保护继承
6、抽象类、实例化对象
7、函数模板、类模板
8、try、catch、throw
9、流插入运算符、流提取运算符
10、可以、可以
11、析构函数
程序阅读题：
#include <iostream> int m = 10; void a(int n) { n = 15 / n; m = m / 2; } int main() { int n = 3; a(n); std::cout << "m=" << m << std::endl; std::cout << "n=" << n << std::endl; return 0; }
这段代码的功能如下：
- 包含了iostream头文件以使用输入输出流。
- 定义了一个整型变量m并初始化为10。
- 声明了一个函数a，接受一个整型参数n。
- 在函数a中，将15除以参数n的值赋给n，然后m除以2的结果赋给m。
- 在主函数main中，定义了一个整型变量n并初始化为3。
- 调用函数a，并传入参数n。
- 使用cout输出m的值，并换行。
- 使用cout输出n的值，并换行。
- 返回0，表示程序正常结束。
代码的执行流程如下： - 声明一个整型变量m并初始化为10。
- 定义函数a，接受一个整型参数n。
- 在函数a中，将15除以参数n的值赋给n，然后将m除以2的结果赋给m。
- 在主函数main中，定义一个整型变量n并初始化为3。
- 调用函数a，并将参数n的值传入。
- 使用cout输出m的值为5，并换行。
- 使用cout输出n的值为3，并换行。
- 返回0，表示程序正常结束。
最终输出结果为：
m=5 n=3
这段代码的功能是对变量m和n进行一些计算操作，并输出结果。
答案：m = 5,n = 3; 过程：a(3); ----> { n = 15/3; m = 10/2; } n是在main()函数中声明的，n = 3,所以n = 15/3 = 5,只在函数a()的作用域中n = 5,但是a()是 void 类型，没有返回值，因此，回到main()函数中后，n仍然等于3。而m是全局变量，在整个程序的任何一个地方更改m的值，m的值都将改变，因此a()函数改变m的值后，main()函数中的m的值也发生了相应的改变。所以 ，调用a(3)后，在main()函数中输出cout<<m<<" "<<n<<endl; 结果为： 5 3
#include <iostream> using namespace std; class PP { int x, y; public: PP() { x = 3; y = 5; } PP(int i, int j) { x = i - y - j; } void Messages() { cout << "x=" << x << " y=" << y << endl; } }; int main() { PP* p1 = new PP(); PP p2(3, 4); p2.Messages(); p1->Messages(); delete p1; // 释放动态分配的内存 return 0; }
这段代码的分析过程如下：
- 包含了iostream头文件以使用输入输出流。
- 使用了
using namespace std来避免每次都需要写std::前缀。 - 声明了一个名为PP的类。
- 在PP类中，定义了私有成员变量x和y。
- 提供了两个构造函数：一个无参构造函数，用于初始化x和y的值为3和5；一个有参构造函数，用于将传入的参数分别赋值给x和y。
- 定义了一个名为Messages的成员函数，用来输出x和y的值。
- 定义了主函数main。
- 在主函数中，通过使用new关键字动态地创建了一个PP类的对象p1，并调用了其无参构造函数。这里使用了指针p1来存储对象的地址。
- 创建了一个PP类的对象p2，并调用了其有参构造函数，传入参数3和4。对象p2会在栈上分配内存。
- 调用p2的Messages函数，输出x和y的值，即输出"x=3 y=4"。
- 通过指针p1调用Messages函数，输出x和y的值，即输出"x=3 y=5"。
- 使用delete关键字释放动态分配的内存，即释放p1指向的对象的内存。
- 返回0，表示程序正常结束。
最终输出结果为：
x=3 y=4 x=3 y=5
该代码主要展示了类的定义与使用。其中，类PP包含了两个构造函数、两个私有成员变量和一个成员函数。在主函数中，通过对象和指针分别创建并使用了PP类的实例。通过调用成员函数Messages，可以输出对象的成员变量x和y的值。最后，通过delete关键字释放了通过new关键字动态分配的内存，以避免内存泄漏。
分析一下过程#include <iostream> using namespace std; class A { int a; public: A(int aa = 0) : a(aa) { cout << a << " "; } ~A() { cout << "析构"; } }; int main() { A x[2] = {2}; cout << endl; return 0; }
这段代码的分析过程如下：
- 包含了iostream头文件以使用输入输出流。
- 使用了
using namespace std来避免每次都需要写std::前缀。 - 声明了一个名为A的类。
- 在A类中，定义了一个私有成员变量a。
- 提供了一个构造函数A，其中使用了参数的默认值0，用于初始化a的值。构造函数会输出a的值。
- 定义了一个析构函数~A，用于在对象被销毁时输出一条提示信息。
- 定义了主函数main。
- 在主函数中，创建了一个名为x的A类对象数组，数组大小为2。数组中的第一个对象会调用构造函数，并将参数2传入进行初始化。构造函数会输出2。数组中的第二个对象会使用参数的默认值0进行初始化。构造函数会输出0。
- 在主函数中，输出一个空行。
- 返回0，表示程序正常结束。
最终输出结果为：
2 0 析构析构
代码的执行过程如下：
- 主函数开始执行。
- 创建一个名为x的A类对象数组，数组大小为2。
- 数组中的第一个对象会调用构造函数A(2)，因此构造函数会输出2。
- 数组中的第二个对象会使用参数的默认值0进行初始化，因此构造函数会输出0。
- 在主函数中，输出一个空行。
- 主函数执行完毕，对象数组x会被销毁，先销毁第二个对象（析构函数输出"析构"），再销毁第一个对象（析构函数输出"析构"）。
因此，最终的输出结果是"2 0 析构析构"。(** 析构析构中间没有空！！！**)
#include <iostream> using namespace std; class A { int a, b; public: A() { a = 0; b = 0; } A(int m) { a = m; b = 0; } A(int m, int n) { a = m; b = n; } void print() { cout << "a=" << a << " b=" << b << endl; } }; int main() { A a, a2(5), a3(5, 15); a.print(); a2.print(); a3.print(); return 0; }
修正后的代码的运行结果为：
a=0 b=0 a=5 b=0 a=5 b=15
代码的执行过程如下：
- 包含了iostream头文件以使用输入输出流。
- 使用了
using namespace std来避免每次都需要写std::前缀。 - 声明了一个名为A的类。
- 在A类中，定义了两个私有成员变量a和b。
- 提供了三个构造函数：
- 默认构造函数A()，将a和b都初始化为0。
- 构造函数A(int m)，将a初始化为m，b初始化为0。
- 构造函数A(int m, int n)，将a初始化为m，b初始化为n。
- 定义了一个成员函数print()，用于输出a和b的值。
- 定义了主函数main。
- 在主函数中，分别创建了三个A类对象a、a2和a3，分别使用了不同的构造函数进行初始化。
- 依次调用a、a2和a3的print()函数，分别输出a和b的值。
- 返回0，表示程序正常结束。
因此，最终的运行结果为：
a=0 b=0 a=5 b=0 a=5 b=15
#include <iostream> using namespace std; class A { public: A() { cout << "generate class A" << endl; } ~A() { cout << "destroy class A" << endl; } }; class B : public A { public: B() { cout << "generate class B" << endl; } ~B() { cout << "destroy class B" << endl; } }; int
这段代码定义了两个类A和B，并在主函数中创建了一个B类对象b。类A和类B都定义了构造函数和析构函数，并且类B继承自类A。
在程序执行过程中，首先创建了一个B类对象b。由于B类是A类的子类，因此在创建B类对象时，会先调用A类的构造函数，然后再调用B类的构造函数。因此，首先输出"generate class A"，然后输出"generate class B"。
当程序执行完毕时，会先销毁B类对象b，调用B类的析构函数，输出"destroy class B"，然后调用A类的析构函数，输出"destroy class A"。
因此，最终的运行结果为：
generate class A generate class B destroy class B destroy class A
#include <iostream> using namespace std; class Base { int x; public: virtual void Set(int b) { x = b; cout << "x=" << x << endl; } }; class Derived : public Base { protected: int y; public: void Set(int d) { y = d; cout << "y=" << y << endl; } }; int main() { Base Bobj; Derived Dobj; Base* p; p = &Bobj; p->Set(100); p = &Dobj; p->Set(200); return 0; }
这段代码定义了两个类Base和Derived，并在主函数中创建了一个Base类对象Bobj和一个Derived类对象Dobj。类Base和类Derived都定义了函数Set，并且类Derived继承自类Base。
在程序执行过程中，首先创建了一个Base类对象Bobj和一个Derived类对象Dobj。
接下来，声明了一个Base指针变量p，并将p指向Bobj。然后通过p调用Set(100)函数，由于Set函数是虚函数，所以会根据指针指向的对象类型调用相应的函数。这里p指向的是Base类对象Bobj，所以调用了Base类的Set函数，输出"x=100"。
然后，将p指向Dobj。再次通过p调用Set(200)函数，同样根据指针指向的对象类型调用相应的函数。这里p指向的是Derived类对象Dobj，所以调用了Derived类的Set函数，输出"y=200"。
因此，最终的运行结果为：
x=100 y=200
#include <iostream> using namespace std; template <class T> T min(T x, T y) { cout << "function1: "; return (x <= y) ? x : y; } int min(int x, int y) { cout << "function2: "; return (x < y) ? x : y; } int main() { int i = 5, j = 6; double d = 1.22, f = 13.21; cout << min(i, j) << endl; cout << min(d, f) << endl; cout << min(d, i) << endl; return 0; }
这段代码定义了一个函数模板min和一个重载的min函数。函数模板min可以接受任意类型的参数，而重载的min函数只接受两个int类型的参数。
在主函数中，创建了两个int类型的变量i和j，并分别初始化为5和6。还创建了两个double类型的变量d和f，并分别初始化为1.22和13.21。
接下来，使用cout输出调用min(i, j)的结果，由于传入的是两个int类型的参数，因此调用的是重载的min函数，输出"function2: 5"。
然后，使用cout输出调用min(d, f)的结果，由于传入的是两个double类型的参数，因此调用的是函数模板min，输出"function1: 1.22"。
最后，使用cout输出调用min(d, i)的结果，由于传入的是一个double类型和一个int类型的参数，因此调用的是函数模板min，输出"function1: 1.22"。
因此，最终的运行结果为：
function2: 5 function1: 1.22 function1: 1.22
#include <iostream> #include <iomanip> using namespace std; int main() { int k = 11; cout << "k=" << hex << k << endl; float d = 12.34144; cout << "d=" << setw(10) << setprecision(5) << setfill('*') << dec<< d << endl; return 0; }
给出的代码是正确的。以下是代码的执行过程和运行结果：
- 包含了iostream和iomanip头文件以使用输入输出流和格式化输出的函数。
- 使用了
using namespace std来避免每次都需要写std::前缀。 - 定义了主函数
main。 - 声明了一个int类型的变量k，并初始化为11。
- 使用cout输出"k="，然后使用hex表示输出k的十六进制形式，输出结果为b。
- 声明了一个float类型的变量d，并初始化为12.34144。
- 使用cout输出"d="，然后使用setw(10)表示输出宽度为10个字符，使用setprecision(5)表示保留小数点后5位，使用setfill(‘‘)表示填充字符为’’。
- 使用dec表示以十进制格式输出。
- 最后使用cout输出d的值，输出结果为"*****12.34144"。
因此，最终的运行结果为：
k=b d=*****12.34144
#include <iostream> class A { int x; public: A() { x = 2; } void print() { std::cout << "x = " << x << std::endl; } void operator++() { x += 5; } void operator--() { x -= 2; } }; int main() { A a; ++a; a.print(); --a; a.print(); return 0; }
这段代码定义了一个类 A，并在 main() 函数中使用该类。
类 A 包含一个私有成员变量 x，默认初始化为 2。类 A 还定义了以下成员函数：
print()函数用于输出变量x的值。operator++()重载了前置递增运算符，将变量x的值增加 5。operator--()重载了前置递减运算符，将变量x的值减少 2。
在 main() 函数中，首先创建了一个类 A 的对象 a，调用构造函数初始化 x 的值为 2。接着，通过 ++a 将 x 的值增加 5，并调用 a.print() 输出结果。然后，通过 --a 将 x 的值减少 2，并再次调用 a.print() 输出结果。
所以，程序的输出结果应为：
x = 7 x = 5
