C语言入门——指针

指针

• 指针就是保存地址的变量

int i;
int* p=&i;
int* p,q;     //定义一个指针变量p和整形变量q;
int *p,q;     //定义一个指针变量p和整形变量q;

指针变量

• 变量的值是内存的地址
  普通变量的值是实际的值
  指针变量的值是具有实际值的变量的地址

作为参数的指针

在被调用时得到了某个变量的地址

• void f(int *p);

在函数里可以通过这个指针访问外面的i

• int i=0;f(&i);

访问地址上的变量*

• *是一个单目运算符，用来访问指针所表示的地址上的变量
• 可以做右值，也可以做左值
  int k=*p;
  *p=k+1;

#include<stdio.h>
void f(int *p);
void g(int k);
int main(void)
{
	int i = 6;
	printf("&i=%p\n", &i);
	f(&i);
	g(i);

	return 0;
}

void f(int* p) {
	printf("p=%p\n", p);      //输出p的地址
	printf("*p=%d\n", *p);    //输出访问得到的变量的值
	*p = 26;             //通过指针访问地址改变变量的值
}

void g(int k) {
	printf("k=%d\n", k);
}
/*
&i=00AFFBA0
p=00AFFBA0
*p=6
k=26
*/

左值

• 出现在赋值号左边的不是变量，而是值，是表达式计算的结果
  a[0]=2;
  *p=3;

指针的运算符& *

互相反作用

•  *  &ytep= *  ( & ytep)=得到那个地址上的变量
  

• & * ytep =&（ * ytep） =&（ytep）=得到ytep 的地址

指针的使用

交换两个变量的值

void swap(int *pa,int *pb)
{
	int t=*pa;
	 *pa=*pb;
	 *pb=t;
}

函数返回多个值，某些值就只能通过指针返回

传入的参数实际上是需要保存带回的结果的变量

#include<stdio.h>

void minmax(int a[], int len, int* min, int* max);

int main(void) {
	int a[] = { 1,2,3,4,5,6,7,8,9,11,12,13,14,15,16,17,22,55 };
	int min, max;
	minmax(a, sizeof(a) / sizeof(a[0]), &min, &max);
	printf("min=%d,max=%d\n", min, max);

	return 0;
}

void minmax(int a[], int len, int* min, int* max)
{
	int i;
	*min = *max = a[0];
	for (i = 0;i < len;i++) {
		if (a[i] < *min) {
			*min = a[i];
		}
		if(a[i]>*max){
			*max = a[i];
		}
	}
}

函数返回运算的状态，结果通过指针返回

常用套路是让函数返回特殊的不属于有效范围内的值来表示出错：

• -1或0（文件操作中可以看到大量的例子）

#include<stdio.h>

/*return:如果出发成功，则返回1，否则返回0；*/
int divide(int a, int b, int* result);

int main(void)
{
	int a = 5;
	int b = 2;
	int c;
	if (divide(a, b, &c)) {
		printf("%d/%d=%d\n", a, b, c);
	}
	return 0;
}

int divide(int a, int b, int* result)
{
	int ret = 1;
	if (b == 0) {
		ret = 0;
	}
	else {
		*result = a / b;
	}
	return ret;
}

指针与数组

传入函数参数表的数组，实际上是指针：

• sizeof(a)==sizeof(int *);
• 可以用数组运算符[ ]进行运算；

#include<stdio.h>

void minmax(int a[], int len, int* min, int* max);

int main(void) {
	int a[] = { 1,2,3,4,5,6,7,8,9,11,12,13,14,15,16,17,22,55 };
	int min, max;
	printf("main sizeof(a)=%lu\n", sizeof(a)); //输出数组a所占的字节长度
	printf("main a=%p\n", a);                  //输出数组a 的地址
	minmax(a, sizeof(a) / sizeof(a[0]), &min, &max);
	printf("min=%d,max=%d\n", min, max);

	return 0;
}

void minmax(int a[], int len, int* min, int* max)
{
	int i;
	printf("minmax sizeof(a)=%lu\n", sizeof(a));//输出数组a所占的字节长度
	printf("minmax a=%p\n", a);                 //输出数组a 的地址
	*min = *max = a[0];
	for (i = 0;i < len;i++) {
		if (a[i] < *min) {
			*min = a[i];
		}
		if (a[i] > *max) {
			*max = a[i];
		}
	}
}

main sizeof(a)=72
main a=012FFAB4
minmax sizeof(a)=4
minmax a=012FFAB4
地址相同，因此传入函数的数组实际上就是指针

数组参数

以下四种函数原型等价：

• int sum(int *ar,int n);
• int sum(int *,int);
• int sum(int ar [ ],int n);
• int sum(int [ ],int)

数组变量是特殊的指针

1、数组变量本身表达地址，所以

• int a[10];int *p=a; //无需用&取地址
• 但是数组单元表达的是变量，需要用&取地址：a==&a[0];

2、[ ]运算符可以对数组做，也可以对指针做

• p[0] <==> a[0]

3、*运算符可以对指针做，也可以对数组做

• *a=25

4、数组变量是const指针，所以不能被赋值

• int a[ ] <==> int *const a=……

指针与const

指针是const：

• 表示一旦得到了某个变量的地址，就不能再指向其他变量
• • int *const q=&i; //q是const;
• • *q=26;//OK
• • q++;//错误

所指是const:

• 表示不能通过这个指针去修改那个变量（并不能使那个变量成为const）
• • const int *p=&i;
• • *p=26;//错误
• • i=26;//OK
• • p=&j;//OK

i 可以被赋值，p可以指向别的地址，但是不能通过*p修改变量

const在 前，表示所指的东西不能被修改//const intp1=&i;<==>int const*p1=&i
const在 *后，表示指针不能被修改int *const p3=&i;

const数组

• const int a[]={1,2,3,4,5,} ;
• 数组变量已经是指针了这里的const表明数组的每个单元都是const int
• 所以必须通过初始化进行赋值

##保护数组值

• 因为数组传入函数传递的是地址，所以函数内部可以修改数组的值
• 为保护数组不被函数破坏，可以设置参数为const
• • int sum(const int a[ ],int length);

指针运算

给一个指针+1表示让指针指向下一个变量(即地址+sizeof)：

• int a[10];
• int *p=a;
• int *(p+1)---->a[1];
• 即*（p+n）<==>a[n]

#include<stdio.h>

int main(void)
{
	char ac[] = { 0,1,2,3,4,5,6,7,8,9, };
	char* p = ac;
	printf("  p=%p\n", p);
	printf("p+1=%p\n", p + 1);
	printf("*(p+1)=%d\n", *(p + 1));
	/*  p=006FF988
      p+1=006FF989
	  *(p+1)=1*/
	int ai[] = { 0,1,2,3,4,5,6,7,8,9, };
	int *q = ai;
	printf("  q=%p\n", q);
	printf("q+1=%p\n", q + 1);
	printf("*(q+1)=%d\n", *(q + 1));
	/*  q=006FF94C
      q+1=006FF950
	  *(q+1)=1*/
	return 0;
}

计算

• 给指针加、减一个整数（+，+=，-,-=）
• 递增递减（++、–）
• 两个指针相减（表示两个指针中间有多少个该类型的数据）

*p++

• 取出p所指的那个数据，完事儿之后顺便把p移到下一个位置去
• 常用于数组类的连续空间操作

• *的优先级高，但是低于++
  

• 在某些CPU上，这可以直接翻译为一条汇编指令

#include<stdio.h>

int main(void)
{
	char ac[] = { 0,1,2,3,4,5,6,7,8,9,-1 };
	char* p = ac;
	
	int i;
	for (i = 0;i < sizeof(ac) / sizeof(ac[0]);i++) {
		printf("%-2d", ac[i]);
	}
	printf("\n");
	
	for (p = ac;*p != -1;p++) {
		printf("%-2d", *p);
	}
	printf("\n");
	//两种等价
	while (*p != -1) {
		printf("%-2d", *p++);
	}
	printf("\n");

	return 0;
}

指针比较

• <,<=,==,>,>=,!=都可以对指针做
• 比较它们在内存中的地址
• 数组中的单元地址肯定都是线性递增的

指针的类型

• 无论指向什么类型，所有指针的大小都是一样的，因为都是地址
• 但是指向不同类型的指针是不能直接互相赋值的，为了避免用错指针

动态内存分配

malloc
#include<stdlib.h>
void*malloc(size_t size);

• 向malloc申请地址是以字节为单位的
• 返会的结果是void*，需要类型转换为自己需要的类型
  (int*)malloc(n*sizeof(int));

#include<stdio.h>
#include<stdlib.h>

int main(void)
{
	int number;
	int* a;
	int i;
	printf("输入数量：");
	scanf("%d", &number);
	a = (int*)malloc(number * sizeof(int));
	for (i = 0;i < number;i++) {
		scanf("%d", &a[i]);
	}
	for (i = number - 1;i >= 0;i--) {
		printf("%d", a[i]);
	}
	free(a);               //还内存

	return 0;
}

#include<stdio.h>
#include<stdlib.h>

int main(void)
{
	void* p;
	int cnt = 0;
	while ((p = malloc(100 * 1024 * 1024))) {
		cnt++;
	}
	printf("分配到了%d00Mb的空间\n", cnt);
	return 0;
}

free()

• 把申请过来的空间还给“系统”
• 申请过的空间最终都需要还
• 只能还申请来的空间的首地址