首页 > 代码库 > 笔试常见函数题（读懂这些函数后，笔试强了很多）

笔试常见函数题（读懂这些函数后，笔试强了很多）

2024-08-18 22:38:36   225人阅读

1：

判断有无符号

void foo(void)

{

unsigned int a = 6;

int b = -20;

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

}

答案和解释：

　　输出 > 6，原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。-20成了一个非常大的正数。

补充：

判断有无符号的宏函数：
#define issignal(x) ((x>=0 && ~x>=0) ? 1:0) //为1是无符号 为0有符号

2：

nt func(x) 
{ 
int countx = 0; 
while(x) 
{ 
countx ++; 
x = x&(x-1); 
} 
return countx; 
}

答案和解释：

　　假定x = 9999。 答案：8
思路：将x转化为2进制，看含有的1的个数。

3：

#include<stdio.h>
void myprint(x){
    int i=0;
    for(i=31;i>=0;i--){
        printf("%d",(x>>i)&1);
        }
    }
void main(){
    myprint(5);
    }

作用：将一个数用二进制输出

4：

！注意宏定义机械替代
若有宏定义：#define MOD(x，y) x％y

则执行以下语句后的输出结果是

int a=13，b=94；

printf(″％d\n″，MOD(b，a+4))；

A.5

B.7

C.9

D.11

参考答案：B

但是：
#define N 3

#define Y(n) ((N+1)*n)//区别#define Y(n) ( (N+1)*(n))！

则表达式2*(N+Y(5+1))的值是

A.42

B.48

C.54

D.出错


参考答案：B
Y(5+1) 传递过去的应该是6，而不是简单的把5+1给替换掉

5：

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

答案和解释：

分析：*(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] //a[5]下一个数组对象的地址==元素首地址
但是prt与(&a+1)类型是不一样的(这点很重要)
所以prt-1只会减去sizeof(int*)。 a,&a的地址是一样的，但意思不一样，a是数组首地址，也就是a[0]的地址，&a是对象（
数组）首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的首地址，即a[5].

6：

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是数组变量，它们有各自的内存空间,指向不同的内存，str1相当于是一个有独立内存空间的指针变量；
而str5,str6,str7,str8是指针，它们指向相同的常量区域。

7：

int  main()  {     
    char a;         
    char *str=&a; 
    char str1[10];
    strcpy(str,"hello");  （错）
    strcpy(str1,"hello");(对)    
    printf(str);       
    return 0;  
}

答案和解释：

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

8:

使用初始化列表和赋值方法进行成员数据的初始化

class A{
int a,b;
public:
A(int x):b(x),a(b){}
};
初始化列表是按成员被定义的顺序执行的，也就是虽然你在列表里后写的a，但是因为a先定义的，
所以还是会先执行a的初始化。也就是你的a是用未初始化的b的值初始化的。
class CExample {
public:
 int a; float b;
 CExample(): a(0),b(8.8) {}//构造函数初始化列表 
 CExample() { a=0; b=8.8; }
};
构造函数内部赋值 CExample() { a=0; b=8.8; } }; 上面的例子中两个C++构造函数的结果是
一样的。上面的构造函数（使用初始化列表的构造函数）显式的初始化类的成员；而没使用初始化
列表的构造函数是对类的成员（所以当成员数据是const这个方法就不可行了，必须要用初始化列表）！，
并没有进行显式的初始化。

9：

unsigned char *p1;     
unsigned long *p2;      
p1=(unsigned char *)0x801000;     
p2=(unsigned long *)0x810000;     
请问p1+5=  ;              p2+5=  ;

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

10：

 指针和*以及++之间常见的运算顺序问题汇总

int i=1;
printf("%d  %d  ",i++,i++);//2 1
printf("%d",i);// 3

int arr[]={6,7,8,9,10};       
int *ptr=arr;      
*(ptr++)+=123;     //先算*ptr=*ptr+123; 再 ptr++;所以arr[0]= 129; *p++=*(p++)?
printf(＂%d,%d＂,*ptr,*(++ptr));    //按从右到左的顺序

int a[3];  
a[0]=0;  
a[1]=1; 
a[2]=2;   
int *p, *q;   
p=a;   
q=&a[2];  
则a[q-p]=?  
答：a[q-p]=a[2]=2;这题是要告诉我们指针的运算特点???


11：

typedef union  
{  long i;  
int k[5];  
char c; 
} DATE;  
struct data  {       
int cat;       
DATE cow;       
double dog; 
} too;   
DATE max;   
则语句 printf("%d",sizeof(too)+sizeof(max));的执行结果是：52

12：

静态变量在全局静态区，下次访问会保留上次的赋值

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,", sum(a));   
}  } 

答案：8,10,12,14,16

笔试常见函数题（读懂这些函数后，笔试强了很多）


联系
我们