下面对静态数据成员的描述中，正确的是?




正确答案: D   你的答案: 空 (错误)

静态数据成员可以在类体内进行初始化


静态数据成员不可以被类的对象调用


静态数据成员不受private控制符的作用


静态数据成员可以直接用类名调用


添加笔记


收藏

纠错





static数据成员必须在类体之外进行定义。通常在定义时才进行初始化。但是，当类型为const static时的整形时可以在类体内进行初始化。因此A有正确的地方，但是也有错误的情况，因此不选A。

141．下面说法中正确的是（     ）

A） 当声明的内容不同时，声明同一个名字的两个类是允许的

B） 不完全生命的类也可以实例化

C） 声明同一个名字的两个类时，要求声明的内容也相同

D）生命同一个名字的两个类是错误的

答案：D

 

142．下面对静态数据成员的描述中，正确的是（     ）

A） 静态数据成员是类的所有对象共享的数据

B） 类的没个对象都有自己的静态数据成员

C） 类的不同对象有不同的静态数据成员值

D）静态数据成员不能通过类的对象调用

答案：A

 

143．下列关于对象数组的描述中，错误的是（    ）

A） 对象数组的下标是从0开始的

B） 对象数组的数组名是一个常量指针

C） 对象数组的没个元素是同一个类的对象

D）对象数组只能赋初值，而不能在定义后赋值

答案：D

 

144．对于下面定义的类A在函数f()中将对象成员n的值修改为60的语句应该是（     ）

class A

{

public:

A(int x){n=x;}

coid SetNum(int n1){n=n1;}

private

int n;

}

int f()

}

a*ptr=new A(60);

}

A） A(60)

B） SetNum(60)

C） Ptr->SetNum(60)

D）Ptr->n=60

答案：C

 

145.关于使用const关键字修饰的对象的说法正确的是（     ）

A） 不能用一般的成员函数来访问

B） 可以用一般的成员函数来访问

C） 可以访问const成员函数及colatile成员函数

D）不能访问const 成员函数

答案：A

 

146．下面是类MyClass的定义，对定义 中各语句描述正确的是（     ）

class MyClass

   {

private:

  int X,y,Z;

public;

coid MyClass(int A、{X=a;}         file://①

int f(int a,int B)                   file://②

{

X=a;

Y=b;}

Int f(int a,int b,int c=0)                file://③

{a;

Y=b;

Z=c;}

Static coid g() {X=10;}             file://④

A） 语句①是类MyClass的构造函数定义

B） 语句②和语句③实现类成员函数的重载

C） 语句④实现对类成员变量X的更新操作

D）语句①②③和④都不正确

答案：D

 

63．友元访问类的对象的成员时使用（       ）

A） 类的成员名

B） this指针指向成员名

C） “类名：：成员名”的形式

D）“对象名.成员名”的形式

答案：D

 

147.下列程序输出的结果正确的是（      ）

＃i nclude<iostream.h>

coid fun()

{static int n=10;

n++;

cout <<”n=”<<n<<endl;

}

void main()

{

for (int I=1;I<3;I++)

cun();

}

A）n=11    n=11

B、  n=11    n=12

C、  n=10     n=11

D、  n=10     n=10

答案：B

 

148. 下面类模板的定义中，不正确的是（    ）

A） tempate<class T>

class A{T x,y;};

B） tempate<class T>

class A{private:t x;};

C） tempate<class T>

class A{public:T x;};

D）tempate<class T>

class A{protected:t x;};

答案：C

 

149. 静态成员遵循类的其他成员所遵循的访问限制，除了（     ）

A） 静态成员函数

B） 静态数据成员初始化

C） 私有静态数据成员

D）公有静态成员函数

答案：B

 

150. 空类的声明（     ）是正确

A） class类名；

B） class类名{}；

C） class类名{}

D）class类名

答案：B

 

151. 可以用“px->*p”来访问类A的对象a 的数据成员，则下面正确的是（     ）

A） px是指向类数据成员的指针

B） p是指向类数据成员的指针

C） p是指向类的对象的指针

D）无法确定指针类型

答案：B

 

152. 关于类中数据成员的生存期的说法正确的是（      ）

A） 与对象的生存期无关

B） 比对象的生存期长

C） 比对象的生存期短

D）有对象的生存期决定

答案：D

 

153. 类example 的析构函数为（     ）

Ａ）example（）；

Ｂ）example（）

Ｃ）~example（）；

D）~example（）

答案：D

 

154. 以知AA是一个类，则执行语句Aaa；后（     ）

Ａ）自动调用无参构造函数

B）自动调用有参构造函数

C、 自动调用拷贝构造函数

D、产生一个对象a,但不调用任何函数

答案：A

 

155.对于类模板tanytemp,执行语句tanytemp<int>iobject(23,32);后(    )

A、产生的模板类为 tanytemp

B、产生的模板类为 iobject

C、产生的模板类为 tanytemp<int>

D、类模板实例化对象

答案：C

 

156. 下列说法正确的是(     )

Ａ）类定义中只能说明函数成员的函数头，不能定义函数体

B、类中的函数成员只能可以在类体内定义,不可能在类体外定义

C、类中的函数成员在类体外定义时必须要与类声明在同一文件中

D、在类体外定义的函数成员不能操作该类的私有数据成员

答案：C

 

157.类的构造函数被自动调用执行的情况是在定义该类的(    )

A、 成员函数时

B、 数据成员时

C、 对象时

D、 友元函数时

答案：C

 

158.说明友元函数使用关键字(    )

A、 friend

B、 static

C、 const

D、 colatile

答案：A

 

159. 有关类的作用域.下了说法中不正确的是(    )

A、 说明类时所使用的一对花括号形成所谓的类作用域

B、 类作用域不

C、 包含类汇总成员函数的作用域

D、 类作用域中说明的标E) 识符只在类中可见

F) 在可能出现两义性的情况下,必须使用作用域限定符”::”

答案：B

 

160. 类的静态成员(     )

A、 是指B、 静态数据成员

C、 是指D、 静态函数成员

E) 为该类的所有对象共享

F) 遵循类的其他成员做遵循的所有访问权限

答案：C

 

161. 允许访问类的所有对象的私有成员,公有成员和保护成员的是(    )

A、 友元函数

B、 成员函数

C、 内联函数

D、 重载函数

答案：A

 

162. 形如X::X(X&)的构造函数称为(   )

A、 拷贝函数

B、 复

C、 制函数

D、 初始化函数

E) 拷贝初始化构造函数

答案：D

 

163.以知example是已定义的类,则程序结束前,共存在(    )个对象.

＃i nclude<example.h>

main()

{example x(5);    example arr[2]={1,2};

x=10;

x.print();

x=example(15);

x.print();

}

A、 3

B、 4

C、 7

D、 8

答案：B

 

164. 所有在函数中定义的变量,连同形式参数,都属于(   )

A、 全局变量

B、 局部变量

C、 静态变量

D、 寄存器变量

答案：B

 

165.在C++中,封状是借助于(    )达到的.

A、 结构

B、 类

C、 数组

D、 函数

答案：B

 

166. 下面不属于类的存取权限的是(   )

A、 public

B、 static

C、 protected

D、 pricate

答案：B

 

167. 指向类X中类型为type的数据成员的指针的说明形式为(    )

A、 type X::*pointer

B、 x::type*pointer

C、 type *X::pointer

D、 X::*tyoe pointer

答案：A

 

168. 已知:print()函数是一个类的常成员函数,它无返回值,下列表示中,(   )是正确的

A、 coid print() const

B、 const coid print()

C、 viod const print()

D、 coid print(const)

答案：A

 

169. 关于new运算符的下列描述中,(   )是错误的.

A、 它可以用来动态创建对象和对象数组

B、 使用它创建对象或对象数组,可以使用运算符DELETE删除

C、 使用它创建对象时要调用构造函数

D、 使用它调用对象数组时不E) 许指F) 定初始值

答案：D

 

170. 下列关于构造函数的描述中,错误的是(    )

A、 构造函数可以设置默认参数

B、 构造函数在说明类变量时自动执行

C、 构造函数可以对静态数据成员进行初始化

D、 够找函数可以重载

答案：C

 

172. 运算符delete删除一个动态对象时(     )

A、 首先为该动态对象调用构造函数,在释放其占用的内存

B、 首先释放该动态对象占用的内存,在为其调用构造函数

C、 首先为该动态对象调用析构函数,在释放其占用的内存

D、 首先释放动态对象占用的内存,在为其调用析构函数

答案：C

 

174． 下面关于纯虚函数和抽象类的描述中，（   ）是错误的。

A） 纯虚函数是一种特殊的虚函数，B） 它没有具体意义

C） 一个基类中说明有纯虚函数，D） 该基类的派生类一定不E） 再是抽象类

F） 抽象类只能作为基类来使用，G） 其纯虚函数的定义由派生类给出

H） 抽象类是指I） 具有纯虚函数的类

答案：B

 

175． 对虚函数的调用（    ）。

A） 一定使用动态联编

B） 一定使用静态联编

C） 必须使用动态联编

D） 不一定使用动态联编

答案：D

 

176． 若类A和类B的定义如下：

class A

{

  int i,j;

  public:

void get();

file://…

};

class B:A//默认为私有派生

{

int k;

  public;

void make();

file://…

};

void B:: make()

{

  k=i*j;

}

则上述定义中，（     ）是非法的表达式。

A）void get();

B）int k;

D）void make();

D）k=i*j;

答案：D

 

177．下列描述中，（    ）是抽象类的特性。

A）可以说明虚函数

B）可以定义友元函数

C）可以进行构造函数重载

D）不能说明其对象

答案：D

 

178．在多继承中，公有私生和私有派生对于基类成员的派生类中的可访问性与单继承的规则（     ）。

A）完全相同

B）完全不同

C）部分相同，部分不同

D）以上都不对

答案：A

 

179．（    ）是一个在基类中说明虚函数，它在该基类中没有定义，但要求任何派生类中的可访问性的规定是相同的。

A）纯虚函数

B）虚析构函数

C）虚构造函数

D）静态成员函数

答案：A

 

180．下列对派生类的描述中，（     ）是错误的。

A）一个派生类可以作另一个派生类的基类

B）派生类至少有一个基类

C）派生类的成员除了它自己的成员外， 包含了它的基类的成员

D）派生类中继承的基类成员的访问权限到派生类保持不变

答案：D

 

181．实现运行时的多态性要使用（     ）。

A）构造函数

B）析构函数

C）重载函数

D）虚函数

答案：D

 

182．派生类的对象对它的基类成员中（    ）是可以访问的。

A）公有继承的公有成员

B）公有继承的私有成员

C）公有继承的保护成员

D）私有继承的公有成员

答案：A

 

183．关于函数的描述中，（     ）是正确的。

A）派生类的虚函数与基类的虚函数具有不同的参数个数和类型

B）基类中说明了虚函数后，派生类中其对应的函数一定要说明为虚函数

C）虚函数是一个成员函数

D）虚函数是一个static类型的成员函数

答案：C

 

184．对基类和派生类的关系描述中，（     ）是错误的。

A）派生类是基类的具体化

B）派生类是基类的子集

C）派生类是基类定义的延续

D）派生类是基类的组合

答案：B

 

185．关于动态联编的下列叙述中，（     ）是错误的。

A）动态联编是以虚函数为基础的

B）动态联编调用虚函数操作是指向对象的指针或引用

C）动态联编是在运行时确定所调用的函数代码的

D）动态联编是在编译时确定操作函数的

答案：D

 

186．派生类的构造函数的成员初始化列表中，不能包含（    ）。

A）基类的构造函数

B）派生类中子对象的初始化

C）基类的子对象初始化

D）派生类中一般数据成员的初始化

答案：C

 

187．如果一个类至少有一个纯虚函数，那么就称该类为（     ）。

A）抽象类

B）派生类

C）纯基类

D）以上都不对

答案：A

 

188．设置虚基类的目的是（    ）。

A）简化程序

B）消除二义性

C）提高运行效率

D）减少目标代码

答案：B

 

189．在下面程序中，编译时出现的错误是（    ）。

class A                             file://(1)

{

  public;                           file://(2)

  A()

  {

    func();                         file://(3)

  }

  virtual void func()=0;               file://(4)

};

A）(1)

B）(2)

C）(3)

D）(4)

答案：C

 

190．关于多继承二义性的描述中，错误的是（    ）。

A）一个派生类的基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性

B）解决二义性的最常用的方法是对成员名的限定法

C）基类和派生类同时出现的同名函数，也存在二义性问题

F） 一个派生类是从两个基类派生出来的，G） 而H） 这两个基类又有一个共同I） 的基类，J） 对该基类成员进行访问时，K） 可能出现二义性

答案：C

 

文章目录
关于多线程与多进程编程，下面描述正确的是：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. 相对寻址