指针（1）

1.指针变量和地址

1.1取地址操作符（&）

比如说：

#include<stdio.h>
int main()
{
    int a=10;
    return 0;
}

整型变量a，在内存空间中占用4个字节，来存放a，每个字节都有地址。

但是我们想读取变量a的地址，该怎么做呢？

这里我们会用一个操作符（&）取地址操作符

#include<stdio.h>

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

&a会取出a所占4个字节中地址。

1.2指针变量和解引用操作符（*）

1.2.1指针变量

通常会把地址存放在指针变量中，比如：

#include<stdio.h>

int main()
{
    int a=10;
    int*pa=&a;
    return 0;
}

 指针变量也是变量，用来存放地址的，存放在指针变量中的值都会理解为地址。

1.2.2指针类型

int a=10;
int*pa=&a;

*是在说明pa是指针变量，int是在说明pa指向的是整型（int）类型的对象。

1.2.3解引用操作符

#include<stdio.h>

int main()
{
     int a=100;
     int*pa=&a;
     *pa=0;
     return 0;
}

*pa的意思就是通过pa中存放的地址，找到指向的空间，*pa其实就是a变量了；所以*pa=0，这个操作符就是把a改成了0.

2.指针的解引用

代码1
#include<stdio.h>
int main()
{
    int n=0x11223344;
    int*pa=&n;
    *pa=0;
    return 0;
}


代码2
#include<stdio.h>
int main()
{
    int n=0x11223344;
    char*pc=(char*)&n;
    *pc=0;
    return 0;
}

代码1会将n的4个字节全改为0，而代码2只会把n的第一个字节改为0.

结论就是：指针的类型决定了，对指针解引用的时候有多大的权限。

如：char*的指针解引用就只能访问一个字节，而int*的指针的解引用就能访问四个字节。

3.const修饰指针

3.1const修饰指针变量

void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 20;
	p = &m;
}
void test2()
{
	int n = 10;
	int m = 20;
	const int* p = &n;
	*p = 20;
	p = &m;
}
void test3()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 20;
	p = &m;
}
void test4()
{
	int n = 10;
	int m = 20;
	int const* const p = &n;
	*p = 20;
	p = &m;
}
int main()
{
	test1();

	test2();

	test3();

	test4();
	return 0;
}

结论：const修饰指针变量时，

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

const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针变量。

4.指针运算

4.1指针+-整数

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));//指针+整数
	}

	return 0;
}

4.2指针-指针

int my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
		p++;
	return p - s;
}
int main()
{
	printf("%d\n", my_strlen("abc"));
	return 0;
}

4.3指针的关系运算

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	while (p < arr + sz)
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

5.指针的使用和传址调用

5.1传址调用

写一个函数，交换两个整型变量的值。

如果写成这样代码：

void Swap1(int x, int y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d b=%d\n", a, b);
	Swap1(a, b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

运行结果：

 没有交换？？

当Swap1函数调⽤结束后回到main函数，a和b的没法交换。Swap1函数在使⽤的时候，是把变量本⾝直接传递给了函数，这种调⽤函数的⽅式我们之前在函数的时候就知道了，这种叫传值调用。

结论：实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实

参。所以Swap是失败的了。

那怎么办呢？

我们现在要解决的就是当调⽤Swap函数的时候，Swap函数内部操作的就是main函数中的a和b，直接将a和b的值交换了。那么就可以使⽤指针了，在main函数中将a和b的地址传递给Swap函数，Swap函数⾥边通过地址间接的操作main函数中的a和b就好了。

void Swap2(int *px, int*py)
{
	int tmp = 0;
	tmp=*px;
	*px = *py;
	*py = tmp;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf_s("%d %d", &a, &b);
	printf("交换前：a=%d b=%d\n", a, b);
	Swap2(&a, &b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

运行结果如下：

我们可以看到实现成Swap2的⽅式，顺利完成了任务，这⾥调⽤Swap2函数的时候是将变量的地址传递给了函数，这种函数调⽤⽅式叫：传址调⽤。