moocC++程序设计（面向对象进阶）章节答案(慕课2023课后作业答案)

点击查看答案

第1单元：C++概览

第01节：C++编程范式与现代C++标准随堂测验

1、序设向对象进哪种编程范式是计面阶章节答C++11之后才支持的？
A、结构化编程
B、案慕案面向对象编程
C、课课泛型编程
D、后作函数式编程

第01节：C++编程范式与现代C++标准随堂测验

1、业答受到C++语言重要影响的序设向对象进编程语言包括
A、Java
B、计面阶章节答C#
C、案慕案Python
D、课课Haskell

2、后作自C++03标准开始的业答C++被称为现代C++

第02节：学习C++：参考书和编程环境随堂测验

1、我们要使用最新版开发工具的序设向对象进原因包括：
A、新版工具提供更友好的计面阶章节答提示信息
B、新版工具提供更便捷的案慕案操作
C、新版工具占用空间更小
D、新版工具的速度更快

第1单元测验

1、第一个被称为“Modern C++”的标准是？
A、C++98
B、C++03
C、C++11
D、C++14
E、C++17
F、C++20

2、集成开发环境中不一定包括
A、编译器
B、链接器
C、图形界面设计工具
D、调试器

3、集成开发环境的英文缩写是
A、IEE
B、IDD
C、DEV
D、IDE

4、C++ 11支持的编程范式包括
A、脚本编程范式
B、结构化编程范式
C、函数式编程范式
D、OO编程范式
E、泛型编程范式
F、解释型编程范式

5、如何学好C++？
A、多看书，少编程
B、多编程
C、多调试解决程序BUG
D、多装几个C++开发环境

6、C++集成开发环境包括下面所列的哪些部分？
A、编辑器
B、编译器
C、链接器
D、开发器
E、运行器
F、测试器

7、集成开发环境中一般包含
A、编辑器
B、编译器
C、链接器
D、测试器
E、调试器

8、我们在C++学习过程中，选择开发工具应尽量选择简单的、问世时间比较久的工具。因为这样的工具易用且稳定。

9、C语言支持面向对象编程范式

10、编译器的英文是__________

作业1：测试你的C++编译器支持的标准

1、在C++开发环境中创建新的项目，然后创建一个main.cpp文件，将下面的代码粘贴到该源文件中； 不要改动你的C++开发环境中的默认设置。 编译并且运行； 截屏展示程序的输出结果。 作业提交： 用文字说明你所用C++开发环境的名称、版本号、操作系统及版本号（共6分）； 输出结果的截屏图片（4分）。 代码如下： // 注意：由于中M系统有bug，正常录入的C++代码会出现HTML控制符。 // 如果出现该问题，请参考上面图片中的代码。 // 也可以下载附件“CompilerVersion.cpp.txt”，将文件名中的“.txt”去掉 #include <iostream> int main() { // 注意：__cplusplus 开头是连续两个下划线 if (__cplusplus > 201703L) std::cout << "C++2a\n"; else if (__cplusplus == 201703L) std::cout << "C++17\n"; else if (__cplusplus == 201402L) std::cout << "C++14\n"; else if (__cplusplus == 201103L) std::cout << "C++11\n"; else if (__cplusplus == 199711L) std::cout << "C++98\n"; else std::cout << "pre-standard C++\n"; std::cout << "Press ANY key to exit."; std::cin.get(); return (0); } // 如果上面的代码无法拷贝，也可以下载附件，将扩展名改为 .cpp

第2单元：C++程序基础

第01节：C++源代码和编码规范随堂测验

1、查资料，然后判断c++程序中的头文件扩展名包括以下：
A、.h
B、.head
C、.hpp
D、.hxx

2、查资料，然后指出C++程序中源文件的扩展名包括以下：
A、cpp
B、cxx
C、cc
D、cplusplus

3、遵守编码规范有助于
A、提升代码的可阅读性和可维护性
B、让代码运行得更快
C、让编译器编译时间更短
D、减少代码编写中的低级错误

第03节：名字空间随堂测验

1、以下代码写法哪个不符合工程规范？
A、using namespace std;
B、using std::endl;
C、std::cout << "Hello";
D、using std::endl; std::cout << endl;

2、名字空间可以限定一个标识符（identifier）的可见范围

第04节：编译C++程序随堂测验

1、编译过程中的Link阶段是对程序中的各种符号进行重新定位的过程

2、C++程序编译的第一步是对源代码进行__________

第05节：处理错误随堂测验

1、C++编程过程中的错误有以下几类：
A、Syntax Error
B、Logical Error
C、Runtime Error
D、Mistype Error

第06节：输入和输出随堂测验

1、cin对象中，用于读取一个字符串的函数是
A、scanf
B、read
C、get
D、gets

2、运算符“<<”被称为流提取运算符

第2单元测验

1、关于C++的main()函数说法不正确的是
A、必须得显式地写 return 语句返回一个整型值
B、函数类型是 int 型
C、可以带参数
D、可以不带参数

2、关于名字空间，说法正确的是
A、C语言也有名字空间
B、名字空间不能嵌套声明
C、名字空间可以用 for 作为名字
D、程序员可以定义自己的名字空间

3、关于编译预处理，说法正确的是
A、using 是预处理指令
B、#define HELLO 是定义了一个宏，名字叫 HELLO
C、#define HELLO HELLO 是定义了一个宏，名字叫 HELLO
D、C++源代码经过编译预处理之后，就变成了目标代码

4、int i = 1; cout << i << i++; 上面的代码的输出是
A、11
B、12
C、21
D、第二行代码是一句病式。最终结果依赖于两个 i 的取值次序。这是C++标准中未定义的行为。不同编译器会输出不同的结果。

5、char a, b; cin >> a; b = cin.get(); 从键盘上输入 字符 x 然后回车，那么 b中存放的是
A、随机的字符
B、字符x
C、字符a
D、换行符

6、cin对象中，以下说法错误的是
A、getline()函数可以读入一行字符串
B、get()的重载函数可以读入一行字符串
C、使用 >> 可以输入时，遇到空格或制表符时都会停止
D、也支持 << 操作

7、c++程序中的源文件扩展名包括以下：
A、cpp
B、cxx
C、java
D、asm

8、遵守编码规范有助于
A、提升代码的可阅读性和可维护性
B、提升程序开发小组协作的效率
C、让代码运行得更快
D、让程序员更快乐

9、运算符 >> 原本的含义是左移运算符

10、int a, b; cin >> a >> b; 输入 1 2 则 a的值是2， b的值是1

11、编译器能帮我们检查代码的逻辑错误

12、C++程序的入口点是哪个函数？

13、用于输出语句中，代表标准输出的对象是

第2单元作业1：在线编程-输入与输出

1、输入一个[1-9]之间的整数（假定该整数为n），输出1-n之间的整数。

第3单元: C语法的增强及对应的C++11特性

第01节：引用、[C++11]空指针与动态内存分配随堂测验

1、对于语句 int& x = y, y = 0;说法正确的是
A、y是一个引用
B、x存放的是y的地址
C、y的地址是0
D、有语法错误

2、char* p = new char(32); 对应的释放内存的语句是：
A、delete [] p;
B、free(p);
C、delete p;
D、delete <char> p;

3、char* a = new char[32];对应的释放内存的语句是：
A、free a;
B、delete *a;
C、delete a[];
D、delete [] a;

4、引用在定义的时候就必须被初始化

5、如果被调函数的形式参数是引用类型，那么对形式参数赋值，效果上相当于对实际参数进行赋值

6、int* p = nullptr; int* q; 在C++11中，第一行的代码写法要比第二行代码规范

第02节：数据类型与转换、[C++11]列表初始化随堂测验

1、bool x = static_cast<bool>('a'); bool y = ( x != true); x和y的值分别是什么？
A、true true
B、true false
C、false false
D、false true

第02节：数据类型与转换、[C++11]列表初始化随堂测验

1、cout << static_cast<double>(1 / 2); 的输出是0.5

第02节：数据类型与转换、[C++11]列表初始化随堂测验

1、bool x, y; // ...... 此处代码对x和y进行初始化 则表达式 !(x && !y) 与下面哪个表达式等价？
A、!x && !y
B、!x || !y
C、!x && y
D、!x || y

2、对于代码 long int x { 1.1 }; 编译器不会报错。

3、对于代码 long int x (1.1);编译器不会报错

4、表达式： static_cast<double> (3) / 2 与 表达式： static_cast<double> (3 / 2) 是等价的。

5、bool x = 1 & 2;则x的值为

6、bool x = 1 && 2; 则x的值为

第03节：[C++11]自动类型推导：类型系统、auto与decltype随堂测验

1、对于以下代码 auto x { 2.f };x的类型是
A、float
B、double
C、int
D、auto

2、对于 int const x = 3; auto y { x }; auto& z { x }; 则y和z的类型分别是
A、const int 和 int
B、int 和 int
C、int 和 const int
D、int 和 int&

3、对于 auto x = 'c'; auto p = &x; p的类型是 char*

第04节：简化的C++内存模型随堂测验

1、语句 int x = 108;中的108存放在哪个区域？
A、常量区
B、静态区
C、堆区
D、栈区

2、对于语句 const char* p = "Hello";执行下面那条语句不会导致错误？
A、p[0] = 'A';
B、p = "World";
C、cin >> p;
D、*(p+1) = 'E';

第05节：常量与指针随堂测验

1、在32位编译器中， const int x = 10; cout << sizeof (x); 的输出是：
A、2
B、4
C、8
D、16

2、对于已有代码 char a[3], b[3]; char* const p = a;合法的后续语句是：
A、p[0] = 'a';
B、*(p++) = 'b';
C、p = b;
D、p[3] = b[0];

3、对于已有代码： char a[3], b[3]; char const* p = a; 合法的后续语句是
A、p = b;
B、p = b + 1;
C、p[0] = 'a';
D、*(++p) = 'b';

4、以下语句using ULInt = unsigned long int; using PULInt = ULInt*; 在C++11中是正确的

第06节：特殊函数：重载、默认参数值与内联随堂测验

1、对于函数1 void f(int a, int b = 1, int c = 2) { }与函数2 void f(int x, int y = 3) { }对于下面语句 f(3, , 1);来说，表述正确的是：
A、调用的是函数1
B、调用的是函数2
C、定义一个新的重载函数
D、编译器会对函数调用语句报错

2、函数 int max(int, int);与函数 unsigned max(unsigned, unsigned); 能够构成重载函数

3、代码 #include <iostream> auto i = 1; int main() { for (auto i = 0; i < 5; i++) { ::i += i; } std::cout << ::i; return 0; } 的输出结果是：

4、声明内联函数的关键字是

第07节：[C++11]基于范围的for循环随堂测验

1、对于代码 char s[] = { 'H', 'e', 'l', 'l', 'o'}; auto i = 0; for(char c : s) { i++; } cout << i; 的输出结果是
A、0
B、4
C、5
D、6

第08节：[C++17]带有初始化器的if和switch语句随堂测验

1、以下关于带有初始化器的if语句用法不正确的是
A、if(auto x{ 3}; x > 3) { // ... }
B、if(z == 1; int z = 1) { //... }
C、if( bool y = (1==2); 1 == 2) { }
D、int foo () { //... } int main() { if(auto x = foo(); x != foo()) { } }

2、带有初始化器的 switch语句 switch( int x = 0; x) { // ... } 等价于 { int x = 0; switch(x) { //... } }

第4单元: 对象和类（基础）

第01节：用类创建对象随堂测验

1、面向对象的四个特征中，“P”和“I”分别代表
A、Polygram
B、Polymorphism
C、Inharitanse
D、Inheritance

2、面向对象的四个特征中“E”代表的是 Encaption

3、面向对象的英文怎么写？(用半角连字符连接两个英文单词)

4、面向对象的四个特征中，“A”的英文全称是：

第01节：用类创建对象随堂测验

1、构造函数不能有返回值，所以构造函数名的前面必须加上关键字 void

2、类的数据成员也叫做实例变量

第02节：对象拷贝以及分离声明与实现随堂测验

1、类Circle有一个无参构造函数，还有一个接收一个参数的构造函数，那么下面匿名对象相关的代码中，哪些是正确的？
A、Circle c = { Circle a};
B、Circle c{ 1.0 } = Circle;
C、Circle c; c = Circle{ };
D、Circle c; c(Circle{ 1});

2、对象拷贝时，对象中的函数成员也进行一对一拷贝

第02节：对象拷贝以及分离声明与实现随堂测验

1、存放类声明的头文件被包含多次，编译器可能会报告类重复声明的错误

2、将类的声明放到.h文件中，将类的实现放到.cpp文件中，这两个文件的名字除了扩展名之外必须完全相同

第02节：对象拷贝以及分离声明与实现随堂测验

1、避免头文件被多次包含的编译预处理方法有
A、#ifndef HEADER_FILE_NAME #define HEADER_FILE_NAME // 程序代码 #endif
B、#pragma once
C、#include once
D、C++11 的 _Pragma 运算符

第03节：对象指针、对象数组以及函数参数随堂测验

1、给定例子中的Circle类；则 Circle c{ }, *p = &c; Circle x{ 8.0 }, *q = &x; 则让c对象的半径也变成 8.0 的代码有：
A、q = p;
B、*q = c;
C、*p = x;
D、c = q;

第03节：对象指针、对象数组以及函数参数随堂测验

1、class Circle { }; int main() { Circle *p = new Circle[4]; p++; } 第5行代码要删除数组应该用：
A、delete [] p;
B、delete [] Circle;
C、delete [] (p--);
D、delete [] (--p);

2、int main() { Circle c[] { 1.0, 2.0, 3.0}; } 数组c是在堆区分配的内存

第03节：对象指针、对象数组以及函数参数随堂测验

1、对于如下代码：class Circle { } ; void f ( Circle c ); // main() Circle x{ }; f(x); 第五行代码会导致对象拷贝

2、对于下面的代码 class Circle { } ; void f ( Circle& c ); // main() Circle x{ }; f(x); 第五行代码会导致对象拷贝

第04节：抽象、封装与this指针随堂测验

1、关于this指针，说法正确的有
A、this指针是自动初始化的
B、this指针的类型是 void *
C、this指针指向调用当前函数的对象
D、我们可以显式声明this指针

2、我们可以修改this指针的值，使之指向另外一个对象

3、不管类的数据成员是public还是private属性，数据成员必须在函数成员前面声明。

第05节：[C++11]类数据成员的初始化随堂测验

1、C++11 中，类数据成员初始化时可以使用如下形式：class X{ int x(2); };

2、C++11中，对象类型的成员不允许就地初始化

第05节：[C++11]类数据成员的初始化随堂测验

1、在构造函数的函数体中，还可以初始化类的子对象成员

2、构造函数的函数体执行之前，类中的子对象成员必须完成初始化

第05节：[C++11]类数据成员的初始化随堂测验

1、以下哪些函数可以作为类Circle的默认构造函数？
A、Circle::Circle();
B、Circle::Circle(double radius);
C、Circle::Circle(double r = 1.0, char color = 'b');
D、Circle::Circle(Circle& c);

2、带有参数的构造函数不是默认构造函数

第05节：[C++11]类数据成员的初始化随堂测验

1、对于代码 struct X { int x { 8}; X() : x { 10} { x = 42; } }; X c; 则 c.x 的值是
A、8
B、10
C、42
D、不能确定

2、如果类X的数据成员x既有就地初始化，也有构造函数初始化列表的初始化，那么就地初始化会被执行并且优先级最高。

第4单元测验

1、对于如下代码： Circle *pCircle2 = new Circle(5.9);释放内存的正确语句是：
A、free(pCircle2);
B、delete pCircle2;
C、delete pCircle2(5.9);
D、delete Circle(5.9);

2、下面的代码输出结果是什么？ string s{ ""}; s.append("ABCDEFG", 3, 2); cout << s;
A、BC
B、CD
C、DE
D、EF

3、对于如下代码 Circle* p = new Circle[3]; 正确释放内存的代码是：
A、delete [] p;
B、delete [3] p;
C、delete p[];
D、delete p(3);

4、对于如下代码 Circle circleArray[3] = { Circle(3), Circle(4) };没有调用Circle类的哪些构造函数？ 上述代码的编译环境是 C++11或者C++14。 注意：在C++17中引入了“复制消除”，会对本题的结果产生重要影响。
A、Circle::Circle(int)
B、Circle::Circle(Circle &)
C、Circle::Circle()
D、Circle::Circle(Circle [])

5、以下代码中，第几行有错误？ class S { int x = 7; int n(7); std::string s{ "Hello"}; int a[] = { 1,2,3}; auto b[] = { 1,2,3}; public: S() { } };
A、3,5,6
B、3,6
C、4
D、1,5,6

6、关于C++11引入的 std::array类，说法不正确的是
A、在C++17中，定义 std::array对象时，可以省略数组类型和数组大小，改为由该对象初始化的值进行自动推断
B、std::array对象中保存了数组元素的数量
C、std::array对象可以像原生数组那样用下标那样访问元素
D、std::array对象不能用基于范围的for循环遍历

7、class Hello 的构造函数的原型可以写为
A、inline int Hello();
B、inline Hello(int a);
C、Hello(char* p, char& q, char []);
D、Hello(int a = 0);
E、int Hello() = default;
F、Hello() = default;

8、代码 Circle circle1, circle2; circle1 = Circle(); circle2 = Circle(5);中的匿名对象有
A、circle1
B、circle2
C、Circle()
D、Circle(5)

9、以下选项中，哪种方法可以将类中的函数成员声明为内联函数？
A、class A { void f() { //do something } };
B、inline void A::f() { //do something }
C、class A { void f(); }; void A::f(){ }
D、class A { inline void f(); }; void A::f(){ }

10、对于如下代码 Circle circle1; Circle *pCircle = &circle1; 正确访问对象成员函数的方法是
A、circle1.getArea();
B、pCircle.getArea();
C、(&circle1)->getArea();
D、(&pCircle)->getArea();

11、下面这些代码的功能是创建一个string对象 s，并将其内容设置为字符串 alohaworld ，正确的有：
A、string s{ 'alohaworld'};
B、string s = string{ "alohaworld"};
C、char* p = "alohaworld"; string s(p);
D、string s{ 'a','l','o','h','a','w','o','r','l','d'};
E、string s('a','l','o','h','a','w','o','r','l','d');

12、构造函数必须带有参数

13、下面的代码中 Circle circle1, &circle2 = circle1, *p = &circle2; 两个 & 符号的含义是相同的。

14、一般而言，函数里面定义的静态局部变量，在函数运行结束后仍然存在。

15、使用this指针之前，程序员必须先声明this指针。

16、类的所有对象中的“this”指针都是指向同一个地址的。

17、一般情况下，使用对象作为函数的参数，要比使用对象的引用作为函数的参数，在运行时的开销要大

18、struct中，如果不指明成员的访问控制属性，则默认的访问控制属性是（请填写C++关键字）：

19、下面的代码输出结果是什么？ string s1("HelloWorld"); string s2("HelloKitty"); cout << (s1 >= s2);

4.3. 在线编程-遍历对象数组

1、1. 编写类Circle。 2. 编写主函数，利用 std::array 创建包含10个对象的Circle数组并初始化。 3. 用基于范围的for循环遍历Circle数组，求10个Circie对象的面积之和

4.4 在线编程-创建Screen类

1、考虑创建一个绘图程序。程序中需要有一个类Screen用来表示绘图时所用的屏幕 这个屏幕有一些基本属性，比如宽和高；有一些基本操作，比如获取屏幕的宽和高

第5单元: 对象和类（高级）

第01节：[C++11]断言与常量表达式随堂测验

1、下面那个语句定义了编译期常量？
A、int m { 1};
B、const char* s = "Hello";
C、int n = 1; const int m = n;
D、constexpr int m = 3;

2、constexpr 修饰的表达式一定是编译期常量表达式

第01节：[C++11]断言与常量表达式随堂测验

1、assert() 是一个函数

2、static_assert 是一个关键字

3、assert() 可以作为程序正常的逻辑控制代码

第02节：代理构造、不可变对象与静态成员随堂测验

1、以下代码对构造函数的调用从语法和语义上都是正确的： class C { int x; public: C() { C(10); } C(int i): x{ i} { }};

2、下面的代码表示代理构造函数的递归调用 class C { public: C() { C(); } C(int i) { }};

第02节：代理构造、不可变对象与静态成员随堂测验

1、不可变类中不能有：
A、getter函数
B、setter函数
C、私有数据成员
D、公有函数成员

2、一个类只要所有数据成员均为私有属性并且没有setter函数，就是一个不可变类

第02节：代理构造、不可变对象与静态成员随堂测验

1、以下类的声明中有错误，请指出错误的代码行号 class A { public: A(int a=0){ x=a; } static void f1(){ x++; }; private: int x; static int y; };
A、3
B、4
C、7
D、11

2、类中的静态成员变量可以在类的构造函数中初始化。

3、C语言程序中的 static函数只能被包含该函数的源程序文件中的其他函数使用。

4、类的静态数据成员的存在不依赖于任何类对象的存在

5、class A { public: A(int a=0){ x=a;} static void f1(){ }; private: int x; static int y;}; int main(){ A::y = 0; A::f1(); return 0; } 上面的代码编译时会出现错误。

第03节：析构、友元与深浅拷贝随堂测验

1、析构函数可以有返回值

2、析构函数可以被重载

第03节：析构、友元与深浅拷贝随堂测验

1、类的友元函数可以在类的外面声明

第03节：析构、友元与深浅拷贝随堂测验

1、如下代码中，类的构造函数与拷贝构造函数的数量分别是 class X { public: X(); X(int&); X(const X&, int = 1); }; 注意，这里所指的构造函数是狭义的构造函数，不包括拷贝构造函数。
A、3, 1
B、2, 1
C、1, 2
D、3, 2

2、拷贝构造函数的参数数量可以是
A、0
B、1
C、2
D、多于2个

第03节：析构、友元与深浅拷贝随堂测验

1、deep copy与shallow copy的问题是由类中的指针类型成员引起的。

第04节：vector类和[C++14]字符串字面量随堂测验

1、下列vector对象初始化语句正确的有
A、std::vector<int> v { 2, 3, 12.0};
B、//C++17 std::vector v { 2, 3, 12};
C、std::vector<char> v { "Hello"};
D、std::vector<std::string> sv{ "Hello", "World"};

第04节：vector类和[C++14]字符串字面量随堂测验

1、下面代码输出的结果是： cout << R"Hello("Hello")Hello";
A、Hello
B、HelloHelloHello
C、Hello("Hello")Hello
D、"Hello"

2、下面代码编译并且执行后，v中存放着5个字符//C++17 #include <string> #include <vector> using namespace string_literals; int main() { auto s = "Hello"s; std::vector v(s.begin(), s.end()); }

第06节：[C++17]结构化绑定随堂测验

1、关于结构化绑定，说法正确的有
A、结构化绑定是一个声明语句
B、结构化绑定可以将已有的一些变量绑定到初始化器的子对象或者元素上
C、结构化绑定可以指定待绑定变量的类型，比如int等
D、结构化绑定中auto不能与引用类型符联合使用

2、用于原生数组的结构化绑定，声明的标识符数量可以少于数组元素的数量

第06节：[C++17]结构化绑定随堂测验

1、下面代码空白处应该填入struct S { int a { 1}; char c[2] { 'a', 'b'}; }; int main() { S s; ___________ = s; }
A、auto [ x ]
B、auto & [ x, y]
C、auto & [x, y, z]
D、auto [ x, y[] ]

2、下面的代码是否正确？class C{ int a; int b{ 1}; }; int main() { C c; auto [ x, y] { c}; }

第5单元测验

1、下面代码中，不正确使用代理构造的是
A、struct A{ A(): A(2) { } A(int x){ } A(double d){ }};
B、struct A{ A(): A{ 2} { } A(int x): A{ static_cast<double>(x)}{ } A(double d):A{ }{ }};
C、struct A{ A(): A(2) { } A(int x){ } A(double d) :A{ static_cast<int>(d)}{ }};
D、struct A{ A() { } A(int x): A{ }{ } A(double d):A{ }{ }};

2、以下类的声明中有错误，请指出错误的代码行号 class A { public: A(int a=0){ x=a; } static void f1(){ x++; }; private: int x; static int y; };
A、3
B、4
C、7
D、11

3、对于下面的代码，说法正确的是 class A { public: A(int a = 0) { x = a; } static void f1() { y++; }; private: int x; static int y; }; int main() { A::f1(); return 0; }
A、Precompile阶段报错
B、compile阶段报错
C、link阶段报错
D、编译后执行的时候报错

4、析构函数说法正确的是
A、析构函数可以有参数
B、析构函数可以重载
C、析构函数可以有返回值
D、析构函数在对象销毁时被自动调用

5、关于类的友元函数说法正确的是
A、友元函数可以在类的外声明
B、友元函数必须在类内声明
C、友元函数不能访问类的成员
D、类的函数成员不能访问友元函数

6、关于 assert() 和 static_assert 说法正确的有
A、assert(bool_expression) 断言可以用于编译期
B、assert(bool_expression) 断言判断bool_expression表达式是否为真，若为真，则退出并提示
C、static_assert(bool_expression, message)断言只能用于编译期，且bool_expression必须是编译期常量表达式
D、按照C++11的标准规定，static_assert(bool_expression, message)断言中，message这个参数可以省略
E、static_assert 和 assert 不能互换

7、关于字符串字面量，下面哪些是正确的？
A、#include <iostream> #include <string> using namespace std::string_literals; int main() { const char* s = R"Hello World"; std::cout << s; } 输出：Hello World
B、#include <iostream> #include <string> using namespace std::string_literals; int main() { const char* s = R"(Hello\n World)"; std::cout << s; } 输出： Hello\n World
C、#include <iostream> #include <string> using namespace std::string_literals; int main() { const char* s = R"Hello(Hello\n World)Hello"; std::cout << s; } 输出： Hello\n World
D、#include <iostream> #include <string> using namespace std::string_literals; // main().......... std::string s1 = "Hello\0World"; auto s2= "Hello\0World"s; s1.size()的值是5 s2.size()的值是11
E、#include <iostream> #include <string> using namespace std::string_literals; // main().......... auto s1 = "Hello\0World"s; s1的类型是 const char*

8、一个类成为 immutable class 的必要条件包括
A、数据域成员不能是指针类型
B、所有数据域均设置为“私有”属性
C、没有更改器函数
D、没有能够返回可变数据域对象的引用或指针的访问器函数
E、数据域成员必须为const类型

9、拷贝构造函数的参数数量可以是
A、0
B、1
C、2
D、多于2个

10、vector对象中可以保存的数据的类型包括
A、int
B、char*
C、std::string
D、std::array<int,10>

11、immutable object 一旦创建之后，就不能通过任何方法改变其内容

12、类中的静态成员变量可以在类的构造函数中初始化。

13、类的静态数据成员不依赖于任何类的对象而存在

14、deep copy与shallow copy的问题是由类中的指针类型成员引起的。

15、调用vector中的push_back()函数时，可能会导致当前vector对象重新申请内存并将已有的数据挪到新内存中

16、声明编译期常量表达式的关键字是

17、为了使得一个头文件只被包含一次，除了使用 #ifndef FILENAME_H #define FILENAME_H // The contents of the header file #endif FILENAME_H 这种方法之外，还可以使用语句

1. 在线编程-代理构造函数1

1、编写一个类C，提供2个构造函数，分别为无参构造函数、接受一个整数作为参数的构造函数。无参构造函数委托整数参数构造函数构造。请确认构造函数的初始化列表和构造函数体代码的执行次序。按照题目内容要求，输出相应的信息

2. 在线编程-代理构造函数2

1、编写一个类C，提供3个构造函数，分别为无参构造函数、接受一个整数作为参数的构造函数、接受一个double类型浮点数作为参数的构造函数。按照题目内容要求，输出相应的信息

第8单元：运算符重载

第01节：运算符重载与平面向量类随堂测验

1、两个 string 对象能够相加的原因是
A、string 类型与 int 类型相似，本质上可以执行加法运算
B、string 类中重载了 + 运算符
C、+ 运算符本身能够对字符进行运算
D、C++ 标准中对 + 运算符做了特殊规定，所以可以对 string 对象执行相应操作

第01节：运算符重载与平面向量类随堂测验

1、重载运算符时，其参数应尽量避免使用引用类型

第02节：重载二元运算符和数组下标运算符随堂测验

1、对于 + - * / 这四个运算符而言， 一般情况下，重载这四个运算符后，运算符函数的返回值类型可以是左值引用类型

2、对于 + - * / 这四个运算符而言， 一般情况下，重载这四个运算符时，运算符函数的参数类型可以是引用类型。但是这个引用类型最好用const修饰。

第02节：重载二元运算符和数组下标运算符随堂测验

1、下面哪个对类C中的+=运算符的重载是最合适的？
A、C& C::operator +=(const C& c);
B、C C::operator +=(const C& c);
C、C& C::operator +=(C c);
D、C C::operator +=(const C c);

第03节：重载一元运算符随堂测验

1、负号运算符函数可以返回一个引用类型

第03节：重载一元运算符随堂测验

1、正确的输出结果是
A、v1:(2,3)
B、v1(3,4)
C、v3(2,3)
D、v3(3,4)

第04节：重载流操作运算符与类型转换运算符随堂测验

1、流操作运算符不能重载为类的成员函数，否则，在调用的时候参数次序就与我们的系贯是相反的

第04节：重载流操作运算符与类型转换运算符随堂测验

1、重载的类型转换运算符函数没有返回值

第8单元测验

1、++ 运算符的两种不同重载方式的目的是：
A、使得运算结果不同
B、使得程序员用起来更方便
C、区别前置++和后置++
D、C++他爹非常喜欢 ++ 运算符，不然也不会叫 C++

2、将 << 运算符重载为类 Vec2D的成员函数后，则将 Vec2D的对象 r1 和 r2 输出到屏幕上的代码的正确写法是：
A、cout << r1 << r2;
B、r1 << r2 << cout;
C、cout << r1; cout << r2;
D、r1 << cout; r2 << cout;

3、关于Vec2D类中重载的 + 运算符，对于代码 Vec2D r1, r2; // initialize r1, r2; cout << r1 + r2; 说法正确的是
A、通过对象 r1 调用了重载的 + 运算符
B、通过对象 r2 调用了重载的 + 运算符
C、通过 cout 返回的对象调用了重载的 + 运算符
D、其它三个说法都不对

4、对于代码 Vec2D v1(1,3); Vec2D v2 = v1; 说法错误的是
A、调用了Vec2D的有参构造函数
B、调用了 Vec2D的赋值运算符函数
C、调用了Vec2D的拷贝构造函数
D、对象v1和v2所在内存位置不同，但是他们的值是相同的

5、以下关于 this 指针说法正确的是
A、使用 this 指针时， this 指向当前对象
B、程序员可以修改 this 指针的值
C、this 指针可以为空
D、this指针不需要程序员显式定义
E、this是c++关键字

6、如下代码正常编译并可正确运行，则仅仅通过阅读下面的代码，我们可以推测出： #include <string> int main () { string s { "Hello"}; s[2] = 'a'; return 0; }
A、字符串常量 “Hello” 在 s 对象中是用链表存储的
B、string 类中对 [] 运算符进行了重载
C、string 的一个构造函数接收字符指针作为其参数
D、重载的 [] 运算符返回的是一个引用类型的数据（或者对象）

7、下面说法错误的有
A、对于二元运算符，重载之后，在使用时，运算符的两个参数必须都是用户自定义的类
B、当函数的参数是引用类型时，如果不希望该参数被修改，则在该参数声明时应加上 const 关键字
C、如果一个函数返回值类型是引用，那么该函数是一个将亡值
D、将亡值是将左值转换为右值引用
E、泛左值包含左值和将亡值

8、&= 运算符可以被重载

9、++ 运算符可以被重载为友元函数

10、重载后置++/--运算符时，参数参加相关运算

11、从C++语法角度看，将 << 或者 >> 重载为成员函数是可以的。

12、运算符重载的本质是__________

13、重载Vec2D类的赋值运算符时，赋值运算符函数的返回值类型应该是(请以代码形式描述，不要用文字描述）

8.1 在线编程-关系运算符重载

1、在如下给定的代码中，为 MyCircle 类重载关系运算符 >、< >=、< >

8.2 在线编程-数组下标运算符重载

1、练习数组下标运算符重载

第6单元: 继承和多态

第01节：继承与构造随堂测验

1、禁止一个类被其他类继承，可以使用的C++关键字或者标识符是
A、noinherit
B、void
C、finally
D、final

第01节：继承与构造随堂测验

1、当程序员在派生类构造函数中显式调用基类构造函数时，应将被调用基类构造函数放在：
A、派生类构造函数体中
B、派生类构造函数初始化列表中
C、派生类内嵌对象的就地初始化语句中
D、其它三个选项都不对

2、在C++11中，派生类不继承的特殊函数有
A、构造函数
B、析构函数
C、友元函数
D、拷贝构造函数

第01节：继承与构造随堂测验

1、派生类构造函数必须调用基类构造函数。

第01节：继承与构造随堂测验

1、类C继承类B，类B继承类A； 那么，当C的对象c析构时，被调用的析构函数及调用次序是：
A、~B()
B、~A()，~B()，~C()
C、~C()， ~B()，~A()
D、~C()

第02节：名字隐藏与重定义随堂测验

1、对于下面的代码 struct A{ void foo(int x) { };}; struct B: A{ void foo() { };}; int main() { B b; // 通过对象 b，调用基类的 foo(int)函数; } 想要完成第9行任务，该怎么办？
A、在第九行写： b.foo(2);
B、在第九行写： b.A::foo(2);
C、在第五行前面插入： using A::foo; 然后在第九行写： b.foo(2);
D、在第九行写： static_cast<A>(b).foo(2);

第6单元测验

1、对于如下代码 class B { public: void f() { } void g() { f(); } } class D : public B { public: void f() { } void g() { B::f() } } int main() { B b, *pb = & b; D d, *pd = & d; b.f(); pd->f(); return 0; }其中第14行代码和第15行代码分别调用的是
A、B::f() 与 D::f()
B、B::f() 与 B::f()
C、D::f() 与 D::f()
D、D::f() 与 B::f()

2、对于如下代码 class B { public: void f() { } void g() { f(); } } class D : public B { public: void f() { } void g() { B::f() } } int main() { B b, *pb = & b; D d, *pd = & d; d.g(); pd->B::g(); return 0; }对第14行代码和第15行代码说法正确的是
A、间接调用了D::f() 直接调用了D::g()
B、间接调用了B::f() 间接调用了B::f()
C、间接调用了D::f() 间接调用了B::f()
D、直接调用了D::g() 间接调用了B::g()

3、关于抽象类的正确说法是
A、可以定义抽象类的对象
B、抽象类中的所有函数都有函数体
C、抽象类不可实例化
D、抽象类只能包含一个抽象函数

4、类B是类A的派生类,对于代码 A a, *pa = &a; B b, *pb = &b;下述说法正确的是
A、表达式 pb = pa 是 Upcast
B、表达式 pb = &a 是 Upcast
C、a = b 是 Upcast
D、pa = pb 是 Upcast

5、派生类中不能继承基类中的
A、友元函数
B、析构函数
C、拷贝构造函数
D、赋值运算符函数

6、对于下面代码说法正确的有 class A { public: A(int x) { }}; class B: public A{ public: B(){ }}; int main() { B b; }
A、编译错误
B、编译正确，但是运行时没有输出信息
C、在第三行代码后加上 A() = default; 就能编译通过
D、在第二行代码后加上 A() { } 就能编译通过
E、第七行改成 B():A(0){ } 就能编译通过

7、函数的override现象要求基类函数与派生类函数满足下面的条件
A、函数名和函数返回值相同
B、函数参数相同
C、函数在类声明中定义
D、基类函数应为虚函数

8、消除下述代码 compile 阶段语法错误的方式为 class A { public: virtual int f() = 0; }; int main() { A a; (&a) -> f(); }
A、将第3行代码中的virtual关键字去掉
B、将第3行代码中的 = 0; 改为 { }
C、将第6行及第7行代码删除
D、将第7行改为 a.f();
E、将第3行代码中的 = 0 去掉

9、C++11中的final特殊标识符可以用来说明
A、类不可被继承
B、成员函数不可被覆写
C、所定义标识符是常量
D、异常处理中必须要执行的代码块

10、派生类继承基类后，可以定义新的数据成员和函数成员

11、类B继承类A，代码可以写作： class B: A { //Some data field and function }; B是以公有继承的方式继承了A中的成员

12、基类的构造函数能够由派生类中的任何函数调用

13、类A的析构函数在类外部定义时可以写为如下形式： ~A::A() { //do something }

14、构造函数和析构函数都是自动调用的，无法像普通成员函数一样通过对象显式调用。

15、函数的overload是 dynamic binding

16、C++实现运行时多态的必要条件是使用对象指针或者对象引用访问同名函数

17、override特殊标识符要放到函数的返回值类型前

18、override特殊标识符可以修饰基类函数

19、根据本单元所讲，派生类与基类之间是一种________关系

20、在派生类中定义虚函数时，必须在函数名字前加上 __________关键字

1. 在线编程-继承中的构造函数

1、编写 Animal 类和 Dog 类； 根据用户输入的数值，创建相应个数的 Animal 对象和 Dog 对象

第7单元：文件输入输出流

第02节：文件I/O流的基本用法随堂测验

1、fstream类直接继承了ifstream类和ofstream类

2、cin是_______类的对象（空白处填写类名）

第02节：文件I/O流的基本用法随堂测验

1、打开一个输出文件流的方法包括
A、std::filesystem::path p{ "out.txt"}; std::ofstream output{ p};
B、std::ofstream output{ "out.txt"};
C、std::filesystem::path p{ "out.txt"}; std::ofstream output{ }; output.open(p);
D、std::filesystem::path p{ "out.txt"}; p.open();

第02节：文件I/O流的基本用法随堂测验

1、用于判断是否成功打开文件流的函数是
A、success()
B、fail()
C、good()
D、ok()

2、创建 ifstream对象时，给ifstream构造函数传递一个路径参数，构造函数会自动尝试打开这个文件流准备读取信息

第03节：格式化输出与I/O流函数随堂测验

1、cout << std::setprecision(4) << std::fixed << 3.14; 输出：
A、3.14
B、3.140
C、3.1400
D、3

2、setw()函数对其后的所有输出都有效

第03节：格式化输出与I/O流函数随堂测验

1、默认情况下，getline函数使用换行符作为分隔符

第04节：二进制输入输出随堂测验

1、文件输出流代表追加模式的文件标志是 std::ios::_______

第04节：二进制输入输出随堂测验

1、用于二进制读写的I/O流函数包括
A、get()
B、getline()
C、read()
D、write()

2、reinterpret_cast 的主要用途是
A、对基础数据类型进行转换
B、对继承链上的指针类型进行转换
C、将指针转换为数值
D、在不同类型的指针之间进行转换

第05节：随机访问文件随堂测验

1、文件 scores.dat 大小是100字节，用文件流 fstream 对象 fst 打开 那么想要读最后一个字节，下面正确的是
A、fst.seekg(100L);
B、fst.seekp(100L);
C、fst.seekg(-1L, std::ios::end);
D、fst.seekg(50L, std::ios::cur);

学习通C++程序设计（面向对象进阶）

学习通C++程序设计（面向对象进阶）是一门深入学习C++语言的课程，针对有一定C++基础的学习者。这门课程着重讲解面向对象的思想和编程，介绍C++的高级特性和技巧，帮助学习者更加熟练掌握C++语言。

课程内容

学习通C++程序设计（面向对象进阶）共分为12个章节，主要内容如下：

1. 模板与泛型编程：介绍模板的概念、类型参数、模板函数和模板类等内容。
2. STL容器：介绍STL容器的使用和实现原理，包括vector、list、set、map等。
3. STL算法：介绍STL算法的使用和实现原理，包括排序、查找、迭代器等。
4. STL仿函数：介绍STL仿函数的概念和使用，包括一元仿函数和二元仿函数。
5. STL迭代器：介绍STL迭代器的概念和使用，包括输入迭代器、输出迭代器、前向迭代器等。
6. 异常处理：介绍异常处理的概念和使用，包括异常类、try-catch语句等。
7. 多线程编程：介绍多线程编程的概念和使用，包括线程创建、线程同步等。
8. 文件操作：介绍文件操作的概念和使用，包括文件读写、文件指针等。
9. 网络编程：介绍网络编程的概念和使用，包括socket编程、TCP/IP协议等。
10. 设计模式：介绍常用的设计模式，包括单例模式、工厂模式、策略模式等。
11. C++11新特性：介绍C++11的新特性，包括lambda表达式、auto关键字、智能指针等。
12. 项目实战：通过一个实际的案例，综合运用学习的知识和技巧，实现一个完整的C++项目。

课程特点

学习通C++程序设计（面向对象进阶）的特点如下：

• 深入剖析：介绍C++语言的高级特性和技巧，帮助学习者更加深入地理解和掌握C++语言。
• 实用性强：通过大量的实例演示和练习，帮助学习者掌握C++语言的实际应用能力。
• 项目实战：通过一个实际的案例，帮助学习者将学习到的知识和技巧应用于实践中。
• 系统性强：将C++语言的高级特性和技巧系统地呈现出来，帮助学习者建立起完整的C++编程知识体系。

学习要求

学习通C++程序设计（面向对象进阶）的前提是具备一定的C++基础，熟悉C++的面向对象编程思想和语法。推荐学习对象为大学计算机专业学生、软件开发工程师等。

学习收获

学习通C++程序设计（面向对象进阶）的学习收获如下：

• 深入掌握C++语言的面向对象思想和编程技巧。
• 熟悉STL容器和算法的使用和实现原理。
• 了解异常处理、多线程编程、文件操作和网络编程等方面的知识。
• 掌握常用的设计模式和C++11的新特性。
• 通过项目实战，综合运用学习到的知识和技巧，提升实际应用能力。

结语

学习通C++程序设计（面向对象进阶）是一门深入学习C++语言的课程，通过系统性的介绍C++的高级特性和技巧，帮助学习者更加熟练掌握C++语言。通过实例演示和练习，帮助学习者掌握C++语言的实际应用能力。推荐大学计算机专业学生、软件开发工程师等学习，相信能够为学习者带来实实在在的收获。

中国大学C++程序设计（面向对象进阶）

在当前快速发展的数字时代，程序设计已经成为了一项非常重要的技能。而C++作为一门强大的编程语言，因其高效性和可扩展性而成为了许多企业和开发者的首选。因此，学习C++程序设计已经成为了现代教育中不可或缺的一部分。

课程简介

中国大学C++程序设计（面向对象进阶）是一门深入学习C++编程语言的高级课程。该课程主要关注面向对象编程（OOP）及其相关的高级主题，如模板、泛型编程、多线程编程等。

通过该课程的学习，学生们将会深入了解面向对象编程的理念和方法，并且掌握开发高质量、高效率的程序所需要的技能和知识。此外，该课程还将涵盖一些实际应用场景，例如游戏开发、网络编程、数据结构和算法等。

课程大纲

以下是该课程的主要内容和大纲：

• 面向对象编程的概念和基本理念
• 类、继承和多态性
• 在C++中使用的高级特性，如智能指针、异常处理和模板等
• STL（标准模板库）的使用方法
• 多线程编程和并发性
• 实际应用场景：游戏开发、网络编程、数据结构和算法等

课程特色

该课程具有以下特点和优势：

• 理论与实战并重，注重将学生所学的知识直接应用到实际项目中
• 课程设置紧密结合行业需求，有助于学生提高就业竞争力
• 通过实践项目，学生们可以体验团队协作和高效开发的过程
• 课程内容更新快速，并且能够跟上技术的最新发展趋势

学习建议

以下是一些学习C++程序设计的建议和技巧：

• 在学习过程中，一定要多写代码，尤其是要编写一些实际的项目
• 充分利用学习资源，例如教材、课件、开发工具等
• 不要轻视基础知识，一些基本的编程概念和语法对于提高程序设计能力至关重要
• 加强书面和口头表达能力，能够清晰地传达思想和观点至关重要
• 不断更新自己的知识和技能，跟上技术的最新发展趋势

总结

中国大学C++程序设计（面向对象进阶）课程是一门深入学习C++编程语言的高级课程。该课程以面向对象编程及其相关的高级主题为中心，旨在教授学生如何开发高质量、高效率的程序。此外，该课程还注重将理论与实践相结合，理论知识与实际项目相结合，以及紧密结合行业需求，有助于学生提高就业竞争力。

通过学习本课程，学生们将会深入了解面向对象编程的理念和方法，并且掌握开发高质量、高效率的程序所需要的技能和知识。此外，学生还将学习到一些实际应用场景，例如游戏开发、网络编程、数据结构和算法等。