EEPW论坛

＃i nclude<setjmp.h>
static jmp_buf buf;

main() 
{ volatile int b;
b =3;

if(setjmp(buf)!=0) 
{
printf("%d ", b); 
exit(0);
}
b=5;
longjmp(buf , 1);
} 

main()
{
struct node 
{
int a;
int b;
int c; 
};
struct node s= { 3, 5,6 };
struct node *pt = &s;
printf("%d" , *(int*)pt);

} 

int foo ( int x , int n)　
{
int val;
val =1;

if (n>0) 
{
if (n%2 == 1) val = val *x;

val = val * foo(x*x , n/2);
}
return val;
} 

main() 
{
int a[5] = {1,2,3,4,5};
int *ptr = (int*)(&a+1);

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

} 

void foo(int [][3] ); 

main()
{
int a [3][3]= { { 1,2,3} , { 4,5,6},{7,8,9}};
foo(a);
printf("%d" , a[2][1]);
}

void foo( int b[][3]) 
{
++ b;
b[1][1] =9;
} 

main()
{
int a, b,c, d;
a=3;
b=5;
c=a,b;
d=(a,b);

printf("c=%d" ,c);
printf("d=%d" ,d);

} 

main()
{
int a[][3] = { 1,2,3 ,4,5,6};
int (*ptr)[3] =a;

printf("%d %d " ,(*ptr)[1], (*ptr)[2] );

++ptr;
printf("%d %d" ,(*ptr)[1], (*ptr)[2] );
} 

int *f1(void)
{
int x =10;
return(&x);
}

int *f2(void)
{
int*ptr;
*ptr =10;
return ptr;
}

int *f3(void)
{
int *ptr;
ptr=(int*) malloc(sizeof(int));
return ptr;
} 

main()
{
int i=3;
int j;

j = sizeof(++i+ ++i);

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

void f1(int *, int); 
void f2(int *, int); 
void(*p[2]) ( int *, int);

main()
{
int a;
int b;

p[0] = f1;
p[1] = f2;
a=3;
b=5;

p[0](&a , b);
printf("%d\t %d\t" , a ,b);

p[1](&a , b);
printf("%d\t %d\t" , a ,b);
}

void f1( int* p , int q)
{
int tmp;
tmp =*p;
*p = q;
q= tmp;
}

void f2( int* p , int q)
{
int tmp;
tmp =*p;
*p = q;
q= tmp;
} 

void e(int ); 

main()
{
int a;
a=3;
e(a);
}

void e(int n)
{
if(n>0)
{
e(--n);
printf("%d" , n);
e(--n);
}
} 

typedef int (*test) ( float * , float*)
test tmp; 

main()
{
char p;
char buf[10] ={ 1,2,3,4,5,6,9,8};
p = (buf+1)[5];
printf("%d" , p);
} 

Void f(char**);

main()
{
char * argv[] = { "ab" ,"cd" , "ef" ,"gh", "ij" ,"kl" };
f( argv );
}

void f( char **p )
{
char* t;

t= (p+= sizeof(int))[-1];

printf( "%s" , t);
} 

＃i nclude<stdarg.h>
int ripple ( int , ...);

main()
{
int num;
num = ripple ( 3, 5,7);
printf( " %d" , num);
}

int ripple (int n, ...)
{
int i , j;
int k; 
va_list p;

k= 0;
j = 1;
va_start( p , n); 

for (; j<n; ++j) 
{
i = va_arg( p , int);
for (; i; i &=i-1 )
++k;
}
return k;
} 

int counter (int i)
{
static int count =0;
count = count +i;
return (count );
}
main()
{
int i , j;

for (i=0; i <=5; i++)
j = counter(i);
} 

int what ( int x , int n)
{
int val;
int product;
product =1;
val =x;

while(n>0)
{
if (n%2 == 1) 
product = product*val; /*如果是奇数次幂, x(val)
要先乘上一次,; 
偶数次幂,最后返回时才会到这里
乘以1*/
val = val* val; 
n = n/2; 
}
return product;
} 

(while n>0) 
{
if next most significant binary digit of n( power) is one
then multiply accumulated product by current val , 
reduce n(power) sequence by a factor of two using integer division .
get next val by multiply current value of itself 
} 

第4题: (c)
a的类型是一个整型数组,它有5个成员
&a的类型是一个整型数组的指针
所以&a + 1指向的地方等同于 a[6]

所以*(a+1) 等同于a[1]
ptr等同 a[6], ptr-1就等同与a[5]


第5题: (b)


题目自身就给了足够的提示
b[0][0] = 4
b[1][0] = 7


第6题: (c)
考查逗号表达式,逗号表达式的优先级是很低的，比 赋值(=)的优先级 低. 逗号表达式的值就是最后一个元素的值
逗号表达式的还有一个作用就是分割函数的参数列表..

E1, E2, ..., En
上面这个表示式的左右是,E1, E2,... En的值被分别计算出来，En计算出来的结构赋给整个逗号表达式

c=a,b; / *yields c=a* /
d=(a,b); /* d =b */ 

第7题: (a)

ptr是一个数组的指针，该数组有3个int成员


第8题: (c)
f1显然有问题，它返回一个局部变量的指针，局部变量是保存在stack中的,退出函数后，局部变量就销毁了，保留其指针没有意义，因为其指向的stack空间可能被其他变量覆盖了
f2也有问题, ptr是局部变量，未初始化，它的值是未知的，*ptr不知道指向哪里了，直接给*ptr赋值可能会覆盖重要的系统变量，这就是通常说的野指针的一种

第9题: (b)
sizeof 操作符给出其操作数需要占用的空间大小，它是在编译时就可确定的，所以其操作数即使是一个表达式，也不需要在运行时进行计算.( ++i + ++ i )是不会执行的，所以
i 的值还是3

第10题: (a)
很显然选a.
f1交换*p 和 q的值，f1执行完后, *p 和 q的值的确交换了, 但 q的改变不会影响到 b的改变, *p 实际上就是 a 
所以执行f1后, a=b=5
这道题考查的知识范围很广,包括typedef自定义类型,函数指针,指针数组
void(*p[ 2 ]) ( int *, int);
定义了一个函数指针的数组p,p有两个指针元素. 元素是函数的指针，函数指针指向的函数是一个带2个参数,返回void的函数，所带的两个参数是 指向整型的指针，和整型
p[ 0 ] = f1; p[ 1 ] = f2 contain address of . name without parenthesis represent address of Value and address of variable is passed to only argument that is effected is a (address is passed). Because of call by value f1, f2 can not effect b

第11题: (a)
 
考查--操作和递归调用,仔细分析一下就可以了

第12题: (c)
建议不会的看看C专家编程
从左往有，遇到括号停下来，将第一个括号里的东西看成一个整体 

第14题: (b)

sizeof(int)的值是2,所以p+=sizeof(int) 指向 argv[2],这点估计大家都没有什么疑问

(p+=sizeof(int))[-1] 指向 argv[1],能理解吗，因为(p+=sizeof(int))[-1] 就相当于 (p+=2)[-1] ,也就是(p+2-1)

第15题: (c)

va_list p; /*定义一个变量 ,保存 函数参数列表 的指针*/
va_start( p , n); /*用va_start宏 初始化 变量p, 
va_start宏的第2个参数n ,
是一个固定的参数,
必须是我们自己定义的变长函数的最后一个入栈的参数
也就是调用的时候参数列表里的第1个参数*/
for (; j<n; ++j) /* j从1开始, 遍历所有可变参数 */
{
i = va_arg( p , int); /*va_arg取出当前的参数,
并认为取出的参数是一个整数(int) */
for (; i; i &=i-1 ) /*判断取出的i是否为0*/
++k; /* 如果i不为0, k自加, 
i与i-1进行与逻辑运算, 直到i 为0
这是一个技巧，下面会谈到它的功能*/
}

(; i; i&=i-1) k++ /* 计算i有多少bit被置1 */ 

令 i= 9 = 1001
i-1 = 1000 
(i-1) +1 = i
1000
+1
1 001