牛客网 C++ 笔试题----刷题笔记

单选题

1.若用数组名作为函数调用时的实参，则实际上传递给形参的是（D）

A 数组元素的个数

B 数组的第一个元素值

C 数组中全部的元素值

D 数组的首地址

2.在 int a=3,int *p=&a; 中，*p 的值是 （D）

A 变量a的地址值

B 无意义

C 变量p的地址值

D 3

3.下列数据结构使用内存空间最小的是 （B）

A.struct Channel {int ChannelIndex; float ChannelProtocol; };

B.union U_Info { char x;float y;int v;};

C.char Red[10];

4.unsigned char数据类型表示的数值范围是 (B)

A.-127~128

B.0~255

C.0~256

D.-127~127

5.下列运算符优先级最高的是(C)

A.&&

B.||

C.!

6.在C语言中，实参与其对应的形参各占独立的存储单元(A)

A.正确

B.不正确

7.下列哪个编译指令属于条件编译指令 (C)

A #include

B #define

C #else

D #pragma

8.下面4个定义中，哪个是错误的 (C)

A char a[9];

B int b[3];

C int n=5, c[n];

D #define N 5 long d[N]

9.程序段 int n=0; while(n=1) n++; while 循环执行的次数是( D) 

A 执行0次

B 执行1次;

C 有语法错误，不能执行;

D 执行无限次;

10. 请选择下面程序的输出结果  (A)

main(){

        int a[5]={1,2,3,4,5};

        int * ptr=(int*)(&a+1); printf(“%d，%d”,*(a+1),*(ptr-1)); 

}

A 2,5

B 2,1

C 1,5

D 1,1

11.分配内存正确的是 (A)

A char *a=new char[20];

B char a=new char[20];

C char a=new char(20.0);

12.以下哪种变量在栈上分配空间 (D)

A 静态变量

B 通过malloc创建

C 全局变量

D 局部变量

13.下列有关宏替换的描述不正确的是 (A)

A 宏名必须用大写子母表示

B 宏替换不占用运行时间

C 宏替换只是字符替换

D 宏名无类型

14.char s[] = "12345";  int m = sizeof(s); (D)

A 1

B 4

C 5

D 6

15.在32位小端系统中， int a = 0x12345678;unsigned char* pa = (unsigned char*)&a; pa[0]的值是（C）

A 0x1

B 0x12

C 0x78

D 0x8

小端存储:低位存放在低地址(高位存放在高地址) 大端存储:低位存放在高地址(高位存放在低地址)

16.若有定义:int a=7;float x=2.5,y=4.7;则表达式x+a%3*(int)(x+y)%2/4的值是 （A）

A 2.5

B 2.75

C 3.5

D 0

17.判断两个字符串S1和S2相等，应该使用(C) 

A if(s1 == s2)

B if(s1 = s2)

C if(!strcmp(s1,s2))

D if(strcmp(s1,s2))

strcmp不是比较两个字符串的长度，是比较两个字符串的ascll码

strcmp函数当s1>s2的时候返回大于0的数

当s1=s2的时候，返回0

当s1

18.下列字符串为合法标识符的是 (A)

A._1_A

B.5_stu

C.$char

D.static

19.下列表达式为true的是 (B)

A 100 > 3 && 'a'>'c'

B 100 > 3 || 'a'>'c'

C !(100>3)

20.若定义:int a[2][3]={1,3,5,7,9,11},以下描述正确的是 (A)

A *(a+1)为元素7的地址

B (a[1]+1)的值是5

C **(a +1)+2值是11

D a[0]和a不同

一维数组和二维数组的关系

1.a[i]==&a[i][0]

2.a[i]+j==&a[i][j]

21.判断变量a中的字符是否为大写字母，最简单的正确表达式是 (A)

A a>=’A’&&a<=’Z’

B A <= a <= Z

C ‘A’ <= a <= ‘Z’

D a >= A && a <= Z

22.若有格式输入函数 scanf("%d%d%d", &x, &y, &z)，输入数据时不能使用(B )作为数据的分隔 2分 符。 

A 空格

B 逗号

C TAB(制表符)

D 回车

23.void main (void) { 2分 

int a[]={4,5,6,7,8};

int *p = a;

*p++=100;

printf(“%d %d\n” , *p,*(++p)); }

程序完成后输出什么?(C)

A 6 6

B 100 6

C 5 6

D 100 5

24.如果变量a是一个数组，a++是否合法. (B)

A 合法

B 不合法

25.若有下列定义，则对 a 数组元素地址的正确引用是( B)。 int a[5],*p=a;

A &a[5]

B p+2

C a++

D &a

27.下面代码的执行后的结果是(A ) 

int main(){

        int x,a=1,b=2,c=3,d=4; 

        x=(ax)?x:d; 

        printf(“%d\n”,x);

}

A 1

B 2

C 3

D 4

28.下面程序的输出是(B)

void t_left(int dir){

        dir = (dir - 1);

}

void t_right(int *p_dir){

        *p_dir = (*p_dir + 1);

}

int main() {

        int dir1 = 3, dir2 = 3;

         t_left(dir1);

        t_right(&dir2);

        printf(“%d %d”,dir1,dir2); return 0;

}

A 3 3

B 3 4

C 2 3

D 2 4

29.C库函数中malloc依赖下面哪个系统调用增长堆空间? (C)

A open

B ioctl

C sbrk

D write

30.下面哪种排序法对12354最快 (B)

A quick sort

B bubble sort

C merge sort

31.下列静态成员的特性中（  B ）是错误的

A. 静态数据成员要在类体外进行定义
B. 静态数据成员不是所有对象所共有的
C. 说明静态成员时，要加修饰符 static
D. 引用静态数据成员时，要在静态数据成员名前加<类名::>

【解析】静态数据成员是类的成员，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。

32、重载函数在调用时选择的依据（B）是错误的
A. 参数的顺序
B. 参数的返回值类型
C. 参数的个数
D. 参数的类型

【解析】函数返回值类型可以相同也可以不同

33、在下面有关析构函数的描述中，正确的是（ C ）

A. 析构函数名与类名完全相同
B. 一个类中可以定义多个析构函数
C. 析构函数不能指定返回类型
D. 析构函数可以有一个或多个参数

【解析】析构函数没有参数，也没有返回类型，仅有析构函数，不存在重载函数

34、关于new运算符的下列描述中，（ B ）是错的。
A. 使用它创建的对象或对象数组可以使用delete运算符删除
B. 使用它创建对象数组，必须指定初始值
C. 它可以用来动态创建对象和对象数组
D. 使用它创建对象时要调用构造函数
【解析】使用new创建对象数组或一般数组时,不能为该数组指定初始值,其初始值为默认值

35、下列关于构造函数的论述中，不正确的是（ D ）
A. 构造函数可以设置默认参数
B. 构造函数可以重载
C. 构造函数的函数名与类名相同
D. 构造函数的返回类型缺省为int

【解析】来自这篇博客的解析C++（基础）每日一题 9_下列静态数据成员的特性中,( )是错误的 a.引用静态数据成员时,要在静态数据成员名_清和的院子的博客-CSDN博客

a).构造函数在实例化对象时自动被调用，且在每个对象的生命期仅被调用一次。
b) 可以被重载。
c).若程序员没有主动给类定义构造函数，编译器自动给””.个缺省的构造函数。
d).旦程序员定义了 一个构造函数，系统将不会再给出缺省构造函数。
e).除了系统缺省的构造函数外，只要构造函数无参或者参数有缺省值，编译器会认为它就是缺省构造函数。 缺省的构造函数同时只能有1个。

36.下列关于静态数据成员的描述中正确的是(B) 

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

B 静态数据成员要在构造函数内初始化

C 类的每个对象有自己的静态数据成员

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

【解析】

作者：牛客957538674号
链接：https://www.nowcoder.com/exam/test/71866724/submission?pid=48310137&pageSource=testHistory
来源：牛客网

A：该选项是正确的。静态数据成员是编译阶段就分配好内存的，不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有属于这个类的所有对象共享

B：该选项是错误的。静态成员变量必须在类中声明，在类外初始化。类内初始化会报错。注意：也可以通过构造函数初始化，但不建议，因为如果通过类名方式来访问静态成员变量，由于没有创建对象，也就不会调用构造函数，自然静态成员变量就做不到初始化要求。

C：该选项是错误的。静态数据成员只有一份拷贝，被该类的所有对象所共享。

D：该选项是错误的。静态成员变量或静态成员函数，都有两种方式访问。第一种：通过实例化对象进行访问。第二种：通过类名直接访问。

37.下列有关重载函数的说法中正确的是(C) 

A 重载函数必须具有不同的返回值类型

B 重载函数参数个数必须相同

C 重载函数必须有不同的形参列表

D 重载函数名可以不同

38.在C++语言中，数据封装要解决的问题是(D） 

A 数据的规范化

B 便于数据转换

C 避免数据丢失

D 防止不同模块之间数据的非法访问

39.void set(Sample& a)，则Sample& a的含义是(B) 

A 指向类Sample的名为a的指针

B a是类Sample的对象引用，用来作函数Set()的形参

C 将a的地址赋给变量Set

D 变量Sample与a按位与的结果作为函数Set的参数

40.假定一个类的构造函数为A(int aa,int bb){a=aa++;b=a*++bb;}，则执行A x(5,5);语句 后，x.a和x.b的值分别为(C)

A 5和5

B 5和25

C 5和30

D 25和5

41.派生类的对象可以访问以下那种情况继承的基类成员 (D)

A 私有继承的私有成员

B 公有继承的私有成员

C 私有继承的保护成员

D 公有继承的公有成员

【解析】无论是什么继承方式，派生类的对象只能访问基类中的公有成员。

42.下列关于析构函数描述正确的是 （D）

A 可以重载

B 函数体中必须有delete语句

C 返回类型必须是void类型

D 不能指定返回类型

43.对基类和派生类的关系描述中，错误的是 （B）

A 派生类是基类的具体化

B 基类继承了派生类的属性

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

D 派生类是基类的特殊化

44.假设Class Y:public X，即类Y是类X的派生类，则说明一个Y类的对象时和删除Y类对象时，调用构造函数和析构函数的次序分别为（A）

A X,Y;Y,X

B X,Y;X,Y

C Y,X;X,Y

D Y,X;Y,X

45.假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（B）

A x.a

B x.a()

C x->a

D (*x).a()

【解析】:对象访问成员的方式为:对象名.成员。指针可以有两种:(*对象指针).成员或者对

象指针->成员。A选项是访问数据成员,B项是访问成员函数。

46.要禁止修改指针p本身，又要禁止修改p所指向的数据，这样的指针应定义为 （D）

A const char *p=“ABCD”;

B char *const p=“ABCD”;

C char const *p=“ABCD”;

D const char * const p=“ABCD”;

47.关于类模板的说法正确的是: （）

A 类模板的主要作用是生成抽象类

B 类模板实例化时，编译器将根据给出的模板实参生成一个类

C 在类模板中的数据成员具有同样类型

D 类模板中的成员函数没有返回值

48.下列函数模板的定义中，合法的是 （A）

A templateT abs(T x){return x<0?-x:x;}

B template classT abs(T x){return x<0 ?-x:x;}

C template T abs(T x){return x<0 ?-x:x;}

D template T abs(T x){return x<0 ?-x:x;}

49.有如下程序：

#include  
using namespace std; 
class Sample
{
    friend long fun(Sample s); 
public:
    Sample(long a ) {x=a;}
private:
    long x;
};
long fun(Sample s)
{
    if(s.x<2) 
        return 1;
    return s.x*fun(Sample(s.x -1));
}
int main()
{
    int sum=0;
    for(int i=0;i<6;i++){sum+=fun(Sample(i));} 
    cout<

【解析】

                                                                  sum=0                             

i=0                     sum+=1                           sum=1

i=1                     sum+=1                           sum=2

i=2                     sum+=2*1                        sum=4

i=3                     sum+=3*(2*1)                  sum=10

i=4                     sum+=4*(3*2*1)               sum=34

i=5                     sum+=5*(4*3*2*1)            sum = 154

50.观察下面一段代码

class ClassE{
public:
virtual 〜ClassE(){};
virtual void FunctionE(){};
};
class ClassF{
public:
virtual void FunctionF(){};
};
class ClassG : public ClassE, public ClassF{}; ClassG aObject; //语句1
ClassE* pE=&aObject;
ClassF* pF=&aObject;
ClassG* pG=&aObject;

关于pE，pF，pG的取值，下面的描述中正确的是(C)。

A pE，pF，pG的取值相同

B pG=pE+pF

C pE和pF不相同

D pG不等于pE也不等于pF

51.观察下面一段代码

class ClassE{
public:
virtual 〜ClassE(){};
virtual void FunctionE(){};
};
class ClassF{
public:
virtual void FunctionF(){};
};
class ClassG : public ClassE, public ClassF{}; ClassG aObject; //语句1
ClassE* pE=&aObject;
ClassF* pF=&aObject;
ClassG* pG=&aObject;
ClassE* pE2;

下面正确的代码是（D）

A pE2=static_cast(pF);

B void*pVoid=static_cast(pF); pE2=static_cast(pVoid);

C pE2=pF;

D pE2=static_cast(static_cast(pF));

52.观察下面一段代码。  

class ClassE{
public:
virtual 〜ClassE(){};
virtual void FunctionE(){};
};
class ClassF{
public:
virtual void FunctionF(){};
};
class ClassG : public ClassE, public ClassF{}; 
ClassG aObject; //语句1
ClassE* pE=&aObject;
ClassF* pF=&aObject;
ClassG* pG=&aObject;
ClassE* pE2;

将语句1改为如下代码

ClassG aObject=new ClassG; 则下面哪一个语句是不安全的(B)

A delete pE

B delete pF

C delete pG

【个人解析】基类的析构函数要声明为虚函数，否则当使用基类的指针释放派生的对象时，派生类对象只会释放基类的部分，造成内存泄露

53.在下列关于类型转换的描述中，错误的是（A）

A 任何形式的构造函数都可以实现数据类型转换

B 带非默认参数的构造函数可以把基本类型数据转换成类类型对象

C 类型转换函数可以把类类型对象转换为其他指定类型对象

D 类型转换函数只能定义为一个类的成员函数，不能定义为类的友元函数

54.在C++中，为了让某个类只能通过new来创建(即如果直接创建对象，编译器将报错)，应该（） 

A 将构造函数设为私有

B 将析构函数设为私有

C 将构造函数和析构函数均设为私有

55.给出下面定义:  char a[]=”abcd”;char b[]={‘a’,’b’,’c’,’d’}; 则下列说法正确的是(C )

A 数组a与数组b等价

B 数组a和数组b的长度相同

C 数组a的长度大于数组b的长度

D 数组a的长度小于数组b的长度

56.一个类的友元函数可以访问类的( D)成员。 

A 私有成员

B 保护

C 公有

D 其他都正确

57.设置虚基类的声明中，正确的是( B) 

A 简化程序

B 消除二义性

C 提高运行效率

D 减少目标代码

58.决定C++语言中函数的返回值类型的是(D ) 

A return语句中的表达式类型

B 调用该函数时系统随机产生的类型

C 调用该函数时的主调用函数类型

D 在定义该函数时所指定的数据类型

59.为了提高程序的运行速度，可将不太复杂的功能用函数实现，此函数应选择( A) 

A 内联函数

B 重载函数

C 递归函数

D 函数模板

60. this指针存在的目的是( C) 

A 保证基类私有成员在子类中可以被访问

B 保证基类保护成员在子类中可以被访问

C 保证每个对象拥有自己的数据成员，共享处理这些数据成员的代码

D 保证基类公有成员在子类中可以被访

61.已知:char a ; float b ; double c ; 则执行语句:c = a + b + c; 后变量c的类型为(D ) 

A char

B float

C int

D double

62.设已有说明语句“in a=5;”，则执行语句“a+=a*=a%=3;”后，a的值为 ( A) 

A 8

B 18

C 0

D 2

63.下列情况中，不会调用拷贝构造函数的是( B) 

A 用一个对象去初始化同一类的另一个新对象时

B 将类的一个对象赋值给该类的另一个对象时

C 函数的形参是类的对象，调用函数进行形参和实参结合时

D 函数的返回值是类的对象，函数执行返回调用时

解析:拷贝构造函数是一个特殊的构造函数,它用一个已知的对象初始化一个正在创建的同类对象,它的一般格式是:类名::类名(const类名&引用对象名)。当一个类的对象赋值给该类的另一个对象时,是赋值而不是创建对象,所以不会调用拷贝构造函数。

64.其中存在语法错误的是(D )

class Foo  {
public:
    Foo(int v) : value(v) {} //1 ~Foo(){}
private:
    Foo(){} //2
    int value = 1; //3 
    static int type = 0; //4
};

A 1

B 2

C 3

D 4

65.若运行程序，请选出表达正确的选项。(CD)

#include  

using namespace std;

int main() {

    int a=9;

    auto fun1=[=]{return ++a;};//代码片段1

    auto fun2=[&]{return ++a;};//代码片段2

    auto fun2=[=]()mutable{return ++a;};//代码片段3 

    return 0;

}

A 代码片段2运行错误。 B 代码片段3运行错误。 C 代码片段3运行正确。 D 代码片段1报错，编译报错，error: increment of read-only variable ‘a’

66.若运行程序，请选出表达正确的选项（ABCD）

#include  
using namespace std;
int main() {
    int a=9;
    auto fun1=[=]()mutable{return ++a;}; 
    cout<<"fun1:"<

A 打印的结果里面包含了如下语句: fun1:10

B 打印的结果里面包含了如下语句: a:9

C 打印的结果里面包含了如下语句: 0 fun2:10

D 打印的结果里面包含了如下语句: 1 fun3:11

func1:10
a:9
func2:10
func3:10
++a执行后:a=10
func2:10 (9+1=10)
func3:11 (10+1=11)

64.auto_ptr 类使用必须满足下列限制:( ABCD) 

A 不要使用 auto_ptr 对象保存指向静态分配对象的指针

B 不要使用两个 auto_ptrs 对象指向同一对象

C 不要使用 auto_ptr 对象保存指向动态分配数组的指针

D 不要将 auto_ptr 对象存储在容器中

65.可以使用memset，memcpy直接进行初始化和拷贝的有:( ABD) 

A 结构

B 枚举

C 类实例

D 指针

66.2个同名成员函数，可以重载的是(BC ) 

A int A::f() 和double A::f()

B void A::f(int) 和void A::f(short)

C void A::f() 和void A::f() const

D void A::f(int) 和void A::f(const int)

67.若有以下定义:“int x[2][3];”,能正确表示x数组元素地址的表达式是(BD ) 

A &x[2][3]

B x[0]

C x[2]

D x[1]

68.若有如下的定义 ，则下列表达式中，正确的是(ABD)  

class sam{     
public:      
    int num;       
    void print(){cout< < num;}     
}x,*p=&x; 

A (*p).print( )

B p->num=10

C p.num

D x.num=5

69.两个线程并发执行以下代码，假设a是全局变量，那么以下输出(ABCD)哪个是可能的

int a=1;

void foo(){ 

    ++a; 
    printf("%d",a);

}

A 3 2

B 2 3

C 3 3

D 2 2

70.下列哪两个数据结构，同时具有较高的查找和删除性能?(CD)

A 有序数组

B 有序链表

C AVL树

D Hash 表

71.正确的是(AC)  

char a = 'a';  
int b = static_cast(a);//语句A
double *c = new double;
void *d = static_cast(c);//语句B
int e = 10;
const int f = static_cast(e);//语句C
const int g = 20;
int *h = static_cast(&g);//语句D
class Base {};
class Derived : public Base {}
Base* pB = new Base();
if(Derived* pD = static_cast(pB)) {}//语句E
Derived* pD = new Derived(); 
if(Base* pB = static_cast(pD)) {}//语句F

A 语句ABCF正确

B 语句ADE正确

C 语句DE错误

D 语句ABCD正确

72.问题描述:
将两个从小到大排序好的列表合并成一个新的从小到大排序的列表 ，请用链表方式实现。
输入描述: 两个从小到大排序好的有符号整型列表(假定两个列表的分别有10个有符号整型数据)
输出描述: 按从小到大排序好的合并数据列表
输入样例:
2 4 7 8 10 33 44 55 56 60

1 3 6 11 15 21 47 49 50 51
输出样例:
1 2 3 4 6 7 8 10 11 15 21 33 44 47 49 50 51 55 56 60

#include  
#include  
#include 
#define InputArraySize 10
 
void ArrayMerge (int Array1[], int Array1Size, int Array2[], int Array2Size, int Array3[]) {
    int m = 0, n = 0;
    int TotalSize = Array1Size + Array2Size;
    if (Array1Size < 0 || Array2Size < 0) 
        return;
    else if (Array1Size == 0 || Array2Size == 0) { 
        for (int i = 0; i < Array1Size; i++)
            Array3[i] = Array1[i];
        for (int i = 0; i < Array2Size; i++)
            Array3[i] = Array2[i]; }
        for (int i = 0; i < TotalSize; i++) {
            int temp1 = m > Array1Size-1 ? INT_MAX : Array1[m]; int temp2 = n > Array2Size-1 ? INT_MAX : Array2[n]; 
            if (temp1 <= temp2) {
                Array3[i] = temp1; 
                if (m > Array1Size)
                    n++; 
                else
                    m++; 
                }
            else {
                Array3[i] = temp2; n++;
            } 
        }
    return; 
}
int main () {
    int *Array1, *Array2, *Array3;
    int TotalSize = InputArraySize * 2;
    Array1 = (int *)malloc (sizeof (int) * InputArraySize); Array2 = (int *)malloc (sizeof (int) * InputArraySize); Array3 = (int *)malloc (sizeof (int) * TotalSize);
    for (int i = 0; i < InputArraySize; i++) 
        scanf ("%d", Array1 + i);
    for (int i = 0; i < InputArraySize; i++) 
        scanf ("%d", Array2 + i);
    ArrayMerge (Array1, InputArraySize, Array2, InputArraySize, Array3);
    for (int i = 0; i < 19; i++) 
        printf ("%d ", Array3[i]);
    printf ("%d\n", Array3[19]);
    free (Array1); 
    free (Array2); 
    free (Array3);
    return 0; 
}

73.问题描述:

有n(n 小于50)个人围成一圈，顺序排号。从第一个人开始循环报数(从1到4报数)，凡报到2的人退出圈子，问最后留下的是原来第几号的 那位。

#include  
void main()
{
int n;
// printf("请输入这一圈人的数量:\n");
scanf("%d",&n); //code body start
//code body end 
}

输入描述: 小于50的一个整数
输出描述: 小于或等于输入的一个整数
输入样例: 5
输出样例: 4

#include  
void main()
{
    int num[50],n,*p,j,loop,i,m,k;
    // printf("请输入这一圈人的数量:\n");
    scanf("%d",&n); 
    p=num;
    for (j=0;j