C语言-易错点汇总

---

指针数组和数组指针

指针数组是一个数组。如同 int arr[10],表示arr数组有10个元素，每一个元素都是整型
指针数组 int* arr[10],表示arr数组有10个元素，每一个元素都是指针；

数组指针是指针。int (*arr)[10],arr先与 *结合，说明arr是一个指针，然后指向一个大小为10个整型的数组。注意：[]的优先级要高于*，所以必须加上()来保证arr与*结合。

---

(*p).a

#include < stdio.h >
struct S
{ 
  int a;
  int b; 
};
int main( )
{ 
  struct S a, *p=&a;
  a.a = 99;
  printf( "%d\n", __________);
  return 0;
}

*p.a 这种表示方式是错误的，.的优先级要高于*，那么就是先要看p.a,而p是一个指针，指针是不能使用.的操作的
(*p).a (*p)表示结构体变量p，.a表示p中的成员a

---

struct stdent和typedef struct stdent

struct stdent
{
	char name[20];
	char sex[10];
	int age[5];
}stu;
//stu是结构体变量

typedef struct stdent
{
	char name[20];
	char sex[10];
	int age[5];
}stu;
//stu是类型

注意：typedef是为一个类型起一个新的名字

---

F5和Ctrl+F5

F5是开始调试，在遇到短点的位置可以停下来；
Ctrl+F5是开始执行，不调试

---

const的位置

一个变量被const修饰，那么它的值就不能被改变；

const type name = value;

const和type的位置是可以互换的，也即是type const name = value;
比如：const char *p和char const *p是一个意思，p所指向的内容不可变，但p本身可变。

---

全局变量和局部变量

全局变量未初始化，默认值为0；局部变量未初始化，默认值为随机值；

---

两个相同的常量字符串

由const修饰的常量字符串不能被修改（即使没有const，也是不能被修改的），当创建两个相同的常量字符串的时候，在内存中只创建了一份。也就是说，当两个不同的指针指向这两个相同的字符串的时候，他们所指向的是同一个地址。如下：

	const char* str3 = "hello bit.";
	const char* str4 = "hello bit.";

str3和str4的值是相同的，存放的是同一个地址。

---

数组名和&数组名

数组名是首元素的地址，&数组名是数组的地址
数组首元素的地址和数组的地址从值的大小来看，是相等的，但是，他们的意义不同。
arr+1,是该数组内第二个元素的地址；&arr+1，是跳过了整个数组后的地址。

---

数组指针定义的解读

int (*p)[5]   首先是一个指针，这个指针指向一个数组[]，
该数组内由5个元素，指针名字为p，又不想p与[5]结合，
所以*p需要加括号，这个数组内每一个元素都是整型

---

int (*arr[10])[5]

这是一个数组，因为，先看*arr[10],*没有被圈起来，说明arr先与[]结合，
说明是一个数组，然后把arr[10]拿掉，变成了int (*)[5],
说明数组里的每一个元素都是数组指针，指针指向一个数组，
该数组内有5个元素，每一个元素都是整型,示意图如下：

---

数组传参

数组传参，形参的部分可以是数组，可以不指定大小，类型交代清楚就可以，如下：

void test(int arr[])
{}
void test(int arr[10])
{}

---

(* (void (*)())0)();

(*(void (*)())0)();
void (*p)(),这是一个函数指针，去掉p后，就变成了函数指针的类型，括号
里面是一个类型，后面又有数据0，把0强制转换为函数指针类型，把0当作一个函数的地址
,前面又有一个*号，对函数地址解引用操作，为函数，函数后面又有一个小括号，表明为无参


void (*signal(int, void(*)(int)))(int);
首先signal是一个函数名，这个函数有两个形参，一个是整型int，另一个是函数指针
类型，该函数指针指向的那一个函数的形参是整型，函数返回的类型为void
而singal函数的返回值又作为了一个函数指针，该指针指向的那一个函数的参数为整型，
返回类型为void

---

关于数组名是否表示整个数组和数组首元素的地址

1.sizeof（数组名），数组名表示整个数组，计算的是整个数组的大小
2.&数组名，数组名表示整个数组，取出的是整个数组的地址
除此之外，所有的数组名都是数组首元素的地址

int a[5]={1,2,3,4,5};
sizeof(*&a)等价于sizeof(a)=5*4=20,这里的a表示整个数组
在sizeof之外，*&a=a，表示数组的首地址 

---

结构体内存对齐

结构体内存对齐,成员变量空间的开辟
1.结构体的第一个成员对齐到结构体在内存中存放位置的0偏移处，占几个字节的空间，就给几个字节的空间
2.从第二个成员开始，每个成员都要对齐到一个对齐数的整数倍处
对齐数：结构体成员自身大小和默认对齐数的较小值
VS：默认对齐数为8
linux gcc ：没有默认对齐数，对齐数就是成员自身的大小
3.结构体的总大小必须是所有成员（包含嵌套的结构体成员中的对齐数）的对齐数中最大对齐数的整数倍
4.如果结构体中嵌套了结构体变量，要将嵌套的结构体变量对齐到自己成员中最大对齐数的整数倍处

---

空指针和野指针

对零位置处的位置进行访问，空指针所指向的位置处
空指针不会指向任何地方，即它不指向任何数据，但是源码中的空指针的常量是整数0，使得指针指向0位置处
但是，大多数系统都将0作为不被使用的地址
空指针和野指针 空指针不等于未初始化的指针，未初始化的指针通常是指野指针，野指针可以指向任何地方，乱指，可能会造成非法访问内存地址，而空指针不指向任何对象

---

函数传参问题

void GetMemory(char* p)
//char* p 说明与str的类型相同，说明此处进行的是值传递
//如果此处要进行地址传递的话，应该是GetMemory(&str)  void GetMemory(char** p)

//它与int a &a 是一样的，只不过这里的变量不再是普通的变量，而是一个指针变量
//GetMemory(a)  void GetMemory(int b)
//GetMemory(&a) void GetMemory(int* b)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

---

直接打印字符串的首地址，可打出字符串

	char* p = "hehe\n";
	printf("hehe\n");
	printf(p);//直接打印字符串的首地址

---

函数内部数组和指针中存储的常量字符串

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
//p是一个局部变量，出了函数就会被销毁
char* GetMemory(void)
{
	char* p = "hello world";
	return p;
}
//这里的p指向的是一个常量字符串，出了函数，它仍然存在
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

---

预定义#define和函数下的计算max的两个带有副作用的例子

关于预定义#define和函数下的计算max的两个带有副作用的例子

#define MAX(x,y) (x)>(y)?(x):(y)

int main()
{
	int a = 4;
	int b = 6;
	int m = MAX(a++, b++);
	//(a++)>(b++)?(a++):(b++)
	//后置++，对于(a++)>(b++)，先比较。4>6,不成立，变为（5）>(7)
	//条件表达式，条件不成立，直接跳至（b++），此时b=7，将7作为结果赋值给m
	//之后6++，变为8，也即是b=8，?(a++)，这部分没有执行，a=5, m=7
	printf("%d",m);
	return 0;
}

int MAX(int x,int y)
{
	return x > y ? x : y;
}
int main()
{
	int a = 4;
	int b = 6;
	int m = MAX(a++, b++);
	//会将a=4，b=6带入MAX函数，之后a++，a=5，b++，b=7.
	//那么x=4,y=6,return 带回的返回值为6，于是m=6
	printf("%d\n",m);
	printf("%d %d\n", a, b);
	return 0;
}

---

unsigned char的加减问题

int main()
{
	unsigned char i = 7;   //unsigned char 1111 1111  取值范围0-255   char -128~+128
	int j = 0;
	for (;i>0;i-=3) //这里不成功，只有i=0；
	{
		++j;
	}
	printf("%d\n",j);
	return 0;
}

7 4 1 -2? X
对于unsigned char 1-1=0 1-2=255 再减一为254
7 4 1 254 251… 5 2 255 252 249… 0
3 84 1 85 1 173

int main()
{
 int a = -3;
 unsigned int b = 2;
 long c = a + b;//内存中补码相加
 printf("%ld\n",c);
 return 0;
}

-3
原10000000 00000000 00000000 00000011
反11111111 11111111 11111111 11111100
补11111111 11111111 11111111 11111101

2 整数的原，反，补相同
00000000 00000000 00000000 00000010
相加的结果，在内存中，是补码
11111111 11111111 11111111 11111111
由补码换算为原码（规则同原码到补码）
10000000 00000000 00000000 00000000
10000000 00000000 00000000 00000001  -1

---

二进制奇数位和偶数位的互换

二进制奇数位和偶数位的互换：
奇数位拿出来，向左移动一位；偶数位拿出来，向右移动一位
奇数位与1与，偶数位和0与，保留奇数位，之后整体左移一位。偶数位同理
0110
0101
0100
1000
0110
1010
0010
0001
1000
0001
1001
一个整型4字节，32位
01010101
0x55555555
10101010
0xaaaaaaaa

#define SWAP_BIT(x) x=(((x&0x55555555)<<1)+((x&0xaaaaaaaa)>>1))

int main()
 {
	 int a = 10;
	 SWAP_BIT(a);
	 printf("%d\n",a);
	 return 0;
 }

---

*p[1] + 3 和 *(p[1] + 3)

int main()
{
	char* p[] = { "shanghai","Beijing","honkong" };
	printf("%c\n", *p[1] + 3);
	printf("%c\n", *(p[1] + 3));
	return 0;
}

char* p[] 是一个指针数组，该数组内有4个元素，每一个元素都是指针类型。
*p[1] + 3，找到该数组的第一个元素，它是一个地址，对它解引用，得到该地址的第一个元素B，B+3=E
*(p[1] + 3)，找到该数组的第一个元素，它是一个地址，也是首元素的地址，即是B的地址，地址+3，也就是j的地址，对它解引用，得到j

---

连续输入两个带空格的字符串（scanf，gets，getchar）

scanf
gets
getchar
连续输入两个带空格的字符串
1 scanf

int main()
{
	char arr1[20] = { 0 };
	char arr2[20] = { 0 };

	scanf("%[^\n]", arr1);//读到\n处，停止读取
	getchar();//吞掉缓冲区的\n
	scanf("%[^\n]",arr2);

	printf("%s\n", arr1);
	printf("%s\n",arr2);
	return 0;
}

2 gets：可以看到gets函数有警告提示，但是不影响结果。

int main()
{
	char arr1[20] = { 0 };
	char arr2[20] = { 0 };

	//scanf("%[^\n]", arr1);//读到\n处，停止读取
	//getchar();//吞掉缓冲区的\n
	//scanf("%[^\n]",arr2);

	gets(arr1);
	gets(arr2);

	printf("%s\n", arr1);
	printf("%s\n",arr2);
	return 0;
}

3 getchar

int main()
{
	char arr1[20] = { 0 };
	char arr2[20] = { 0 };

	//scanf("%[^\n]", arr1);//读到\n处，停止读取
	//getchar();//吞掉缓冲区的\n
	//scanf("%[^\n]",arr2);

	//gets(arr1);
	//gets(arr2);

	char ch = 0;
	int i = 0;
	while ((ch=getchar())!='\n')
	{
		arr1[i++] = ch;
	}

	int j = 0;
	while ((ch = getchar() )!= '\n')
	{
		arr2[j++] = ch;
	}

	printf("%s\n", arr1);
	printf("%s\n",arr2);
	return 0;
}

其它

---

switch语句中可以没有default关键字

---

c程序的基本组成单位是函数

---

c语言本身是没有输入输出语句的。这是因为 C语言是一门计算机语言，它规定的是语法，按照怎样的规则去写代码，c语言的编译器会对代码进行编译。早期的时候，由于一些功能被经常使用，比如说，求字符串的长度，从界面输入，从界面输出。如果每个人都要自己实现的话，比较费时费力，并且代码不够规范。于是，便引入了标准库，里面的库函数可以实现一些常用的功能。是标准库实现的输入输出语句。

---

++的优先级要高于*的优先级

---

对于浮点型，如5.5，它的二进制表示方式为101.1，小数点后的权重依次为2的负1次方，2的负2次方…

IEEE 754规定，任意一个二进制浮点数V，可表示为（-1)^S * M * 2^E 比如：5.5，它的二进制表示方式为101.1，那么它可以写成1.011*2^2
(可以类比10进制的科学计数法101.1=1.011 * 10^2),进一步写成（-1） ^0 * 1.011 * 2^2

---

有些浮点数在内存中是无法保存的，或者说是无法精确保存的，对于float型小数点后的二进制最多保存23位，对于double型小数点后的二进制最多保存52位

---

当指针所指向的内存已经被释放，所以其它代码有机会改写其中的内容，相当于该指针从此指向了自己无法控制的地方，也称为野指针；
为了避免失误，最好在free之后，将指针指向NULL。

---

数据总线为32位，意味着一次读取32个bit位，也就是4个字节

---

解决头文件被重复包含的问题 条件编译

---

i[arr] 等价于 *(i+arr) 等价于 *(arr + i) 等价于 arr[i]

---