易错点汇总
- 指针数组和数组指针
- (*p).a
- struct stdent和typedef struct stdent
- F5和Ctrl+F5
- const的位置
- 全局变量和局部变量
- 两个相同的常量字符串
- 数组名和&数组名
- 数组指针定义的解读
- int (*arr[10])[5]
- 数组传参
- (* (void (*)())0)();
- 关于数组名是否表示整个数组和数组首元素的地址
- 结构体内存对齐
- 空指针和野指针
- 函数传参问题
- 直接打印字符串的首地址,可打出字符串
- 函数内部数组和指针中存储的常量字符串
- 预定义#define和函数下的计算max的两个带有副作用的例子
- unsigned char的加减问题
- 二进制奇数位和偶数位的互换
- *p[1] + 3 和 *(p[1] + 3)
- 连续输入两个带空格的字符串(scanf,gets,getchar)
- 其它
指针数组和数组指针
指针数组是一个数组。如同 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]