2-1


下列函数中，（C ）不能重载。 (2分)
成员函数
非成员函数
析构函数
构造函数


2-2


下列对重载函数的描述中，（A）是错误的。 (2分)
重载函数中不允许使用默认参数
重载函数中编译根据参数表进行选择
不要使用重载函数来描述毫无相干的函数
构造函数重载将会给初始化带来多种方式


2-3


在下面类声明中，关于生成对象不正确的是（A ）。

class point

{ public:

int x;

int y;

point(int a,int b) {x=a;y=b;}

}; (2分)
point p(10,2);
point *p=new point(1,2);
point *p=new point[2];
point *p[2]={new point(1,2), new point(3,4)};


2-4


设A为自定义类，现有普通函数int fun(A& x)。则在该函数被调用时(D)： (2分)
将执行复制构造函数来初始化形参x
仅在实参为常量时，才会执行复制构造函数以初始化形参x
无需初始化形参x
仅在该函数为A类的友元函数时，无需初始化形参x


2-5


所有类都应该有D： (1分)
构造函数
析构函数
构造函数和析构函数
以上答案都不对


2-6


析构函数可以返回D： (1分)
指向某个类的指针
某个类的对象
状态信息表明对象是否被正确地析构
不可返回任何值


2-7


下列属于类的析构函数特征的是A (1分)
一个类中只能定义一个析构函数
析构函数名与类名不同
析构函数的定义只能在类体内
析构函数可以有一个或多个参数


2-8


建立一个类对象时，系统自动调用 B(1分)
构造函数
析构函数
友元函数
成员函数


2-9


下列关于类定义的说法中，正确的是A (1分)
类定义中包括数据成员和函数成员的声明
类成员的缺省访问权限是保护的
数据成员必须被声明为私有的
成员函数只能在类体外进行定义


2-10


下列关于类和对象的叙述中，错误的是 A(1分)
一个类只能有一个对象
对象是类的具体实例
类是对某一类对象的抽象
类和对象的关系是一种数据类型与变量的关系

文章目录
关于多线程与多进程编程，下面描述正确的是：ACD
以下关于栈的说法正确的是：A
关于多线程与多进程编程，下面描述错误的是：ABC
下列关于多态性说法不正确的是：
定义析构函数时，注意：C
C中出现如下类型的结构体定义：
对静态成员的正确描述是（）？
开讲啦！！
一、静态数据成员与静态成员函数
二、从内存角度看静态数据成员
三、从this指针谈静态成员函数
四、注意事项
参考链接
ADD R0, R1, #3属于（A）：

关于多线程与多进程编程，下面描述正确的是：ACD

A. 多进程里，子进程可获得父进程的所有堆与栈的数据；而线程会与同进程的其他线程共享数据，拥有自己的栈空间

子进程得到父的复制


B. 线程因为有自己的独立栈空间且共享数据，所有执行的开销相对较大，同时不利于资源管理和保护
C. 线程的通信速度更快，切换更快，因为他们在同一地址空间内
D. 线程使用公共变量/内存时需要使用同步机制，因为他们在同一地址空间内

以下关于栈的说法正确的是：A
A. 在栈空的情况下，一定不能作出栈操作，否则产生溢出

可能叫下溢

B. 栈一定是顺序存储的线性结构

C. 空栈是所有元素都为0的栈

D. 一个栈的输入序列为：A,B,C,D，可得到输出序列：C,A,B,D

关于多线程与多进程编程，下面描述错误的是：ABC
A. 多进程里，子进程可获得父进程的部分堆与栈的数据；而线程会与同进程的其他线程共享数据，拥有自己的栈空间

B. 线程的通信速度更快，切换更快，因为他们在同一地址空间内

C. 线程使用公共变量/内存时不需要使用同步机制，因为他们在同一地址空间内

D. 因多线程里，每个子进程有自己的地址空间，因此相互之间通信时，线程不如进程灵活和方便
下列关于多态性说法不正确的是：
A. 重指函数名相同，但是参数列表个数和顺序，参数类型，以及返回类型不同

B. 重载 overload 和 重写 override 是一个意思

C. 多态行有静态和动态多态两种

D. c++中 final 关键字表示函数不能再次被override
定义析构函数时，注意：C
A. 其名与类名完全相同

B. 返回类型是void类型

C. 无形参，也不可重载

D. 函数体中必须有delete语句
C中出现如下类型的结构体定义：
typedef struct holder 
{ struct holder *next; 
struct holder *prev; 
char buffer[ 0 ]; 
}holder; 


char data[ 0 ] 作用？

A. 方便管理内存缓冲区

B. 减少内存碎片化

C. 使结构体数据对齐

D. 没有作用
对静态成员的正确描述是（）？
A. 静态数据成员要在类外定义和初始化

B. 非静态成员函数也可以操作静态数据成员

C. 全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域，局部变量存放在内存的栈区

D. 调用静态成员函数时要通过类或对象激活，所以静态成员函数拥有this指针
开讲啦！！
一、静态数据成员与静态成员函数

静态数据成员不依赖对象,依赖于类,

即:如果不实例化对象,静态数据成员在内存中仍然是存在的:
普通的数据成员必须要实例化后才能存在。
静态数据成员的初始化不能通过构造函数,往往单独进行


访问静态成员有两种方式:

不通过对象而直接通过类
通过对象调用



# include <iostream>

class Tank 
{
public:
	Tank() { s_iCount++; }
	~Tank() { s_iCount--; }
	static int getCount() { return s_iCount; }
	static int s_iCount;
private:
	std::string m_strCode;
};
int Tank::s_iCount = 0;
int main(void)
{
	std::cout << Tank::getCount() << std:: endl;
	std::cout << Tank::s_iCount<< std::endl;
	Tank tank;
	std::cout << tank.getCount() << std::endl;
	std::cout << tank.s_iCount << std::endl;
	return 0;
}

二、从内存角度看静态数据成员

在对象诞生之前,静态数据成员就已经诞生了,且只诞生一次,它的值可能发生变化,但它在内存中始终是一个

三、从this指针谈静态成员函数
四、注意事项

静态成员函数不能调用非静态成员函数和非静态数据成员
非静态成员函数则可以调用静态数据成员和静态成员函数。

参考链接

https://www.cnblogs.com/Tang-tangt/p/9677885.html

ADD R0, R1, #3属于（A）：
A. 立即寻址方式

B. 多寄存器寻址

C. 寄存器直接寻址

D. 相对寻址

单选题：

2-1

下列函数中，（ C ）不能重载。

A.成员函数

B.非成员函数

C.析构函数

D.构造函数
2-2

下列对重载函数的描述中，（ A ）是错误的。

A.重载函数中不允许使用默认参数

B.重载函数中编译根据参数表进行选择

C.不要使用重载函数来描述毫无相干的函数

D.构造函数重载将会给初始化带来多种方式
2-3

在下面类声明中，关于生成对象不正确的是（ C ）。
class point
{ public:
int x;
int y;
point(int a,int b) {x=a;y=b;}
}; 

A.point p(10,2);

B.point *p=new point(1,2);

C.point *p=new point[2];

D.point *p[2]={new point(1,2), new point(3,4)};
2-4

设A为自定义类，现有普通函数int fun(A& x)。则在该函数被调用时（ C ）

A.将执行复制构造函数来初始化形参x

B.仅在实参为常量时，才会执行复制构造函数以初始化形参x

C.无需初始化形参x

D.仅在该函数为A类的友元函数时，无需初始化形参x
2-5

所有类都应该有 ( C )

A.构造函数

B.析构函数

C.构造函数和析构函数

D.以上答案都不对
2-6

析构函数可以返回 ( D )

A.指向某个类的指针

B.某个类的对象

C.状态信息表明对象是否被正确地析构

D.不可返回任何值
2-7

下列属于类的析构函数特征的是 ( A )

A.一个类中只能定义一个析构函数

B.析构函数名与类名不同

C.析构函数的定义只能在类体内

D.析构函数可以有一个或多个参数
2-8

建立一个类对象时，系统自动调用 ( A )

A.构造函数

B.析构函数

C.友元函数

D.成员函数
2-9

下列关于类定义的说法中，正确的是 ( A )

A.类定义中包括数据成员和函数成员的声明

B.类成员的缺省访问权限是保护的

C.数据成员必须被声明为私有的

D.成员函数只能在类体外进行定义
2-10

下列关于类和对象的叙述中，错误的是 ( A )

A.一个类只能有一个对象

B.对象是类的具体实例

C.类是对某一类对象的抽象

D.类和对象的关系是一种数据类型与变量的关系