}AA;
void main()
{
AA aa;
char cc[100];
strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz");
memcpy(&aa,cc,sizeof(AA));
cout << aa.b1 <
cout << aa.b2 <
}
答案是 -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和１

求函數返回值，輸入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的個數是很效率很高的。
不必去一個一個地移位。循環次數最少。

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<0 && b<0 &&(*c>a || *c>b)));
}


分析：
struct bit
{ int a:3;
int b:2;
int c:3;
};
int main()
{
bit s;
char *c=(char*)&s;
cout<<
*c=0x99;
cout << s.a <<<<<
int a=-1;
printf("%x",a);
return 0;
}
輸出為什么是
4
1
-1
-4
ffffffff
因為0x99在內存中表示為 100 11 001 , a = 001, b = 11, c = 100
當c為有符合數時, c = 100, 最高1為表示c為負數，負數在計算機用補碼表示，所以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()
{
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了..無限循環下去.

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\n", sizeof(s1));
printf("sizeof(s2)= %d\n", sizeof(s2));
result: 16, 24
第一個struct s1
{
int i: 8;
int j: 4;
int a: 3;
double b;
};
理論上是這樣的，首先是i在相對0的位置，占8位一個字節，然后，j就在相對一個字節的位置，由于一個位置的字節數是4位的倍數，因此不用對齊，就放在那里了，然后是a，要在3位的倍數關系的位置上，因此要移一位，在15位的位置上放下，目前總共是18位，折算過來是2字節2位的樣子，由于double是8 字節的，因此要在相對0要是8個字節的位置上放下，因此從18位開始到8個字節之間的位置被忽略，直接放在8字節的位置了，因此，總共是16字節。

第二個最后會對照是不是結構體內最大數據的倍數，不是的話，會補成是最大數據的倍數
1）讀文件file1.txt的內容（例如）：
12
34
56
輸出到file2.txt：
56
34
12
（逆序）
2）輸出和為一個給定整數的所有組合
例如n=5
5=1+4；5=2+3（相加的數不能重復）
則輸出
1，4；2，3。
望高手賜教！！

第一題,注意可增長數組的應用.
#include 
#include 

int main(void)
{
int MAX = 10;
int *a = (int *)malloc(MAX * sizeof(int));
int *b;

FILE *fp1;
FILE *fp2;

fp1 = fopen("a.txt","r");
if(fp1 == NULL)
{printf("error1");
exit(-1);
}

fp2 = fopen("b.txt","w");
if(fp2 == NULL)
{printf("error2");
exit(-1);
}

int i = 0;
int j = 0;

while(fscanf(fp1,"%d",&a[i]) != EOF)
{
i++;
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;


}

第二題.
#include 

int main(void)
{
unsigned long int i,j,k;

printf("please input the number\n");
scanf("%d",&i);
if( i % 2 == 0)
j = i / 2;
else
j = i / 2 + 1;

printf("The result is \n");
for(k = 0; k < j; k++)
printf("%d = %d + %d\n",i,k,i - k);
return 0;
}

#include 
void main()
{
unsigned long int a,i=1;
scanf("%d",&a);
if(a%2==0)
{
for(i=1;i
printf("%d",a,a-i);
}
else
for(i=1;i<=a/2;i++)
printf(" %d, %d",i,a-i);
}

兄弟,這樣的題目若是做不出來實在是有些不應該, 給你一個遞規反向輸出字符串的例子,可謂是反序的經典例程.

void inverse(char *p)
{
if( *p = = '' )
return;
inverse( p+1 );
printf( "%c", *p );
}

int main(int argc, char *argv[])
{
inverse("abc");

return 0;
}

借簽了樓上的“遞規反向輸出”
#include 
void test(FILE *fread, FILE *fwrite)
{
char buf[1024] = {0};
if (!fgets(buf, sizeof(buf), fread))
return;
test( fread, fwrite );
fputs(buf, fwrite);
}
int main(int argc, char *argv[])
{
FILE *fr = NULL;
FILE *fw = NULL;
fr = fopen("data", "rb");
fw = fopen("dataout", "wb");
test(fr, fw);
fclose(fr);
fclose(fw);
return 0;
}

在對齊為4的情況下
struct BBB
{
long num；
char *name;
short int data;
char ha;
short ba[5];
}*p;
p=0x1000000;
p+0x200=____;
(Ulong)p+0x200=____;
(char*)p+0x200=____;
希望各位達人給出答案和原因，謝謝拉
解答：假設在32位CPU上，
sizeof(long) = 4 bytes
sizeof(char *) = 4 bytes
sizeof(short int) = sizeof(short) = 2 bytes
sizeof(char) = 1 bytes

由于是4字節對齊，
sizeof(struct BBB) = sizeof(*p)
= 4 + 4 + 2 + 1 + 1/*補齊*/ + 2*5 + 2/*補齊*/ = 24 bytes (經Dev-C++驗證)

p=0x1000000;
p+0x200=____;
= 0x1000000 + 0x200*24

(Ulong)p+0x200=____;
= 0x1000000 + 0x200

(char*)p+0x200=____;
= 0x10000