C语言指针注意事项（1）

1.内存单元的编号==地址==指针

2.int a, &a取出的是a所占4个字节中地址较⼩的字节的地址,打印时候占位符为%p;

3.指针变量也是⼀种变量，这种变量就是⽤来存放地址的，存放在指针变量中的值都会理解为地址。

4.int a=10; int* p=&a;   * 是在说明pa是指针变量，⽽前⾯的 int 是在说明pa指向的是整型(int)

类型的对象。

5.指针变量的大小

 在32位平台下地址是32个bit位，指针变量⼤⼩是4个字节

 在 64位平台下地址是64个bit位，指针变量⼤⼩是8个字节

注意指针变量的⼤⼩和类型是⽆关的，只要指针类型的变量，在相同的平台下，⼤⼩都是相同的。

6. 指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）。 char* 的指针解引⽤就只能访问⼀个字节，⽽ int* 的指针的解引⽤就能访问四个字节。

7.指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）。

char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。

这就是指针变量的类型差异带来的变化。

8.void*指针，泛型指针（无具体类型的指针），可以用来接受任意类型的地址，但是 void* 类型的指针不能直接进 ⾏指针的+-整数和解引⽤的运算。注意下面一段代码：

int a = 0;
int* p=&a;
char* pc=&a;

将⼀个int类型的变量的地址赋值给⼀个char*类型的指针变量。编译器给出了⼀个警

告（从“ int* ”到“ char* ”的类型不兼容），是因为类型不兼容。⽽使⽤void*类型就不会有这样的问题。 ⼀般 void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以 实现泛型编程的效果，使得⼀个函数来处理多种类型的数据。

9.const修饰变量

这里我们看到即使n被const修饰，仍然可以通过指针对n的进行修改，这里的n被称作是常变量。

10.const修饰变量

void test01()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	p = &m;//ok
	*p = 30;//ok
}
void test02()
{
	int n = 10;
	int m = 20;
	const int* p = &n;
	p = &m;//ok
	//*p = 30;//err
}
void test03()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	//p = &m;//err
	*p = 30;//ok
}
void test04()
{
	int n = 10;
	int m = 20;
	const int* const p = &n;
	//p = &m;//err
	//*p = 30;//err
}
int main()
{
	test01();//测试⽆const修饰的情况
	trst02();//测试const放在*的左边情况
	test03();//测试const放在*的右边情况
	test04();//测试*的左右两边都有const
	return 0;
}

结论：const修饰指针变量的时候

• const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。

但是指针变量本⾝的内容可变。

• const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指

向的内容，可以通过指针改变。

11.int* p;// p+i加的是i*sizeof(int),其他类型的指针道理类似

12.指针-指针的绝对值是指针和指针之间的元素个数，指针减指针运算的前提条件是两个指针指向同一块空间。

int main()
{
	//指针-指针 = 地址-地址
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	printf("%d\n", &arr[0] - &arr[9]);//9 - 指针-指针的绝对值是指针和指针之间的元素个数
	//指针-指针运算的前提条件是：两个指针指向同一块空间

	char ch[20] = {0};
	printf("%d\n", &ch[0] - &arr[0]);//err，不确定arr数组和ch数组之间是否有间隙
                                     //也不确定计算的元素个数是int类型还是char类型

	return 0;
}

利用指针-指针求字符串长度，其实就是实现strlen函数，注意：strlen求字符串长度-统计的是\0前面出现的字符个数

//int  my_strlen(const char* s)
//{
//	int count = 0;
//	char* str = s;
//	while (*str!='\0')
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
int  my_strlen(char* s)
{
	char* str = s;
	while (*str)
	{
		str++;
	}
	return str - s;
}
int main()
{
	int len = my_strlen("abcdefg");
	printf("%d", len);
	return 0;
}

指针的运算关系（其实就是指针比较大小，即地址比较大小）的一个例子如下：

int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    int len = sizeof(arr) / sizeof(arr[0]);
    int* p = arr;//arr<=>&arr[0],即数组名等价于数组首元素地址
    while (p < arr + len)
    {
        printf("%d ", *p);
        p++;
    }
    printf("\n");
    return 0;
}

13.野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

野指针成因：

①：指针未初始化

int main()
{
    int* p;
    *p = 20;//局部变量指针未初始化，默认为随机值
    return 0;
}

局部变量如果不初始化，变量的值是随机的！

但是全局变量和静态变量如果不初始化，变量的值默认是0，因为全局变量和静态变量都在静态区。

对于这种情况，如果不知道指针该指向哪，可以给指针赋值NULL，例如int *p =NULL;

NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址会报错。

约定俗称的一个规定：

只要是NULL指针就不去访问， 同时使⽤指针之前可以判断指针是否为NULL。

int main()
{
	int a = 10;
	int* p = &a;
	//....
	//....
	p = NULL;

	//...
	//...
	if (p != NULL)
	{
		//....
	}
	return 0;
}

②：指针越界访问：

int main()
{
	int arr[5] = { 0 };
	//1 1 1 1 1 1 1 1 1 1
	int i = 0;
	int* p = arr;
	for (i = 0; i < 10; i++)
	{
		*p = 1;
		p++;
	}

	return 0;
}

这是指针越界常见的错误, ⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是 越界访问。

③：指针指向的空间释放

#include <stdio.h>
int* test()
{
 int n = 100;
 return &n;
}
int main()
{
 int*p = test();
 printf("%d\n", *p);
 return 0;
}

所以不要返回局部变量的地址。

14.assert断言

      assert.h 头⽂件定义了宏 assert() ，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报

错终⽌运⾏。这个宏常常被称为“断⾔”。

assert(p != NULL)

上⾯代码在程序运⾏到这⼀⾏语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运⾏，否则就会终⽌运⾏，并且给出报错信息提⽰。

     assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产⽣

任何作⽤，程序继续运⾏。如果该表达式为假（返回值为零）， assert() 就会报错，在标准错误

流 stderr 中写⼊⼀条错误信息，显⽰没有通过的表达式，以及包含这个表达式的⽂件名和⾏号。

     assert() 有⼏个好处：它不仅能⾃动标识⽂件和 出问题的⾏号，还有⼀种⽆需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问 题，不需要再做断⾔，就在 #include <assert.h> 语句的前⾯，定义⼀个宏 NDEBUG 。代码如下

#define NDEBUG
#include<assert.h>

重新编译程序 ，编译器就会禁⽤⽂件中所有的 assert() 语句。 如果程序⼜出现问题，可以移

除这条 #define NDBUG 指令（或者把它注释掉），再次编译，这样就重新启⽤了 assert() 语

句。

     assert()唯一的缺点就是引入了额外的检查，增加了程序的运行时间。在vs中,Release版本直接优化掉了assert()。下面就是一个利用assert()检查字符串长度的例子。