整理的C、C++面试题

>> 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

#defineSECONDS_PER_YEAR (60 * 60 * 24 * 365)UL

>> 写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。

#define MIN(A,B)((A) <= (B) ?(A) : (B))

>> 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？

第一个方案是用 while

while(1)

{

}

第二个方案是用 for

for(;;)

{

}

第三个方案是用 goto

Loop:

...

goto Loop;

 

>> 用变量a给出下面的定义

a) 一个整型数（An integer）

b) 一个指向整型数的指针（A pointer to an integer）

c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointerto a pointer to an integer）

d) 一个有10个整型数的数组（Anarray of 10 integers）

e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）

f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（Apointer to a function that takes an integer as an argument and returns aninteger）

h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argumentand return an integer ）

答案是：

a) int a; // Aninteger

b) int *a; // Apointer to an integer

c) int **a; // Apointer to a pointer to an integer

d) int a[10]; // Anarray of 10 integers

e) int *a[10]; //An array of 10 pointers to integers

f) int (*a)[10]; //A pointer to an array of 10 integers

g) int (*a)(int);// A pointer to a function a that takes an integer argument and returns aninteger

h) int(*a[10])(int); // An array of 10 pointers to functions that take an integerargument and return an integer

 

>> 关键字static的作用是什么？

这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：

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

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

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

（1）设置变量的存储域，函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；

（2）限制变量的作用域，在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；

（3）限制函数的作用域，在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
（4）在类中的static成员变量意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见；
（5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

 

>> const关键字至少有下列n个作用：

　　（1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；

　　（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；

　　（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；

　　（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；

 

>> 关键字volatile有什么含意 并给出三个不同的例子。

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

1). 并行设备的硬件寄存器（如：状态寄存器）

2). 一个中断服务子程序中会访问到的非自动变量(Non-automaticvariables)

3). 多线程应用中被几个任务共享的变量

 

? 1).一个参数既可以是const还可以是volatile吗？解释为什么。

是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

? 2).一个指针可以是volatile 吗？解释为什么。

是的。尽管这并不很常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时。

? 3).下面的函数有什么错误：

int square(volatileint *ptr)

{

return *ptr * *ptr;

}

答：由于*ptr的值可能在两次取值语句之间发生改变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr)

{

int a;

a = *ptr;

return a * a;

}

 

>> 堆和栈的区别？

栈区（stack）- 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

堆区（heap） - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收 。

1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。

2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。

3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

 

>> C和C++有什么不同?

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

c++编写面向对象的程序比c容易从适用的方向：c适合要求代码体积小的，效率高的场合，如嵌入式；c++适合更上层的，复杂的；

llinux核心大部分是c写的，因为它是系统软件，效率要求极高。C语言是结构化编程语言，C++是面向对象编程语言。

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

 

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

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

 

>> ＃include 和 ＃i nclude “filename.h”有什么区别？

答：前者用来包含开发环境提供的库头文件，后者用来包含自己编写的头文件。

 

>> 在C++程序中调用被 C 编译器编译后的函数，为什么要加 extern“C”声明？

答：函数和变量被C++编译后在符号库中的名字与C语言的不同，被extern "C"修饰的变

量和函数是按照C语言方式编译和连接的。由于编译后的名字不同，C++程序不能直接调

用C 函数。C++提供了一个C 连接交换指定符号extern“C”来解决这个问题。

 

>> 嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。

#define BIT3(0x1<<3)

static int a;

void set_bit3(void)

{

a |= BIT3;

}

voidclear_bit3(void)

{

a &= ~BIT3;

}

 

>> 尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？

主要有三种类型:内存泄露、内存碎片和内存崩溃 　内存崩溃是内存使用最严重的结果，主要原因有数组访问越界、写已经释放的内存、指针计算错误、访问堆栈地址越界等等。碎片收集的问题，变量的持行时间等等

 

>> 用C++写个程序，如何判断一个操作系统是16位还是32位的？不能用sizeof()函数

A1:

16位的系统下，

int i = 65536;

cout << i; // 输出0；

int i = 65535;

cout << i; // 输出-1；

32位的系统下，

inti = 65536;

cout<< i; // 输出65536；

inti = 65535;

cout<< i; // 输出65535；

 

A2:

inta = ~0;

if(a>65536 )

{

cout<<"32 bit"<<endl;

}

else

{

cout<<"16 bit"<<endl;

}

>> 编写strcat函数

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

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

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

答：

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

{

char * cp = dst;

while( *cp )

cp++; /* find endof dst */

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

return( dst ); /*return dst */

}

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

答：方便赋值给其他变量

 

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

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

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

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

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

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

其他情况都使用单线程。

 

>> TCP协议和UDP协议的区别

答：TCP协议面向连接，UDP协议面向非连接

TCP协议传输速度慢，UDP协议传输速度快

TCP协议保证数据顺序，UDP协议不保证

TCP协议保证数据正确性，UDP协议可能丢包

TCP协议对系统资源要求多，UDP协议要求少

TCP = Transmission Control Protocol 传输控制协议

 

>> TCP/IP 建立连接的过程?(3-way shake)

答：在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。

　　第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状

态，等待服务器确认；

第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个

SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；

　　第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)

，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。

>> TCP/IP断开连接的过程？（主要分四次完成）

答：第一次HOST1上的应用程序关闭己方的连接导致TCP发送一个FIN消息给HOST2。

第二次HOST2发送一个确认消息给HOST1,并且HOST2把FIN作为EOF递交给HOST2上的应用程序。

第三次一段时间过后，HOST2上的应用程序关闭它那边的连接，引发一个FIN消息给HOST1。

第四次HOST1给HOST2发送一个确认消息，然后HOST2关闭连接并释放资源，然而，HOST1却没有关闭连接，而是进入了TIME_WAIT状态，并为两个最大段生存时间(2MSL)保留在此状态.

？1：为什么需要time_wait?

答：1.因为在第四步的时候，HOST1发送的ACK可能丢失并导致HOST2重新发送FIN消息，TIME_WAIT维护连接状态.

 如果执行主动关闭的一方HOST1 不进入到TIME_WAIT状态就关闭连接那会发生什么呢？当重传的FIN消息到达时，因为TCP已经不再有连接的信息了，所以就用RST(重新启动)消 息应答，导致HOST2进入错误的状态而不是有序终止状态，如果发送最后ACK消息的一方处于TIME_WAIT状态并仍然记录着连接的信息，它就可以正确的响应对等方HOST2的FIN消息了.

？2：TIME_WAIT为连接中”离群的段”提供从网络中消失的时间.

答： 考虑一下，如果延迟或者重传段在连接关闭后到达时会发生什么呢？通常情况下，因为TCP仅仅丢弃该数据并响应RST消息，所以这不会造成任何问题。当 RST消息到达发出延时段的主机时，因为该主机也没有记录连接的任何信息，所以它也丢弃该段。然而，如果两个相同主机之间又建立了一个具有相同端口号的新连接，那么离群的段就可能被看成是新连接的，如果离群的段中数据的任何序列号恰恰在新连接的当前接收窗口中，数据就会被重新接收，其结果就是破坏新连接。

 

>> winsock建立连接的主要实现步骤 ?

答：服务器端：socker()建立套接字，绑定（bind）并监听（listen），用accept（）

等待客户端连接。

客户端：socker()建立套接字，连接（connect）服务器，连接上后使用send()和recv（

），在套接字上写读数据，直至数据交换完毕，closesocket()关闭套接字。

服务器端：accept（）发现有客户端连接，建立一个新的套接字，自身重新开始等待连

接。该新产生的套接字使用send()和recv（）写读数据，直至数据交换完毕，closesocket()关闭套接字。

 

>> 动态连接库的两种方式

答：调用一个DLL中的函数有两种方法：

1．载入时动态链接（load-time dynamic linking），模块非常明确调用某个导出函数

，使得他们就像本地函数一样。这需要链接时链接那些函数所在DLL的导入库，导入库向

系统提供了载入DLL时所需的信息及DLL函数定位。

2．运行时动态链接（run-time dynamic linking），运行时可以通过LoadLibrary或Loa

dLibraryEx函数载入DLL。DLL载入后，模块可以通过调用GetProcAddress获取DLL函数的

出口地址，然后就可以通过返回的函数指针调用DLL函数了。如此即可避免导入库文件了

>> 描述实时系统的基本特性

      在特定时间内完成特定的任务，实时性与可靠性。

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

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

>> 什么是平衡二叉树？

     左右子树都是平衡二叉树且左右子树的深度差值的绝对值不大于1。

>> 堆栈溢出一般是由什么原因导致的？

     没有回收垃圾资源。

>> 局部变量能否和全局变量重名？

    答：能，局部会屏蔽全局。要用全局变量，需要使用"::"

局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。

>> 如何引用一个已经定义过的全局变量？

    答：extern

    可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。

>> 全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？

   答：可以，在不同的C文件中以static形式来声明同名全局变量。

>> 软件测试都有那些种类?

黑盒：针对系统功能的测试  

白合：测试函数功能，各函数接口

>> 进程和线程的差别。

线程是指进程内的一个执行单元,也是进程内的可调度实体.

与进程的区别:

(1)调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位

(2)并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行

(3)拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源.

(4)系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。

 

>> 网络编程中设计并发服务器，使用多进程与 多线程 ，请问有什么区别？

1.进程：子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。

2.线程：相对与进程而言，线程是一个更加接近与执行体的概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。

两者都可以提高程序的并发度，提高程序运行效率和响应时间。

线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。

 

>> Heap与stack的差别。

Heap是堆，stack是栈。

Stack的空间由操作系统自动分配/释放，Heap上的空间手动分配/释放。

Stack空间有限，Heap是很大的自由存储区

C中的malloc函数分配的内存空间即在堆上,C++中对应的是new操作符。

程序在编译期对变量和函数分配内存都在栈上进行,且程序运行过程中函数调用时参数的传递也在栈上进行

>> 列举几种进程的同步机制，并比较其优缺点。

  原子操作

  信号量机制

  自旋锁

  管程，会合，分布式系统

>> 进程之间通信的途径

答：管道、有名管道、信号量、消息队列、共享内存、套接字等

# 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

# 有名管道 (namedpipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

# 信号量(semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

# 消息队列(message queue ) ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

# 信号 ( sinal )： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

# 共享内存( sharedmemory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。

# 套接字( socket) ： 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。

>> 进程死锁的原因

资源竞争及进程推进顺序非法

>> 死锁的4个必要条件

互斥、请求保持、不可剥夺、环路

>> 死锁的处理

鸵鸟策略、预防策略、避免策略、检测与解除死锁

>> 操作系统中进程调度策略有哪几种？

FCFS(先来先服务)，优先级，时间片轮转，多级反馈

>> 数组和链表的区别

数组：数据顺序存储，固定大小

连表：数据可以随机存储，大小可动态改变

 

>> 引用与指针有什么区别？

答 、1) 引用必须被初始化，指针不必。

2) 引用初始化以后不能被改变，指针可以改变所指的对象。

3)不存在指向空值的引用，但是存在指向空值的指针。

 

>> 什么函数不能声明为虚函数？

答 构造函数（constructor）

 

>> 对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现?

答 、c用宏定义，c++用inline

 

>> C++是不是类型安全的？

答案：不是。两个不同类型的指针之间可以强制转换（用reinterpretcast)

 

>> 系统会自动打开和关闭的3个标准的文件是？

(1) 标准输入----键盘---stdin

(2) 标准输出----显示器---stdout

(3) 标准出错输出----显示器---stderr

 

>> 在Win32下 char, int, float, double各占多少位？

(1) Char    占用8位

(2) Int占用32位

(3) Float占用32位

(4) Double占用64位

 

>> strcpy()和memcpy()的区别？

    strcpy()和memcpy()都可以用来拷贝字符串，strcpy()拷贝以’\0’结束，但memcpy()必须指定拷贝的长度。

 

>> 说明define和const在语法和含义上有什么不同？

(1) #define是C语法中定义符号变量的方法，符号常量只是用来表达一个值，在编译阶段符号就被值替换了，它没有类型；

(2) Const是C++语法中定义常变量的方法，常变量具有变量特性，它具有类型，内存中存在以它命名的存储单元，可以用sizeof测出长度。

 

>> 说出字符常量和字符串常量的区别，并使用运算符sizeof计算有什么不用？

字符常量是指单个字符，字符串常量以‘\0’结束，使用运算符sizeof计算多占一字节的存储空间。

 

>> 什么是指针？谈谈你对指针的理解？

指针是一个变量，该变量专门存放内存地址；

指针变量的类型取决于其指向的数据类型，在所指数据类型前加*

指针变量的特点是它可以访问所指向的内存。

 

>> 什么是常指针，什么是指向常变量的指针？

常指针的含义是该指针所指向的地址不能变，但该地址所指向的内容可以变化，使用常指针可以保证我们的指针不能指向其它的变量，

指向常变量的指针是指该指针的变量本身的地址可以变化，可以指向其它的变量，但是它所指的内容不可以被修改。指向长变量的指针定义，

 

>> 函数指针和指针函数的区别？

函数指针是指指向一个函数入口的指针；

指针函数是指函数的返回值是一个指针类型。

 

>> 类的声明和实现的分开的好处？

1.  起保护作用；

2.  提高编译的效率。

 

>> 怎样消除多重继承中的二义性？

1．成员限定符

2．虚基类

 

>> 什么叫静态关联，什么叫动态关联

在多态中，如果程序在编译阶段就能确定实际执行动作，则称静态关联，

如果等到程序运行才能确定叫动态关联。

 

>> 多态的两个必要条件

1.一个基类的指针或引用指向一个派生类对象，

2.虚函数

 

>> 什么叫智能指针？

当一个类中，存在一个指向另一个类对象的指针时，对指针运算符进行重载，那么当前类对象可以通过指针像调用自身成员一样调用另一个类的成员。

 

>> 什么时候需要用虚析构函数？

当基类指针指向用new运算符生成的派生类对象时，delete基类指针时，派生类部分没有释放掉而造成释放不彻底现象，需要虚析构函数。

 

>> memset ,memcpy 的区别

memset用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为'\0'。

memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度；

 

>> 面向对象的三个基本特征，并简单叙述之？

1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)

2. 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。

3. 多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

 

>> 用最简单的方法实现函数int strcmp(char *p1,char*p2)

int ret;

//while( *p1 && *p2 && !(ret=*p1-*p2))

while(!(ret=*p1-*p2) && *p1 && *p2)

{

p1++;p2++;

}

return ret;

int strcmp(const char * cs,const char * ct)

{

register signed char __res;

 

while (1) {

if ((__res = *cs - *ct++) != 0 || !*cs++)

break;

}

 

return __res;

}

 

>> 以下代码中的两个sizeof用法有问题吗？

voidUpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母

{   

for(size_t i=0; i <sizeof(str)/sizeof(str[0]); ++i )       

if( 'a' <=str[i] && str[i]<='z' )           

str[i] -= ('a'-'A' );

}

charstr[] = "aBcDe";

cout< < "str字符长度为: " < <sizeof(str)/sizeof(str[0]) < < endl;

UpperCase(str );

cout< < str < < endl;

 

答案：函数外的str是一个静态定义的数组，因此其大小为6，因为还有'\0'，

函数内的str返回4。

 

>> 一个32位的机器,该机器的指针是多少位答案：

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

 

>> 请问以下代码有什么问题：

int  main()

{

 char a;

 char *str=&a;

 strcpy(str,"hello");

 printf(str);

return 0;

}

答案：没有为str分配内存空间，将会发生异常问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。

 

>> 下面代码有什么错

char*s="AAA";

printf("%s",s);

s[0]='B';

printf("%s",s);

答案："AAA"是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。 cosnt char* s="AAA"; 然后又因为是常量，所以对是s[0]的赋值操作是不合法的。

 

>> int (*s[10])(int) 表示的是什么

答案：int (*s[10])(int) 函数指针数组，每个指针指向一个intfunc(int param)的函数。

 

>> (void *)ptr 和 (*(void**))ptr的结果是否相同？其中ptr为同一个指针

答案：.(void*)ptr 和 (*(void**))ptr值是相同的

 

>>  -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)

 

>> 下面语句：

unsignedchar *p1;    unsigned long *p2;   

p1=(unsignedchar *)0x801000;   

p2=(unsignedlong *)0x810000;   

请问p1+5=  ;       p2+5=  ;

答案：801005；810014。不要忘记了这个是16进制的数字，p2要加20变为16进制就是14

 

>> static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？

答案：全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。 static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件 static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用; static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值； static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

 

>> 不使用库函数，编写函数int strcmp(char  *source, char*dest) 相等返回0，不等返回-1；

答案：一、

intstrcmp(char  *source, char *dest)

{ 

assert((source!=NULL)&&(dest!=NULL)); 

int i,j; 

for(i=0; source[i]==dest[i]; i++) 

{ 

if(source[i]=='\0' &&dest[i]=='\0')   

return 0;

else   

return -1; 

}

}

 

答案：二、

intstrcmp(char *source, char *dest)

{    while( (*source != '\0') && (*source == *dest))  

 {

 source++; dest++;   

}   

return ( (*source) - (*dest) ) ? -1 : 0;

 }

 

>> 写一函数int fun(char *p)判断一字符串是否为回文,是返回1，不是返回0，出错返回-1

答案：一、

intfun(char *p)

{  if(p==NULL) 

return -1; 

else 

{ int length = 0;  int i = 0;  int judge = 1;  length = strlen(p); 

for(i=0; i<length/2; i++) 

{   if(p[i]!=p[length-1-i])  

 judge = 0;   

break; 

} 

if(judge == 0)   

return 0; 

else   

return 1; 

}

}

答案：二、

intfun(char *p)

{

int len = strlen(p) - 1;

char *q = p + len;

if (!p) return -1;

while (p < q)

{

if ((*p++) != (*q--))

return 0;

}

return 1;

} 

 

>> 设有int a=3;则执行语句a+=a-=a*a;后

变量a的值是? 

答案：-12

 

>> 有一个字符串，将字符串从第m个字符开始全部复制到另一个新字符串?

voidcopystr( char *p1, char *p2, int m)

{

    int n=0;

    while(n<m-1)

    {

        n++;

        p1++;

}

while(*p1!=’/0’)

{

   *p2=*p1;

   p1++;

   p2++;

}

*p2=’/0’;

}

 

>> 写出冒泡排序

 

voidpop_sort(int a[],int N)

{ int tmp, i , j;

    for(j=0;j<N; j++)

     for( i=0; i<N-j; i++)

        if( a[i]>a[i+1])

         {tmp=a[i];

a[i]=a[i+1];

a[i+1]=tmp;

}

}

 

>> 写出选择法排序

voidselect_sort(int a[],int N)

{ int  i , j,k, t;

    for(i=0; i<N;i++)

{

    k=i;

        for( j=i+1; j<N; j ++)

         if( a[j]<ak])

          k=j;

         tmp=a[k];

a[k]=a[i];

a[i]=tmp;

}

}

 

>> 写一print函数，将链表中的各数据遍历输出

  void print(student *head )

  {

    student*p;

    cout<<"there"<<n<<"records"<<endl;

    p=head;

    if(head!=NULL)

    do

    {

        cout<<p->num<<""<<p->score<<endl;

        p=p->next;

    }while(p!=NULL)

  }

 

>> 写一del函数，用来删除动态链表中，指定的结点数据

 void *del(student *head, long num)

 {

    student*p1,*p2;

    if(head==NULL)

    {return(head);}

    p1=head;

    while(num!=p1->num&& p1->next !=NULL)

    {

        p2=p1;

        p1=p1->next;

    }

    if(num== p1->num)

    {

        if(p1==head)

                head=p1->next;

        else

                p2->next=p1->next;

        cout<<"delete:"<<num<<endl;

        n=n-1;

    }

    else

        cout<<"cannot find"<<num;

    return(head);

 }

>> 写一函数insert,用来向动态链表插入一结点

 Student *insert(student *head, student *stud)

 {

    student*p0 ,*p1, *p2;

    p1=head;

    p0=stud;

    if(head== NULL)

    {

        head=p0;

        p0->next=NULL;

    }

    else

    {

        while((p0->num>p1->num) && (p1->next!=NULL) )

        {

            p2=p1;

            p1=p1->next;

        }

        if(p0->num<= p1->num)

        {

            if(head==p1)

                head=p0;

            else

                p2->next=p0;

            p0->next=p1;

        }

        else

        {

            p1->next=p0;

            p0->next=NULL; 

        }

    }

    n=n+1;

    return(head);

 

 }