j++;
if(i >= MAX)
{
MAX = 2 * MAX;
b = (int*)realloc(a,MAX * sizeof(int));
if(b == NULL)
{
printf("error3");
exit(-1);
}
a = b;
}
}

for(;--j >= 0;)
   fprintf(fp2,"%d\n",a[j]);

fclose(fp1);
fclose(fp2);

return 0;
}

6。void g(int**);
int main()
{
int line[10],i;
int *p=line; 
for (i=0;i<10;i++)
{
*p=i;
g(&p);
}
for(i=0;i<10;i++)
printf("%d\n",line[i]);
return 0;
}

void g(int**p)
{
(**p)++;
(*p)++;
}
輸出？


答案：1
2 
3 
4 
5 
6 
7 
8 
9 
10這道題目不是很好理解，我們可以把題目g函數改為

void g(int**s)
{
(**s)++;
(*s)++;
}

這樣不容易看混淆s就是一個形式參數，g(&p)輸入的就是p的地址，這樣有如下指向：*p－》p－》line調用函數時候，**s對應*p即數組中的數,*s對應p即數組數字的地址，這樣就可以知道了(**s)++是line中的內容增加；(*s)++是地址增加。

7。寫出程序運行結果

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

答案：static會保存上次結果，記住這一點，剩下的自己寫
輸出：8,10,12,14,16,

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[2]


答案：指針一次移動一個int但計數為1，p＝a；q＝a＋2。

 
 


 

 

 

1。分析下面的程序：
void GetMemory(char **p,int num)
{
    *p=(char *)malloc(num);
    
}        
int main()
{
    char *str=NULL;
    
    GetMemory(&str,100);
    
    strcpy(str,"hello");
    
    free(str);
    
    if(str!=NULL)
    {
        strcpy(str,"world");
    }    
        
    printf("\n str is %s",str);
    getchar();
}    
問輸出結果是什么？

答案：輸出str is world。
free 只是釋放的str指向的內存空間,它本身的值還是存在的.
所以free之后，有一個好的習慣就是將str=NULL.
此時str指向空間的內存已被回收,如果輸出語句之前還存在分配空間的操作的話,這段存儲空間是可能被重新分配給其他變量的,
盡管這段程序確實是存在大大的問題（上面各位已經說得很清楚了），但是通常會打印出world來。
這是因為，進程中的內存管理一般不是由操作系統完成的，而是由庫函數自己完成的。
當你malloc一塊內存的時候，管理庫向操作系統申請一塊空間（可能會比你申請的大一些），然后在這塊空間中記錄一些管理信息（一般是在你申請的內存前面一點），并將可用內存的地址返回。但是釋放內存的時候，管理庫通常都不會將內存還給操作系統，因此你是可以繼續訪問這塊地址的，只不過。。。。。。。。樓上都說過了，最好別這么干。

2。運行的結果為什么等于15

#include "stdio.h"
#include "string.h"

void main()
{

char aa[10];
printf("%d",strlen(aa));
}

答案：sizeof()和初不初始化，沒有關系；strlen()和初始化有關。

3。給定結構struct A 
{
       char t:4;
       char k:4;
       unsigned short i:8;
       unsigned long m;
};問sizeof(A) = ?

答案：給定結構

struct A 
{
       char t:4; //4位
       char k:4; //4位
       unsigned short i:8; //8位 這里要偏移2字節保證4字節對齊    
       unsigned long m; //4個字節
}; // 共8字節

4。分析一下
#include<iostream.h>
#include <string.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
typedef struct  AA
{
        int b1:5;
        int b2:2;
}AA;
void main()
{
       AA aa;
       char cc[100];
       strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz");
       memcpy(&aa,cc,sizeof(AA));
       cout << aa.b1 <<endl;
       cout << aa.b2 <<endl;
}


答案： -16和１
首先sizeof(AA)的大小為4,b1和b2分別占5bit和2bit.
經過strcpy和memcpy后,aa的4個字節所存放的值是:
0,1,2,3的ASC碼，即00110000,00110001,00110010,00110011
所以，最后一步：顯示的是這４個字節的前５位，和之后的２位
分別為：10000,和01
因為int是有正負之分　　所以是-16和１

5。求函數返回值，輸入x=9999; 
int func （ x ）
{ 
    int countx = 0; 
    while ( x ) 
    { 
        countx ++; 
        x = x&(x-1); 
    } 
    return countx; 
} 
結果呢？


答案：知道了這是統計9999的二進制數值中有多少個1的函數，且有
9999＝9×1024＋512＋256＋15

9×1024中含有1的個數為2；
512中含有1的個數為1；
256中含有1的個數為1；
15中含有1的個數為4；
故共有1的個數為8，結果為8。
1000 - 1 = 0111，正好是原數取反。這就是原理。
用這種方法來求1的個數是很效率很高的。
不必去一個一個地移位。循環次數最少。

6。int a,b,c 請寫函數實現C=a+b ,不可以改變數據類型,如將c改為long int,關鍵是如何處理溢出問題
答案：bool add (int a, int b,int *c)
{
*c=a+b;
return (a>0 && b>0 &&(*c<a || *c<b) || (a<0 && b<0 &&(*c>a || *c>b)));
}

 

7。分析：
struct bit 
{   int a:3; 
    int  b:2; 
    int c:3; 
}; 
int main() 
{ 
  bit s; 
  char *c=(char*)&s; 
   cout<<sizeof(bit)<<endl;
  *c=0x99;
   cout << s.a <<endl <<s.b<<endl<<s.c<<endl; 
     int a=-1;
   printf("%x",a);
  return 0; 
} 
輸出為什么是？

答案：4
1
-1
-4
ffffffff
因為0x99在內存中表示為 100 11 001 , a = 001, b = 11, c = 100（在vc環境中，一般是由右到左進行分配的）
當c為有符合數時, c = 100, 最高1為表示c為負數，負數在計算機用補碼表示，所以c = -4;同理 
b = -1;
當c為有符合數時, c = 100,即 c = 4,同理 b = 3

8。改錯：
#include <stdio.h>

int main(void) {

    int **p;
    int arr[100];

    p = &arr;

    return 0;
}

答案：搞錯了,是指針類型不同,
int **p; //二級指針
&arr; //得到的是指向第一維為100的數組的指針
應該這樣寫#include <stdio.h>
int main(void) {
int **p, *q;
int arr[100];
q = arr;
p = &q;
return 0;

9。下面這個程序執行后會有什么錯誤或者效果:
 #define MAX 255
 int main()
{
   unsigned 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了..無限循環下去.


11。struct name1{
   char  str;
   short x;
   int   num;
}

struct name2{
   char str;
   int num;
   short x;
}

sizeof(struct name1)=？？,sizeof(struct name2)=？？

答案：sizeof(struct name1)=8,sizeof(struct name2)=12
在第二個結構中，為保證num按四個字節對齊，char后必須留出3字節的空間；同時為保證整個結構的自然對齊（這里是4字節對齊），在x后還要補齊2個字節，這樣就是12字節。