总结c++笔试题目

若有以下说明和语句，请选出哪个是对c数组元素的正确引用_______。 int c[4][5],(*cp)[5]； cp=c；
A．cp+1
B．*(cp+3)
C．*(cp+1)+3
D．*(*cp+2)

正确答案：D
解析：cp=c 这个语句是将数组第0行的地址赋给了cp。cp+1使指针指向二维数组c的第一行；*(cp+3)是数组c的第三行的第0列的地址值；*(cp+1)+3是数组c的第一行第三列的地址值。

*(*cp+2)等价于*(*(cp+0)+2)，等价于c[0][2]，代表c数组的一个元素。

9．类A中有唯一的一个成员函数f，且f是公有的静态或非静态成员函数，对于类A的一个对

象a,执行语句 a.f(100);成功，那么f 的函数原型不可以是：B 

(A) A& f( int, int=50 ); (B) void f(int& ) ; 

(C) const A * f(const int ); (D) A f( const int&); 

1.

 关键字static的作用是什么？

在C语言中，关键字static有三个明显的作用：

1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

 

2.
const最经常的用法
 1.为了防止传递的函数参数不被修改，在调用函数的形参中用const关键字.
2.const可以用来创建数组常量、指针常量、指向常量的指针等
const int a;     //前两个的作用是一样，a是一个常整型数。
int const a; 
const int *a;    //第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。
int * const a;
int const * a const; //第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。

//注：const并不会阻止参数的修改

3.
下面的代码输出是什么，为什么？

void foo(void)

{

    unsigned int a = 6;

    int b = -20;

    (a+b > 6) ? puts("> 6") : puts("<= 6");

}

//当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。

因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。

 

4.

#define dPS struct s *

typedef struct s * tPS;

以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？

这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子：

dPS p1,p2;

tPS p3,p4;

第一个扩展为

struct s * p1, p2;

.上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。晦涩的语法

 

5.int a = 5, b = 7, c;

c = a+++b;//<==>c = a++ + b;

这段代码持行后a = 6, b = 7, c = 12。

 

6.

写出判断ABCD四个表达式的是否正确, 若正确, 写出经
4000
过表达式中 a的值(3分)

int a = 4;

(A)a += (a++); (B) a += (++a) ;(C) (a++) += a;(D) (++a) += (a++);

a = ?

答：C错误，左侧不是一个有效变量，不能赋值，可改为(++a) += a;

改后答案依次为9,10,10,11

7.头文件中的 ifndef/define/endif 干什么用？预处理

答：防止头文件被重复引用

8. switch()中不允许的数据类型是?
答：实型

9.

编写strcat函数(6分)

已知strcat函数的原型是char *strcat (char *strDest, const char *strSrc);

其中strDest 是目的字符串，strSrc 是源字符串。

（1）不调用C++/C 的字符串库函数，请编写函数 strcat

答：

VC源码：

char * __cdecl strcat (char * dst, const char * src)

{

char * cp = dst;

while( *cp )

cp++; /* find end of dst */

while( *cp++ = *src++ ) ; /* Copy src to end of dst */

return( dst ); /* return dst */

}

（2）strcat能把strSrc 的内容连接到strDest，为什么还要char * 类型的返回值？

答：方便赋值给其他变量

10.

回答下面的问题(6分)

(1).Void GetMemory(char **p, int num){

*p = (char *)malloc(num);

}

void Test(void){

char *str = NULL;

GetMemory(&str, 100);

strcpy(str, "hello");

printf(str);

}

请问运行Test 函数会有什么样的结果？

答：输出“hello”

(2). void Test(void){

char *str = (char *) malloc(100);

strcpy(str, “hello”);

free(str);

if(str != NULL){

strcpy(str, “world”);

printf(str);

}

}

请问运行Test 函数会有什么样的结果？

答：输出“world”

(3). char *GetMemory(void){

char p[] = "hello world";

return p;

}

void Test(void){

char *str = NULL;

str = GetMemory();

printf(str);

}

请问运行Test 函数会有什么样的结果？

答：无效的指针，输出不确定

 

11.

程序什么时候应该使用线程，什么时候单线程效率高。

答：1．耗时的操作使用线程，提高应用程序响应

2．并行操作时使用线程，如C/S架构的服务器端并发线程响应用户的请求。

3．多CPU系统中，使用线程提高CPU利用率

4．改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独

立的运行部分，这样的程序会利于理解和修改。

其他情况都使用单线程。

12

.C++中什么数据分配在栈或堆中，New分配数据是在近堆还是远堆中？

答：栈: 存放局部变量，函数调用参数,函数返回值，函数返回地址。由系统管理

堆: 程序运行时动态申请，new 和　malloc申请的内存就在堆上

13.

int i=10, j=10, k=3; 
k*=i+j; k最后的值是？
答：60，此题考察优先级，实际写成： k*=(i+j);，赋值运算符优先级最低

14.

ICMP是什么协议,处于哪一层?

答：Internet控制报文协议，处于网络层（IP层）

15.

全局变量和局部变量在内存中是否有区别？如果有，是什么区别？

      全局变量储存在静态数据库，局部变量在堆栈。

17.

-1,2,7,28,,126请问28和126中间那个数是什么？为什么？

第一题的答案应该是4^3-1=63

规律是n^3-1(当n为偶数0，2，4)

      n^3+1(当n为奇数1，3，5)

 

18.
Heap与stack的差别。
Heap是堆，stack是栈。
Stack的空间由操作系统自动分配/释放，Heap上的空间手动分配/释放。
Stack空间有限，Heap是很大的自由存储区
C中的malloc函数分配的内存空间即在堆上,C++中对应的是new操作符。
程序在编译期对变量和函数分配内存都在栈上进行,且程序运行过程中函数调用时参数的传递也在栈上进行

19.

用宏定义写出swap（x，y）     //如果把较长的宏定义分成干行，须在待续的行末尾加上\

#define swap(x,y) \

x=x+y;\

y=x-y;\

x=x-y 

注意:结尾没有;

20

一个指针为4个字节

 int *p;

 printf("%d",sizeof(p));//输出: 4

void Func(char str[100])

{

printf("%d\n", sizeof(str));

}

答:

4

分析:

指针长度

一个32位的机器,该机器的指针是多少位

指针是多少位只要看地址总线的位数就行了。80386以后的机子都是32的数据总线。所以指针的位数就是4个字节了。

21.

main()

{

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

   int *ptr=(int *)(&a+1);    //ptr实际是&(a[5]),也就是a+5

　　 printf("%d,%d",*(a+1),*(ptr-1));

}

输出：2,5

*(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5

&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int）
int *ptr=(int *)(&a+1);  则ptr实际是&(a[5]),也就是a+5
原因如下：
&a是数组指针，其类型为 int (*)[5];
而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同 .a是长度为5的int数组指针，所以要加 5*sizeof(int)
所以ptr实际是a[5]  .但是ptr与(&a+1)类型是不一样的(这点很重要)
所以prt-1只会减去sizeof(int*)
a,&a的地址是一样的，但意思不一样，a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5].

22.
1)给定结构struct A 
{
       char t:4;
       char k:4;
       unsigned short i:8;
       unsigned long m;
};问sizeof(A) = ?

给定结构struct A 
{
       char t:4; 4位
       char k:4; 4位
       unsigned short i:8; 8位      
       unsigned long m; // 偏移2字节保证4字节对齐
}; // 共8字节

23.

//输出结果: 15

#include<stdio.h>

int main(void)

{

 char aa[10];

    printf("%d",strlen(aa));

 return 0;

}

 

24.

C和C++有什么不同?

从机制上：c是面向过程的（但c也可以编写面向对象的程序）；c++是面向对象的，提供了类。但是，

c++编写面向对象的程序比c容易

从适用的方向：c适合要求代码体积小的，效率高的场合，如嵌入式；c++适合更上层的，复杂的； llinux核心大部分是c写的，因为它是系统软件，效率要求极高。

从名称上也可以看出，c++比c多了+，说明c++是c的超集；那为什么不叫c+而叫c++呢，是因为c++比

c来说扩充的东西太多了，所以就在c后面放上两个+；于是就成了c++

C语言是结构化编程语言，C++是面向对象编程语言。

C++侧重于对象而不是过程，侧重于类的设计而不是逻辑的设计。

25 &和&&的区别。

&是位运算符。&&是布尔逻辑运算符。

26，short s1 = 1； s1 = s1 + 1；有什么错？ short s1 = 1； s1 += 1；有什么错？

short s1 = 1； s1 = s1 + 1；有错，s1是short型，s1+1是int型，不能显式转化为short型。可修改为s1 =（short）（s1 + 1） .short s1 = 1； s1 += 1正确。

27.

17.在不用第三方参数的情况下，交换两个参数的值

#include <stdio.h>

void main()

{

    int i=60;

    int j=50;

    i=i+j;

    j=i-j;

    i=i-j;

    printf("i=%d\n",i);

    printf("j=%d\n",j);

}

方法二：

i^=j;

j^=i;

i^=j;

方法三：

// 用加减实现，而且不会溢出

a = a+b-(b=a)

28.

假设你有8个球，其中一个略微重一些，但是找出这个球的惟一方法是将两个球放在天平上对比。最少要称多少次才能找出这个较重的球？

答：

2次就可以了，方法：将其分成3堆，分别是3个、3个、2个。

第一次天平两边各放3个，会有两种情况，一、两边持平一样重，那较重的球则不在里面，那就把剩下的两个称一下就能找到较重那个了。第二种情况是有一边较重，那较重的球就在较重那边的3个之中，第二次称就是就在这3个之中拿出两个来比较，也有两种情况，持平则较重的是没放进去称的那个，有一边较重则那个就是较重的。