c语言面试笔试易错题,牛客刷题：笔试常考题和易错题（长期更新）

1，C++中为什么用模板类的原因？(即模板类的优点)

(1)可用来创建动态增长和减小的数据结构

(2)它是与类型无关的，因此具有很高的可复用性

(3)它在编译时而不是在运行时检查数据类型，保证了类型安全

(4)它是与平台无关的，有很强的可移植性

(5)可用于基本数据类型

2,以下程序的输出结果是什么？

int main()

{

int a = 1, b = 2, c = 3, d = 0;

if (a == 1 && b++ == 2)

{

if (b != 2 || c-- != 3)

{

cout << a << " " << b << " " << c << endl;

}

else

{

cout << a << " " << b << " " << c << endl;

}

}

else

{

cout << a << " " << b << " " << c << endl;

}

system("pause\n");

return 0;

}

这道题中与两点需要注意，(1)后置++是先使用再++；(2)||运算和&&运算的短路问题，||：当第一个条件为真时，则后面条件不执行。&&：当第一个条件不成立时，则后面的都不执行。因此，这道题第二个if语句，结果是1 3 3

3，以下代码中，a和b的地址相同吗，为什么？p1和p2地址相同吗，为什么？

int main()

{

int a = 1, b = 2, c = 3, d = 0;

if (a == 1 && b++ == 2)

{

if (b != 2 || c-- != 3)

{

cout << a << " " << b << " " << c << endl;

}

else

{

cout << a << " " << b << " " << c << endl;

}

}

else

{

cout << a << " " << b << " " << c << endl;

}

system("pause\n");

return 0;

}

大家先看调试结果

a和b地址不同，p1和p2地址相同，原因是a和b是在栈空间的两个字符数组，地址不同，p1和p2指向的位置在常量区，值都是abcde，所以是同一常量，地址相同。

4，若Myclass是一个类名，则如下语句中调用构造函数的个数是？

Myclass c1,*c2;

Myclass *c3 = new Myclass;

Myclass &c4 = c1;

c1调用一次构造函数，c2是一个指针，用来动态描述对象，不会调用类的构造函数，c3的右边新创建一个对象会调用构造函数，但是注意，这里的赋值运算符不是类中的赋值运算符，而是普通的赋值运算符。c4是一个对象引用，是c1的一个别名，所以不会调用构造函数。

5，传地址或引用时，形参与实参都有相同的地址，传值调用时，只是将数据进行了复制，不会改变实参的值。

6，以下代码，sizeof(list_t) = ?

tyedef struct list_t

{

struct list_t *next;

struct list_t *prev;

char data[0];//柔性数组

}list_t;

柔性数组，把单一元素的数组放在一个struct的尾端，使得每个struct对象可以拥有可变大小的数组，柔性数组不占空间，只是作为一个符号地址存在。所以，sizeof(list_t) = 8

7,在C++中，下面代码的执行结果是？

int main()

{

const int i = 0;

int *j = (int *)&i;

*j = 1;

printf("%d,%d",i,j);

system("pause\n");

return 0;

}

这段代码在C++中的结果是0，1；在C语言中的结果是1，1；原因如下：

C语言中的const是运行时const，编译时只是定义。

而C++中，const变量是编译时的常量，可以像#define定义的常量一样使用，故C++中，const变量额值在编译时就已经确定了，直接对const变量进行了值的替换。

8，下面代码的输出结果是什么？

int main()

{

int a[3];

a[0] = 0, a[1] = 1, a[2] = 2;

int *p, *q;

p = a;

q = &a[2];

cout << a[q - p] << endl;

system("pause\n");

return 0;

}

指针间相减是其地址空间的距离，我用图来解释这道题:

9,C++中，为了让某个类只能通过new来创建(即如果直接创建对象，编译器会报错)，应该(将析构函数设为私有)。

编译器在为类对象分配栈空间时，会先检查类的析构函数的访问属性，其实不光是析构函数，只要是非静态的函数，编译器就会进行检查，如果类的析构函数是私有的，则编译器不会在栈上为类对象分配内存，因此，将析构函数设为私有，类对象就无法建立在栈(静态)上了，只能在堆上(动态new)分配类对象。

10，来看以下代码

class A

{

public:

virtual void print()

{

cout << "A::print()" << endl;

}

};

class C :public A

{

public:

virtual void print()

{

cout << "C::print()" << endl;

}

};

class B :public A

{

public:

virtual void print()

{

cout << "B::print()" << endl;

}

};

void print(A a)

{

a.print();

}

int main()

{

A a, *aa, *ab, *ac;

B b;

C c;

aa = &a;

ab = &b;

ac = &c;

a.print();

b.print();

c.print();

aa->print();

ab->print();

ac->print();

print(a);

print(b);

print(c);

system("pause\n");

return 0;

}

输出结果与分析如下

11，请分析以下代码的输出结果

void f(char* x)

{

x++;

*x = 'a';

}

int main()

{

char str[sizeof("hello")];

strcpy(str, "hello");

f(str);

cout << str<< endl;

system("pause\n");

return 0;

}

输出结果为hallo，f函数的作用是将字符串第二个字符替换成a,由于函数是值传递，不影响指针指向，所以str指针还是从字符串开头开始的。

12，以下 代码的输出结果是？

static int a = 1;

void fun1()

{

a = 2;

}

void fun2()

{

int a = 3;

}

void fun3()

{

static int a = 4;

}

int main()

{

printf("%d", a);

fun1();

printf("%d", a);

fun2();

printf("%d", a);

fun3();

printf("%d\n", a);

system("pause\n");

return 0;

}

输出结果为1 2 2 2，通过分步调试可以看到每一个printf语句中的a地址都是全局变量a的地址。第一个printf输出全局变量a = 1,在调用fun1()时，全局变量a的值被修改为2，而调用其他函数时，a为每个函数的局部变量，出了其作用域即被销毁。因此printf输出的都是全局变量a的值。

13，关于PA、PB、PC的取值，以下说法正确的是？

class A

{

public:

virtual void FunTestA()

{}

};

class B

{

public:

virtual void FunTestB()

{}

};

class C :public B, public A

{

virtual void FunTestC()

{}

};

int main()

{

C c;

A* pA = &c;

B* pB = &c;

C* pC = &c;

system("pause");

return 0;

}

A,pA、pB、pC的取值相同

B,pC和pA不相同

C,pB和pB不相同

D,pC不等于pA,也不等于pB

正确答案选B

14,若已定义：int a[9],*p = a;并在以后的语句中未改变p的值，不能表示a[1]地址的表达式是：

A,++p

B,a+1

C,p+1

D,a++