筆試常見函數題（讀懂這些函數後，筆試強了不少）

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));    //按從右到左的順序  輸出8,8

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=32+20

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