C/C++笔记
int a[100];
sizeof (a) 的值是多少？
sizeof(a[100])呢？//请尤其注意本例。
sizeof(&a)呢？
sizeof(&a[0])呢？
int b[100];
void fun(int b[100])
{
sizeof(b);// sizeof (b) 的值是多少？
}
2.
intmain()
{
char a[1000];
int i;
for(i=0; i<1000; i++)
{
a[i] = -1-i;
}
printf("%d",strlen(a));
return 0;}
3.
int i = -20;
unsigned j = 10;
i+j的值为多少？为什么？
4.
下面的代码有什么问题？
unsigned i ;
for (i=9;i>=0;i--)
{
printf("%u\n",i);
}
5.
判断系统是大端模式还是小端模式
int checkSystem( )
{
union check
{
int i;
char ch;
}c;
c.i = 1;
return (c.ch ==1);
}
6.
在 x86系统下，输出的值为多少？
#include <stdio.h>
int main()
{
int a[5]={1,2,3,4,5};
int *ptr1=(int *)(&a+1);
int *ptr2=(int *)((int)a+1);
printf("%x,%x",ptr1[-1],*ptr2);
return 0;
}
对指针进行加 1 操作，得到的是下一个元素的地址，而不是原有地址值直接加 1。所以，
一个类型为 T 的指针的移动，以 sizeof(T) 为移动单位。 因此，对上题来说，a 是一个一
维数组，数组中有 5 个元素； ptr 是一个 int 型的指针。
&a + 1: 取数组 a 的首地址，该地址的值加上 sizeof(a) 的值，即 &a + 5*sizeof(int)，也
就是下一个数组的首地址，显然当前指针已经越过了数组的界限。
(int *)(&a+1): 则是把上一步计算出来的地址，强制转换为 int * 类型，赋值给 ptr。
*(a+1): a,&a的值是一样的，但意思不一样，a 是数组首元素的首地址，也就是 a[0]的
首地址，&a是数组的首地址，a+1是数组下一元素的首地址，即a[1]的首地址,&a+1是下一
个数组的首地址。所以输出 2
*(ptr-1): 因为 ptr 是指向 a[5]，并且 ptr 是 int * 类型，所以 *(ptr-1) 是指向 a[4] ，
输出 5。
7.
#include <stdio.h>
int main()
{
unsigned int a=0xFFFFFFF7;
unsigned char i=(unsigned char)a;
char *b=(char*)&a;
printf("%08x,%08x\n",i,*b);
return 0;
}
输出结果为：000000f7，fffffff7.
开始不明白，对于*b为什么输出的是整个a的值，而不是a的低字节。
原来是这样的，*b的值是f7，但用%08x格式输出，首先将*b扩展成
32位然后输出，所以误以为*b的值和a相等。验证如下：
#include <stdio.h>
int main()
{
unsigned int a=0xFFFFFFF7;
unsigned char i=(unsigned char)a;
unsigned char *b=(unsigned char*)&a;//改为无符号的
printf("%08x,%08x\n",i,*b);
return 0;
}
输出结果为：000000f7，000000f7
或将代码改为如下：
#include <stdio.h>
int main()
{
unsigned int a=0xFEBDCAF7;
unsigned char i=(unsigned char)a;
char *b=(char*)&a;
printf("%08x,%08x\n",i,*b);
return 0;
}
输出结果为：000000f7，fffffff7
8.
sizeof问题
struct A
{
int i;
char c1;
char c2;
};
struct B
{
char c1;
int i;
char c2;
};
sizeof(A)=8,sizeof(B)=12,内存对齐问题
这里有三点很重要:
首先，每个成员分别按自己的方式对齐,并能最小化长度。
其次， 复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂
类型时,可以最小化长度。
然后，对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保
证每一项都边界对齐。
补充一下,对于数组,比如:char a[3];它的对齐方式和分别写 3个 char是一样的.也就是说
它还是按 1 个字节对齐.如果写: typedef char Array3[3];Array3这种类型的对齐方式还是按 1
个字节对齐,而不是按它的长度。
但是不论类型是什么,对齐的边界一定是 1,2,4,8,16,32,64....中的一个。
9.
mutable关键字
class A
{
public:
void f(void) const{a=1;};
private:
int a;
};
不修改函数f（），使编译通过，在int a前面加mutable
10.
有关注释问题
我们看看下面的例子：
A） ，int/*...*/i;
B） ，char* s="abcdefgh //hijklmn";
C), //Is it a \
valid comment?
D), in/*…*/t i;
我们知道 C 语言里可以有两种注释方式：/* */ 和//。那上面 3 条注释对不对呢？建议你
亲自在编译器中测试一下。上述前３条注释都是正确的，最后一条不正确。
A),有人认为编译器剔除掉注释后代码会被解析成 inti，所以不正确。编译器的确会将注
释剔除，但不是简单的剔除，而是用空格代替原来的注释。再看一个例子：
/*这是*/#/*一条*/define/*合法的*/ID/*预处理*/replacement/*指*/list/*令*/
你可以用编译器试试。
B),我们知道双引号引起来的都是字符串常量，那双斜杠也不例外。
C),这是一条合法的注释，因为\是一个接续符。
D), 前面说过注释会被空格替换，那这条注释不正确就很好理解了。
但注意：/*…*/这种形式的注释不能嵌套，如：
/*这是/*非法的*/*/
因为/*总是与离它最近的*/匹配。
又一例：
y = x/*p
y=x/*p，这是表示 x 除以 p 指向的内存里的值，把结果赋值为 y？我们可以在编译器
上测试一下，编译器提示出错。
实际上，编译器把/*当作是一段注释的开始，把/*后面的内容都当作注释内容，直到出
现*/为止。这个表达式其实只是表示把 x 的值赋给 y，/*后面的内容都当作注释。但是，由
于没有找到*/，所以提示出错。
我们可以把上面的表达式修改一下：
y=x/ *p
或者
y = x/(*p)
这样的话，表达式的意思就是 x除以 p指向的内存里的值，把结果赋值为 y了。
也就是说只要斜杠（/）和星号（*）之间没有空格，都会被当作注释的开始。这一点一
定要注意。
11.
按位异或操作实现不用第三个临时变量交换两个变量的值：
a^=b;b^=a;a^=b;但并不推荐这么做，因为这样的代码读起来很费劲。
注意比a=a+b;b=a-b;a=a-b;好在哪，溢出问题。
12.
要注意的运算符优先级
13。
看看下面的例子：
#define BSC //
#define BMC /*
#define EMC */
D),BSC my single-line comment
E),BMC my multi-line comment EMC
D)和 E)都错误，为什么呢？因为注释先于预处理指令被处理,当这两行被展开成//…或
/*…*/时,注释已处理完毕,此时再出现//…或/*…*/自然错误.因此,试图用宏开始或结束一段
注释是不行的。
14.
指针数组与数组指针
A)，int *p1[10];
B)，int (*p2)[10];
这里需要明白一个符号之间的优先级问题。
“[]”的优先级比“*”要高。p1先与“[]”结合，构成一个数组的定义，数组名为 p1，int *
修饰的是数组的内容，即数组的每个元素。那现在我们清楚，这是一个数组，其包含 10个
指向 int类型数据的指针，即指针数组。至于 p2就更好理解了，在这里“ （） ”的优先级比
“[]”高， “*”号和 p2构成一个指针的定义，指针变量名为 p2，int修饰的是数组的内容，
即数组的每个元素。数组在这里并没有名字，是个匿名数组。那现在我们清楚 p2是一个指
针，它指向一个包含 10个 int类型数据的数组，即数组指针。
15.
看下面这个例子：
struct Test
{
int Num;
char *pcName;short sDate;
char cha[2];
short sBa[4];
}*p;
假设 p 的值为 0x100000。 如下表表达式的值分别为多少？
p + 0x1 = 0x___ ?
(unsigned long)p + 0x1 = 0x___?
(unsigned int*)p + 0x1 = 0x___?
p+0x1的值为 0x100000+sizof（Test）*0x1。至于此结构体的大小为 20byte，前面的章
节已经详细讲解过。所以 p+0x1的值为：0x100014。
(unsigned long)p + 0x1的值呢？这里涉及到强制转换，将指针变量p保存的值强制转换
成无符号的长整型数。任何数值一旦被强制转换，其类型就改变了。所以这个表达式其实就
是一个无符号的长整型数加上另一个整数。所以其值为：0x100001。
(unsigned int*)p + 0x1的值呢？这里的 p被强制转换成一个指向无符号整型的指针。所
以其值为：0x100000+sizof（unsigned int）*0x1，等于 0x100004。
16.
#include <stdio.h>
intmain(int argc,char * argv[])
{
int a [3][2]={(0,1),(2,3),(4,5)};
int *p;
p=a [0];
printf("%d",p[0]);
}
问打印出来的结果是多少？
很多人都觉得这太简单了，很快就能把答案告诉我：0。不过很可惜，错了。答案应该
是 1。如果你也认为是 0，那你实在应该好好看看这个题。花括号里面嵌套的是小括号，而
不是花括号！ 这里是花括号里面嵌套了逗号表达式！ 其实这个赋值就相当于 int a [3][2]={ 1, 3,
5};
所以，在初始化二维数组的时候一定要注意，别不小心把应该用的花括号写成小括号
了。
17.
看下面的例子：
void GetMemory（char * p, int num）
{
p = (char *)malloc(num*sizeof(char));
}
intmain()
{
char *str = NULL;
GetMemory（str，10）;
strcpy(str,”hello”);
free（str） ；//free并没有起作用，内存泄漏
return 0;
}
在运行 strcpy(str,”hello”)语句的时候发生错误。 这时候观察 str的值， 发现仍然为NULL。
也就是说 str本身并没有改变，我们 malloc的内存的地址并没有赋给 str，而是赋给了_str。
而这个_str是编译器自动分配和回收的，我们根本就无法使用。所以想这样获取一块内存是
不行的。那怎么办? 两个办法：
第一：用 return。
char * GetMemory（char * p, int num）
{
p = (char *)malloc(num*sizeof(char));
return p；
}
intmain()
{
char *str = NULL;
str = GetMemory（str，10）;
strcpy(str,”hello”);
free（str） ；
return 0;
}
这个方法简单，容易理解。
第二：用二级指针。
void GetMemory（char ** p, int num）
{
*p = (char *)malloc(num*sizeof(char));
return p；
}
int main()
{
char *str = NULL;
GetMemory（&str，10）;
strcpy(str,”hello”);
free（str） ；
return 0;
}
注意，这里的参数是&str而非 str。这样的话传递过去的是 str的地址，是一个值。在函
数内部，用钥匙（ “*” ）来开锁：*(&str)，其值就是 str。所以 malloc分配的内存地址是真正
赋值给了 str本身。
18.
fread和fwrite函数一般用于二进制文件的输入输出，fprintf与fscanf函数与printf函数、scanf函数作用相仿，都是格式化读写函数。
用fprintf和fscanf函数对磁盘文件读写，使用方面，容易理解，但由于在输入时要将二进制形式转换成字符，花费时间比较多。因此，在内存与磁盘频繁交换数据的情况下，最好不用fprintf和fscanf函数，而用fread和fwrite。
