c语言常见笔试题

【1 使用宏】

1.1

#ifdef NDEBUG

#define TRACE(S) S

#else

#define TRACE(S) printf("%s;\

说明以下函数的意义：

void perror(const char *__s);

fdprintf(int, const char *, ...);

isspace(), isxdigit(), strerr(), sprintf()

coon @ 23:44:01 | 阅读全文 | 评论 0 | 引用 0 | 编辑

c语言笔试题(九)

2006-09-06

Tag: C语言

1．

#include "stdio.h"

int main()

{

int a;

int *p;

p = &a;

*p = 0x500;

a = (int )(*(&p));

a = (int )(&(*p));

if(a == (int)p)

printf("equal !\

");

else

printf("not equal !\

");

}

请问本程序的输出显示是什么？

答案：输出显示为”equal!”

2．

struct {

signed int bit0:1;

signed int bit1:1;

signed int bit2:1;

signed int bit3:1;

signed int bit4:1;

signed int bit5:1;

signed int bit6:1;

signed int bit7:1;

}bits;

请问sizeof(bits)是否是正确的表达式？

请问语句bits mybits; 的定义是否正确？如果不正确，要如何修改上述的结构定义才能使该语句正确？修改后的结构定义是否会影响sizeof(bits)的正确性？如果正确则该表达式的值为多少？如果将上述的结构中int类型改为char类型，此时sizeof(bits)的大小为多少？

答案：1）是正确的表达式，因为sizeof后面的内容可以是类型，也可以是变量。

2）该语句的定义不正确，因为此时的bits为一个变量；应该这样修改结构的定义

typedef struct {

signed int bit0:1;

signed int bit1:1;

signed int bit2:1;

signed int bit3:1;

signed int bit4:1;

signed int bit5:1;

signed int bit6:1;

signed int bit7:1;

}bits;

修改后sizeof(bits)表达式依然正确，其值为4；类型改为char后其值为1，注意该值是在VC环境中的32位程序中得到的值，在不同的编译器其值有可能不同，因此在编程时不能自己假定类似结构的大小。

3．

struct bit{

unsigned int a[0]:1,a[1]:1,a[2]:1….a[7]:1;

}

请问这种写法是否正确？为什么？

答案：不正确，位域中的变量不能是数组。

4．

struct a {

int x;

char y;

struct a z;

struct a *p;

}

请问这种定义结构正确否？ 如果有问题，问题在哪里？

答案：结构中不能对定义结构本身的非指针变量，如果编译器支持则会导致无限嵌套，因此一般编译器都会认为struct a是未定义的类型，即使提前声明也不会有任何用处。

5． 什么是可重入函数？C语言中写可重入函数，应注意的事项？

答案：可重入函数是指能够被多个线程“同时”调用的函数，并且能保证函数结果的正确性的函数。在编写可重入函数时通常要注意如下的一些问题：

尽量不要使用全局变量，静态变量，如果使用了应该注意对变量访问的互斥。通常可以根据具体的情况采用：信号量机制，关调度机制，关中断机制等方式来保证函数的可重入性。

不要调用不可重入的函数，调用了不可重入的

函数会使该函数也变为不可重入的函数。

注意对系统中的临界资源，互斥资源的访问方式，防止使函数成为不可重入的函数。

一般驱动程序都是不可重入的函数，因此在编写驱动程序时一定要注意重入的问题。

6． 简述stack frame 的含义。

答案：stack frame的中文译名为：栈框架，表示函数在栈空间的调用层次，以x86平台的函数调用为例，通常一个函数编译成汇编程序，都有如下的结构：

其中的leave指令相当于：mov ebp,esp ；pop ebp

各个函数在栈空间的映象为：

test1函数 test2函数 test3函数

因此在函数test3中，就可以根据这种栈框架的形式得到函数调用层次上的每个函数的基址指针，当前栈指针，以及函数调用点等信息。

7． printf (“%d%d\

”,++n, power(2,n)); 其中power(2,n)为实现一定功能的函数 如 2^n 。

请问这种表示方法有什么潜在的问题？

答案：编译器的不同，对++n 和power(2,n)处理的先后顺序不一样，形成二义性，造成程

序的移植性差，因此最好把++n 写在printf函数外面，以消除二义性。

printf (s);

请问这样的语句有没有问题？（s为一指向有效字符串的指针）

答案：没有%的话，可以这样表达，如果有%在s中的话，有意想不到的输出结果。

9． 两段代码共存于一个文件，编译时有选择的编译其中的一部分，请问如何实现？

答案：有两种简单的办法可以实现：

在源码中使用条件编译语句，然后在程序文件中定义宏的形式来选择需

要的编译代码。

在源码中使用条件编译语句，然后在编译命令的命令中加入宏定义命令

来实现选择编译。

10．数据结构指针传给函数，函数能访问数据单元，但不能修改实际的内容，如何实现？

答案：定义为指向常量的指针，这样指针所指的数据结构中的内容就不会被改变。如：

const 类型 *p 或 类型 const *p

11． 在头文件中定义静态变量，可能产生什么问题？

答案：在使用了该头文件的每个c程序文件中都单独存在一个该静态变量，这样造成空间的浪费并且很容易引起错误。因此建议不要在头文件中定义任何变量。

12．malloc()与 calloc()的区别？

答案：

1）参数上的区别

malloc (size_t size);

calloc (size_t n , size_t size);

malloc分配一块size大小的内存块，而calloc分配一个n*size大小的内存块

2）返回内存块的状态不同

malloc分配的内存块没有被清零，而calloc分配的内存块是清了零的。但是建议在使用内存时，如果需要初始化，则最好自己按照需要来进行初试化，不要依赖函数的实现说明。

13．寄存器变

量可不可以访问其地址？可否是全局变量？在什么场合使用寄存器变量？

答案：这些问题都与编译器的实现有关，建议不要声明全局变量为寄存器变量，即使是局部变量都最好不要声明其为寄存器变量，现在的编译器在优化时都会较为合理的安排寄存器变量的使用，而人为的安排有时会造成优化的低效。

14．"\

" '\

' 的区别？

答案：前者是一个字符串并且以’/0’结束，而后者只是一个简单的字符。

15．包含预定义头文件< > 和" "的区别？

答案：< >只在指定的目录里寻找被包含文件；" "先在当前目录下查找 ，再在指定目录下查找；通常<>方式用于系统的头文件，而一般用户的头文件用" "的方式。

16．strunt S_A{

int a[10];

};

void f()

{

int i;

strunt S_A *s_ptr;

for (i=0,i<10,i++)

s_ptr -> a[i] = i;

}

请问这段代码正确否？

答案：这段代码不正确，没有对s_ptr指针进行初始化，在编程中要注意此类低级错误的发生。

coon @ 23:37:37 | 阅读全文 | 评论 0 | 引用 0 | 编辑

c语言笔试题(八)

2006-09-06

Tag: C语言

　　#pragma pack(8)

　　struct s1{

　　short a;

　　long b;

　　};

　　struct s2{

　　char c;

　　s1 d;

　　long long e;

　　};

　　#pragma pack()

　　问

　　1.sizeof(s2) = ?

　　2.s2的s1中的a后面空了几个字节接着是b?

　　如果您知道答案请在讨论中写出，以下是部份网友的答案，供参考：

　　网友rwxybh(行云)的答案：

　　内存布局是

　　1*** 11**

　　1111 ****

　　1111 1111

　　所以答案就是24和3

　　下面是一个测试的程序，试一试就知道了，我用的是VC2005

　　#pragma pack(8)

　　struct s1{

　　short a; // 2 BYtes

　　long b; // 4 Bytes

　　};

　　struct s2{

　　char c; // 1 Byte

　　s1 d; // 8 Bytes

　　long long e; // 8 Bytes

　　};

　　// 1*** 11**

　　// 1111 ****

　　// 1111 1111

　　//

　　// 00 01 02 03 04 05 06 07

　　// 00 01 02 03 04 05 06 07

　　// 00 01 02 03 04 05 06 07

　　//

　　#pragma pack()

　　int main(int argc, char* argv[])

　　{

　　s2 a;

　　char *p = (char *)&a;

　　for(int i=0;i<24;++i)

　　p[i] = (char)(i%8);

　　printf("%d\

struct S1 d;

　　long long e;

　　};

　　#pragma pack()

　　sizeof(S2)结果为24.

　　成员对齐有一个重要的条件,即每个成员分别对齐.即每个成员按自己的方式对齐.

　　也就是说上面虽然指定了按8字节对齐,但并不是所有的成员都是以8字节对齐.其对齐的规则是,每个成员按其类型的对齐参数(通常是这个类型的大小)和指定对齐参数(这里是8字节)中较小的一个对齐.并且结构的长度必须为所用过的所有对齐参数的整数倍,不够就补空字节.

　　S1中,成员a是1字节默认按1字节对齐,指定对齐参数为8,这两个值中取1,a按1字节对齐;成员b是4个字节,默认是按4字节对齐,这时就按4字节对齐,所以sizeof(S1)应该为8;

　　S2中,c和S1中的a一样,按1字节对齐,而d 是个结构,它是8个字节,它按什么对齐呢?对于结构来说,它的默认对齐方式就是它的所有成员使用的对齐参数中最大的一个,S1的就是4.所以,成员d就是按4字节对齐.成员e是8个字节,它是默认按8字节对齐,和指定的一样,所以它对到8字节的边界上,这时,已经使用了12个字节了,所以又添加了4个字节的空,从第16个字节开始放置成员e.这时,长度为24,已经可以被8(成员e按8字节对齐)整除.这样,一共使用了24个字节.

　　a b

　　S1的内存布局：11**,1111,

　　c S1.a S1.b d

　　S2的内存布局：1***,11**,1111,****11111111

　　这里有三点很重要:

　　1.每个成员分别按自己的方式对齐,并能最小化长度

　　2.复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度

　　3.对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐

　　网友xue23(xue23) 的答案和分析：

　　有程序查一下各个变量的内存地址得知：

　　各个变量在内存中的位置为

　　c***aa**

　　bbbb****

　　dddddddd

　　测试代码为：

　　s2 ss;

　　cout << "ss.c = " << &ss << endl ;

　　cout << "ss.d.a = " <<&ss.d.a << endl;

　　cout << "ss.d.b = " <<&(ss.d.b) <　　cout << "ss.d = " <<&ss.e << endl;

　　print out 各个变量的内存地址不就可以看出来了吗。

　　所以答案是24,2.

　　但是我的想像中应该是这样的分布情况：

　　c*******

　　aa**bbbb

　　dddddddd

　　不知为什么会c和a放在一起，组成8位长度。

coon @ 23:35:17 | 阅读全文 | 评论 0 | 引用 0 | 编辑

c语言笔试题(七)

2006-09-06

Tag: C语言

找错

Void test1()

{

char string[10];

char* str1="01234567";

strcpy(string, str1);

}

Void test2()

{

char string[10], str1[10];

for(I=0; I<10;I++)

{

str1[i] ='a';

}

strcpy(string, str1);

}

Void test3(char* str1)

{

char string[10];

if(strl

en(str1)<=10)

{

strcpy(string, str1);

}

}

2. 找错

#define MAX_SRM 256

DSN get_SRM_no()

{

static int SRM_no;

int I;

for(I=0;I{

SRM_no %= MAX_SRM;

if(MY_SRM.state==IDLE)

{

break;

}

}

if(I>=MAX_SRM)

return (NULL_SRM);

else

return SRM_no;

}

3. 写出程序运行结果

int sum(int a)

{

auto int c=0;

static int b=3;

c+=1;

b+=2;

return(a+b+C);

}

void main()

{

int I;

int a=2;

for(I=0;I<5;I++)

{

printf("%d,

要用全局变量，需要使用"::"

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

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

答：extern

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

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

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

可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错

4、语句for( ；1 ；)有什么问题？它是什么意思？

答：和while(1)相同。

5、do……while和while……do有什么区别？

答：前一个循环一遍再判断，后一个判断以后再循环

6、请写出下列代码的输出内容

#include

main()

{

int a,b,c,d;

a=10;

b=a++;

c=++a;

d=10*a++;

printf("b，c，d：%d，%d，%d"，b，c，d）;

return 0;

}

答：10，12，120

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

全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 了它的使用范围。

static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些

些函数的源文件要包含这个头文件

static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;

static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；

static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

2、程序的局部变量存在于（堆栈）中，全局变量存在于（静态区 ）中，动态申请数据存在于（ 堆）中。

3、设有以下说明和定义：

typedef union {long i; int k[5]; char c;} DATE;

struct data { int cat; DATE cow; double dog;} too;

DATE max;

则语句 printf("%d

将新元素push入栈A;

出队:

(1)判断栈B是否为空；

(2)如果不为空，则将栈A中所有元素依次pop出并push到栈B；

(3)将栈B的栈顶元素pop出；

这样实现的队列入队和出队的平摊复杂度都还是O(1), 比上面的几种方法要好。3.在c语言库函数中将一个字符转换成整型的函数是atool()吗，这个函数的原型是什么？

函数名: atol

功 能: 把字符串转换成长整型数

用 法: long atol(const char *nptr);

程序例:

#include

#include

int main(void)

{

long l;

char *str = "98765432";

l = atol(lstr);

printf("string = %s integer = %ld\

为拥有资源的基本单位

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

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

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

2.测试方法

人工测试：个人复查、抽查和会审

机器测试：黑盒测试和白盒测试

2．Heap与stack的差别。

Heap是堆，stack是栈。

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

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

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

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

3．Windows下的内存是如何管理的？

4．介绍.Net和.Net的安全性。

5．客户端如何访问.Net组件实现Web Service？

6．C/C++编译器中虚表是如何完成的？

7．谈谈COM的线程模型。然后讨论进程内/外组件的差别。

8．谈谈IA32下的分页机制

小页(4K)两级分页模式，大页(4M)一级

9．给两个变量，如何找出一个带环单链表中是什么地方出现环的？

一个递增一，一个递增二，他们指向同一个接点时就是环出现的地方

10．在IA32中一共有多少种办法从用户态跳到内核态？

通过调用门，从ring3到ring0，中断从ring3到ring0，进入vm86等等

11．如果只想让程序有一个实例运行，不能运行两个。像winamp一样，只能开一个窗口，怎样实现？

用内存映射或全局原子（互斥变量）、查找窗口句柄..

FindWindow，互斥，写标志到文件或注册表,共享内存。.　

12．如何截取键盘的响应，让所有的‘a’变成‘b’？

键盘钩子SetWindowsHookEx

　13．Apartment在COM中有什么用？为什么要引入？

　14．存储过程是什么？有什么用？有什么优点？

我的理解就是一堆sql的集合，可以建立非常复杂的查询，编译运行，所以运行一次后，以后再运行速度比单独执行SQL快很多

　15．Template有什么特点？什么时候用？

16．谈谈Windows DNA结构的特点和优点。

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

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

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

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

线程和进程在使用上各有优缺点：线程

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

思科

1. 用宏定义写出swap（x，y）

#define swap(x, y)\\

x = x + y;\\

y = x - y;\\

x = x - y;

2.数组a[N]，存放了1至N-1个数，其中某个数重复一次。写一个函数，找出被重复的数字.时间复杂度必须为o（N）函数原型：

int do_dup(int a[],int N)

3 一语句实现x是否为2的若干次幂的判断

int i = 512;

cout << boolalpha << ((i & (i - 1)) ? false : true) << endl;

4.unsigned int intvert(unsigned int x,int p,int n)实现对x的进行转换,p为起始转化位,n为需要转换的长度,假设起始点在右边.如x=0b0001 0001,p=4,n=3转换后x=0b0110 0001

unsigned int intvert(unsigned int x,int p,int n){

unsigned int _t = 0;

unsigned int _a = 1;

for(int i = 0; i < n; ++i){

_t |= _a;

_a = _a << 1;

}

_t = _t << p;

x ^= _t;

return x;

}

慧通：

什么是预编译

何时需要预编译：

１、总是使用不经常改动的大型代码体。

２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。

char * const p;

char const * p

const char *p

上述三个有什么区别？

char * const p; //常量指针，p的值不可以修改

char const * p；//指向常量的指针，指向的常量值不可以改

const char *p； //和char const *p

char str1[] = "abc";

char str2[] = "abc";

const char str3[] = "abc";

const char str4[] = "abc";

const char *str5 = "abc";

const char *str6 = "abc";

char *str7 = "abc";

char *str8 = "abc";

cout << ( str1 == str2 ) << endl;

cout << ( str3 == str4 ) << endl;

cout << ( str5 == str6 ) << endl;

cout << ( str7 == str8 ) << endl;

结果是：0 0 1 1

解答：str1,str2,str3,str4是数组变量，它们有各自的内存空间；

而str5,str6,str7,str8是指针，它们指向相同的常量区域。

12. 以下代码中的两个sizeof用法有问题吗？[C易]

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

{

for( size_t i=0; i

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

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

}

char str[] = "aBcDe";

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

UpperCase( str );

cout << str << endl;

答：函数内的sizeof有问题。根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组，因此其大小为6，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。

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

指针是多少位只要看地址总线的位数就行了。80386以后的机子都是3

2的数据总线。所以指针的位数就是4个字节了。

main()

{

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

int *ptr=(int *)(&a+1);

printf("%d,%d

别是c中的struct不可以含有成员函数，而c++中的struct可以。c++中struct和class的主要区别在于默认的存取权限不同，struct默认为public，而class默认为private

4.#include

#include

void getmemory(char *p)

{

p=(char *) malloc(100);

strcpy(p,"hello world");

}

int main( )

{

char *str=NULL;

getmemory(str);

printf("%s/n

oid(*)() voidFuncPtr;

*((voidFuncPtr)0x100000)();

2，已知一个数组table，用一个宏定义，求出数据的元素个数

#define NTBL

#define NTBL (sizeof(table)/sizeof(table[0]))

面试题: 线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有的堆栈?

进程是死的，只是一些资源的集合，真正的程序执行都是线程来完成的，程序启动的时候操作系统就帮你创建了一个主线程。

每个线程有自己的堆栈。

DLL 中有没有的堆栈，这个问题不好回答，或者说这个问题本身是否有问题。因为DLL中的代码是被某些线程所执行，只有线程拥有堆栈，如果DLL中的代码是 EXE中的线程所调用，那么这个时候是不是说这个DLL没有自己的堆栈？如果DLL中的代码是由DLL自己创建的线程所执行，那么是不是说DLL有的堆栈？

以上讲的是堆栈，如果对于堆来说，每个DLL有自己的堆，所以如果是从DLL中动态分配的内存，最好是从DLL中删除，如果你从DLL中分配内存，然后在EXE中，或者另外一个DLL中删除，很有可能导致程序崩溃

unsigned short A = 10;

printf("~A = %u\

别这么干。

char a[10],strlen(a)为什么等于15？运行的结果

#include "stdio.h"

#include "string.h"

void main()

{

char aa[10];

printf("%d

机用补码表示，所以c = -4;同理

b = -1;

当c为有符合数时, c = 100,即 c = 4,同理 b = 3

位域 ：

有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态，用一位二进位即可。为了节省存储空间，并使处理简便，Ｃ语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为：

struct 位域结构名

{ 位域列表 };

其中位域列表的形式为： 类型说明符 位域名：位域长度

例如：

struct bs

{

int a:8;

int b:2;

int c:6;

};

位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如：

struct bs

{

int a:8;

int b:2;

int c:6;

}data;

说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：

1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：

struct bs

{

unsigned a:4

unsigned :0 /*空域*/

unsigned b:4 /*从下一单元开始存放*/

unsigned c:4

}

在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。

2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。

3. 位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：

struct k

{

int a:1

int :2 /*该2位不能使用*/

int b:3

int c:2

};

从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。

二、位域的使用位域的使用和结构成员的使用相同，其一般形式为： 位域变量名?位域名 位域允许用各种格式输出。

main(){

struct bs

{

unsigned a:1;

unsigned b:3;

unsigned c:4;

} bit,*pbit;

bit.a=1;

bit.b=7;

bit.c=15;

pri

改错：

#include

int main(void) {

int **p;

int arr[100];

p = &arr;

return 0;

}

解答：

搞错了,是指针类型不同,

int **p; //二级指针

&arr; //得到的是指向第一维为100的数组的指针

#include

int main(void) {

int **p, *q;

int arr[100];

q = arr;

p = &q;

return 0;

}

下面这个程序执行后会有什么错误或者效果:

#define MAX 255

int main()

{

u

nsigned char A[MAX],i;//i被定义为unsigned char

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

A[i]=i;

}

解答：死循环加数组越界访问（C/C++不进行数组越界检查）

MAX=255

数组A的下标范围为:0..MAX-1,这是其一..

其二.当i循环到255时,循环内执行:

A[255]=255;

这句本身没有问题..但是返回for (i=0;i<=MAX;i++)语句时,

由于unsigned char的取值范围在(0..255),i++以后i又为0了..无限循环下去.

struct name1{

char str;

short x;

int num;

}

struct name2{

char str;

int num;

short x;

}

sizeof(struct name1)=8,sizeof(struct name2)=12

在第二个结构中，为保证num按四个字节对齐，char后必须留出3字节的空间；同时为保证整个结构的自然对齐（这里是4字节对齐），在x后还要补齐2个字节，这样就是12字节。

intel：

A.c 和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会不会有问题?这两个static变量会保存到哪里（栈还是堆或者其他的）?

static的全局变量，表明这个变量仅在本模块中有意义，不会影响其他模块。

他们都放在数据区，但是编译器对他们的命名是不同的。

如果要使变量在其他模块也有意义的话，需要使用extern关键字。

struct s1

{

int i: 8;

int j: 4;

int a: 3;

double b;

};

struct s2

{

int i: 8;

int j: 4;

double b;

int a:3;

};

printf("sizeof(s1)= %d\

* MAX;

b = (int*)realloc(a,MAX * sizeof(int));

if(b == NULL)

{

printf("error3");

exit(-1);

}

a = b;

}

}

for(;--j >= 0;)

fprintf(fp2,"%d\