注：以下问题的部分解析并非全部是自己原创，只是为了便于以后复习，直接粘贴总结的答案，主要来源是七月在线中的解析部分。https://www.julyedu.com/question/selectAnalyze/kp_id/4/cate/C
1、下列关于一个类的静态成员的描述中，不正确的是（ ）
A 该类的对象共享其静态成员变量的值
B 静态成员变量可被该类的所有方法访问
C 该类的静态方法只能访问该类的静态成员变量
D 该类的静态数据成员变量的值不可修改
解释：选D
用static关键字修饰的数据成员为静态成员。
普通成员每一个对象都回创建一个，但静态成员是被同类的所有对象共享，可以被类的所有方法访问。
静态方法只能访问静态方法和静态成员，不能访问任何非静态方法和和非静态成员。
若静态成员变量没有被const修饰，则其值是可以修改的。
补充：静态成员只能在类外进行初始化，只有静态常量整型数据成员才能在类中初始化。
普通成员只有在创建了对象之后才可以存在，但静态成员只要创建了类，便存在了。
普通成员的调用方法为对象名.成员名，静态成员还可以直接用类名作用域的方法调用
类名::成员名
2、C++将父类的析构函数定义为虚函数，下列正确的是哪个（ ）
A 释放父类指针时能正确释放子类对象
B 释放子类指针时能正确释放父类对象
C 这样做是错误的
D 以上全错
解释：选A
当创建一个父类的指针调用子类的对象时（CFather *fa = new CSon），若父类的析构函数不是虚函数时，释放父类指针时只会调用父类的析构函数；若父类的析构函数是虚函数时，将会先调用子类的析构函数，在调用父类的析构函数。
3、以下关于STL的描述中，（ ）是错的。
A STL容器是线程安全的
B 当容量不够时，vector内部内存扩展方式是翻倍
C std::sort可以是不稳定排序
D std::string中可以存储多个’\0’字符
E std::bitset是一个存储bit的STL容器
F std::stack默认是用deque实现的
解释：选A
STL容器没有规定一定是线程安全，所以如果是多个写操作，使用时需要由程序员加锁来保证一致性。
容量不够是，一种vector的实现方案的确是翻倍，当然也有扩大为原来的1.5倍等其他方案。std::sort的一种实现方案是当数据量大时，使用快速排序；如果数量中等，使用堆排序；如果少量数据，则使用插入排序；因此，它不是稳定的排序方案。
std::string有长度字段，不以’\0’字符作为结束标志。
std::bitset是记录0、1标志的容器，但需要初始化时指定长度，功能上类似压缩的0/1数组。
deque是双向队列，一般是分块连续的；在实现时，往往使用deque来实现堆栈std::stack。
4、程序出错在什么阶段（ ）
#include < iostream >
using namespace std;
int main(int argc,char**argv)
{
http://www.sougou.com
cout<< “welcome to sogou”<< endl;
return 0;
}
A 编译阶段出错
B 运行阶段出错
C 编译和运行都出错
D 程序运行正常
解释：选D
本题中的网址比较迷惑人，在C++中，单行注释以双斜杠（//）开头，即"www.sougou.com"是注释内容。
而前面http是标签，标签命名规则和变量相同，后面跟一个冒号（:），标签提供了表示特定语句的方式，使用goto label（label表示标签名）可以无条件跳转到该语句。
5、下面程序执行结果为【说明：x86_64环境】（ ）
int a[4][4] =
{
{ 1, 2, 3, 4 },
{ 50, 60, 70, 80 },
{ 900, 1000, 1100, 1200 },
{ 13000, 14000, 15000, 16000 }
};
int (*p1)[4] = a;
int (*p2)[4] = &a[0];
int *p3 = &a[0][0];
printf(“%d, %d, %d, %d\n”,
* ( *(a + 1) - 1),
* ( * (p1 + 3) - 2) + 1,
* ( *(p2 - 1) + 16) + 2,
* (p3 + sizeof(p1)-3));
A 16000,1101,13002,2
B 4,2,3,60
C 16000,2,3,2
D 4,1101,13002,60
解释：选D
a+1指向第二行 * (a+1)指向第二行第一列，( * (a + 1) - 1)指向第一行最后一列，故* ( * (a + 1) - 1)为4；
指针p1是一个指向含有4个元素的数组的指针，即数组指针。当p1与整数加减时，以4个整型值长度为单位进行调整， p1+3指向第四行， * (p1+3)指向第四行第一列，* (p1+3)-2 将指向第三行倒数第二列，故* ( * (p1 + 3) - 2) + 1为1101；
指针p2和指针p1类型相同，初始值也都是数组a的首地址，分析同p2；
指针p3是指向单个整型元素的指针，与整数加减时以1个整型值长度为单位来调整， 对于第4个输出值，指针p1的大小在x86_64环境下为8个字节，* (p3 + 8 – 3)结果为60。
在不同的系统环境中，指针类型：32位系统4字节，64位系统8字节。
6、void func()
{
char b[2] = {0};
strcpy(b,“aaaa”);
}
以下说法哪个正确（ ）
A Debug版崩溃，Release版正常
B Debug版正常，Release版崩溃
C Debug版崩溃，Release版崩溃
D Debug版正常，Release版正常
解释：选A
func函数中，申请了2个char大小的内存空间，而实际写入的数据超出申请空间，执行strcpy函数虽然将数据写入但是破坏了后续的空间，在函数返回前收回申请空间时发现内存访问越界。由于Debug版中，存在相应的保护机制检查是否内存访问越界，而Release版则不会进行相应的检查，故前者崩溃，后者正常。
7、在x86_64环境下，int(*b)[10][10]; sizeof(b)=（ ）
A 8
B 40
C 80
D 400
E 800
解释：选A
b为一个指向二维数组的指针，即数组指针，故其大小为指针的大小，在该环境下为8。
8、在面向对象软件开发中，封装是一种（ ）技术，其目的是使对象的使用者和生产者分离。
A 接口管理
B 信息隐藏
C 多态
D 聚合
解释：选B
9、声明一个指向含有10个元素的数组的指针，其中每个元素是一个函数指针，该函数的返回值是int，参数是int*，正确的是（ ）
A (int * p[10])(int*);
B int [10]* p(int*);
C int (* (* p)[10])(int*);
D int ((int*)[10])*p;
解释：选C
首先区分一下数组指针和指针数组。int (* p)[10]是一个数组指针，p是一个指针指向 int[10]数组， int* p[10]是一个指针数组，p是一个数组，数组每个元素是个指向int型的指针。
一个指向含有10个元素的数组的指针就是(* p)[10]。返回值是int，参数是int* 的函数指针的定义为int ( * pf)(int * ) ，然后把( * p)[10]作为一个整体替代 pf，即int( * ( * p)[10]))(int * )。
对于复杂指针的解析，有一个“右左法则”。对于C选项中的int ( * ( * p)[10])(int*)，可以进行如下解析：首先找到那个未定义的标识符，就是p，它的外面是圆括号，左边是*，说明p是一个指针,然后(* p)右面是[]，所以是数组指针, * p指向一个int[10]数组。再看左边，是个 * 号，表明数组的每个元素为一个指针。出括号再看右侧是(int * )，说明这是一个函数指针,所以这个数组中每个元素是函数指针，该函数的参数是int*，返回值是int
10、下面描述中，正确的是（ ）
A 基类定义的public成员在公有继承的派生类中可见，也能在类外被访问
B 基类定义的public和protected成员在私有继承的派生类中可见，在类外可以被访问
C 基类定义的public和protected成员在保护继承的派生类中不可见
D 基类定义的protected成员在保护继承的派生类中可见，也能在类外被访问
解释：选A
