[C语言]初学者的一些理解-指针
指针
什么是指针？
简单的来讲：指针就是一个变量，它跟其他类型的变量是一样的概念，只不过它储存的是内存地址（内存单元编号）。
比如：我们的身份证就是一个指针变量，它所存储的是我们的家庭住址。
我们的住址，还有房间的编号，门牌号，它们都是指针常量。
假如有个同学借你的身份证去上网回来，你不在宿舍，他就把身份证夹在了放在书架的书里。然后写了张纸条放在桌子上，就去玩了，你回来看到纸条你就知道身份证放在哪里了。
（纸条就是一个指针变量，它所存储是你身份证的地址。）
这时又来了个同学向你借书，你叫他自己找，在书架上的“第三层第一格里”（这就是一个指针常量）
当理解指针的概念时，就有这样的思想了，指针就是地址，地址就是指针。
但是要搞清楚的是，指针是指针，指针变量是指针变量，刚开始就是这里，
搞糊涂我了，我以为指针就是指针变量，那么指针变量就是地址了。
指针的声明
数据类型 指针操作符（*） 变量
int *p;//声明一个储存int型变量地址的指针
char *cp;//声明一个存储char型变量地址的指针
书上说的指向int型的指针，其实就是存储int型变量地址的指针。
这些都是我片面的理解，错了请喷，但是喷了请告诉我为什么？？谢谢！
指针的使用
指针变量的赋值和初始化
为指针变量赋值就是设定指针所指向地址的过程
①
int i = 10;//声明一个int型变量，并初始化为10
int *p;//声明一个指向int型的指针变量
p = &i;//使p指向i，&i是取i的地址。
②
int i = 8;//声明一个int型变量，并初始化为8
int *p = &i;//声明一个指向int型的指针变量，并初始化指向i
注意指针的初始化，当我们不为指针变量初始化时，我们应该为其赋值为NULL == 0
int *p = NULL;//使p指向空。就可以避免造成一些不必要的错误。
指针的一些简单应用
①测试指针类型的字节长度。
#include <stdio.h>
int main(void)
{
int *ip = NULL;
char *cp = NULL;
float *fp = NULL;
double *dp = NULL;
long *lp = NULL;
long long *llp = NULL;
printf("sizeof(int*) = %d\n",sizeof(ip));
printf("sizeof(char*) = %d\n",sizeof(cp));
printf("sizeof(float*) = %d\n",sizeof(fp));
printf("sizeof(double*) = %d\n",sizeof(dp));
printf("sizeof(long *) = %d\n",sizeof(lp));
printf("sizeof(long long *) = %d\n",sizeof(llp));
return 0;
}
可以得出所有类型指针的字节长度都为4个字节。
②指针如何访问和修改所指的变量。
#include <stdio.h>
int main(void)
{
int i = 10;
int *p = &i;
printf("通过*p访问i\n");
printf("i = %d\n",i);//输出i的值
printf("*p = %d\n",*p);//输出p所指地址的内容（就是值）
/* *p是取指针变量所指地址的内容 */
printf("\n通过*p 修改 i的值\n");
*p = 3;
printf("i = %d\n",i);
printf("*p = %d\n",*p);
return 0;
}
可以得出在此代码中 *p = = i i = = *p
③多次赋值指针变量的变化。
#include <stdio.h>
int main(void)
{
int x = 8;
int y = 6;
int *p = NULL;
printf("&x = %p\n",&x);//取x的地址
printf("&y = %p\n",&y);//取y的地址
printf("&p = %p\n",&p);//取p本身的地址
printf("&*p = %p\n",&*p);//取p所指的地址
p = &x;
printf("p = &x\n");
printf("&x = %p\n",&x);
printf("&p = %p\n",&p);
printf("&*p = %p\n",&*p);
p = &y;
printf("p = &y\n");
printf("&y = %p\n",&y);
printf("&p = %p\n",&p);
printf("&*p = %p\n",&*p);
return 0;
}
就像其他类型的变量，每一个赋值就是改变他的值。
const指针
① 指向const的指针变量
声明方式：
int const *p;
const int *p;
就是指向const型变量的指针变量
#include <stdio.h>
int main(void)
{
const int a = 8;
const int b = 10;
const int *p;//其声明方式
p = &a;
printf("*p = %d\n",*p);
p = &b;
printf("*p = %d\n",*p);
//*p = 10;错误不可通过*p修改b的值
return 0;
}
可以重新为p赋值，但是不可以通过指针修改变量的值
② const 型指针变量，声明方式如下：
int *const p;
声明一个const型指针变量，赋值后就不可以，再为其赋值了。如同其他类型的变量一样。
如：
const int i = 10;
i = 8;//这是错误的
#include<stdio.h>
int main(void)
{
int i = 8;
nt j = 10;
int *const p = &i;
printf("i = %d\n",i);
printf("*p = %d\n",*p);
//p = &j;//错误
return 0;
}
③ 指向const的const指针变量，声明方式如下：
const int *const p;
声明一个指向const型变量的const型指针变量。
不可通过指针修改变量的值。
不可在为其赋值。
#include <stdio.h>
int main(void)
{
int i = 6;
const int *const p = &i;
printf("i = %d\n",i);
printf("*p = %d\n",*p);
return 0;
}
int i = 8;
const int *const p;
p = &i;//这是错误的。
*p = 10;//不可通过*p改变其值
指针与函数
指针形参
指针作为形参实现交换两个数。
#include <stdio.h>
void exch(int *x,int *y)
{
int t = 0;
t = *x;
*x = *y;
*y = t;
}
int main(void)
{
int i = 10;
int j = 11;
exch(&i,&j);
printf("i = %d\n",i);
printf("j = %d\n",j);
return 0;
}
/*****************************************
输出结果
i = 11
j = 10
请按任意键继续. . .
******************************************/
成功交换两个数，如果不用指针作为形参可以实现吗？
#include <stdio.h>
void exch(int x,int y)
{
int t = 0;
t = x;
x = y;
y = t;
}
int main(void)
{
int i = 10;
int j = 11;
exch(i,j);
printf("i = %d\n",i);
printf("j = %d\n",j);
return 0;
}
交换失败，这是为什么？（函数传递 是把实参赋值给形参。）
因为这个函数只是把实参的值传递给形参，相等于：
x = i,y = j;
形参和实参不是同一个地址，是互不相干的，都有自己的家（内存地址）
但是指针作为形参时就不一样了，因为实参传递给形参是地址，那函数内部就可以直接访问内存了。
指针型函数
函数是形参可以为指针型，那函数的返回值可以为指针型吗？
答案是可以的，指针型函数可以实现。
其声明方式如下：
数据类型 *函数名(形参列表)
int *a(void);
编写一个函数返回最大数的地址。
#include <stdio.h>
int *p_max(int *p,int *p1)
{
if(*p > *p1)
return p;
else
return p1;
}
int main(void)
{
int x,y;
int *pt;
printf("请输入两个整数:");
scanf("%d %d",&x,&y);
pt = p_max(&x,&y);
printf("*pt = %d\n",*pt);
return 0;
}
函数型指针
函数定义的时候实际上就是定义了一个函数变量，那么是否可以将这个变量的地址赋值给指针呢？当然了，可以使用函数型指针实现。
函数型指针就是指向函数的指针变量。
其声明方式如下：
int f(int x,int y);
int (*p)(int,int);
函数型指针的赋值和调用
#include <stdio.h>
int add(int x,int y)
{
return x + y;
}
int main(void)
{
int t = 0;
int (*p)(int,int);
p = add;
t = (*p)(8,8);
printf("t = %d\n",t);
printf("%d\n",p(8,8));
return 0;
}
赋值
如：
int (*p)(int,int);
p = 函数名;
int (*p)(int,int) = 函数名;
调用有两种形式：
① (*p)(形参列表);
② p(形参列表);
注意：要保证左值和右值一样，如
int add(int x,int y);
int amx(int x);
int (*p)(int,int) = add;
p = amx;//这是错误，因为他们不匹配
void型指针
书上关于void型指针一页都没有，为什么介绍的这么少。
void型指针有什么用？用在哪里？
当你不知道这个指针变量要指向什么类型的地址时，就可以使用void指针了。
#include <stdio.h>
int main(void)
{
void *vp;
int i = 10;
char c = '8';
float f = 9.3;
int *p;
printf("vp = &i\n");
vp = &i;
//printf("*vp = %d\n",*vp);
p = vp;
printf("*p = %d\n",*p);
printf("vp = &c\n");
vp = &c;
p = vp;
printf("*p = %c\n",*p);
printf("vp = &f\n");
vp = &f;
p = vp;
printf("*p = %f\n",*p);
return 0;
}
指针与数组
指向数组元素的指针
指向数组元素的指针变量，其指向的地址属于一个数组中的某一个元素。
如：
#include <stdio.h>
int main(void)
{
int array[10] = {1};
int *p = &array[0];
int *p1 = array[0];
int *p2 = &array;
int *p3 = array;
printf("&array[0] = %p\n",&array[0]);
printf("&*p = %p\n",&*p);
printf("&*p1 = %p\n",&*p1);
printf("&*p2 = %p\n",&*p2);
printf("&*p3 = %p\n",&*p3);
return 0;
}
我想的是这些输出都是相同的，但是为什么&*p1（array[0]）不同？？？
因为 p1 指向的是 array[0]
而array[0] == 1; 所以 p1 = 1; p1所指向的是内存中 1单元。
注意：虽然指针变量可以赋值为整数，但是不用这样做，很容易出现错误。
假如我们随便为指针变量赋值了个整数，而这个地址有程序中变量占用了。
那不是很危险，严重会导致那个程序崩溃。万一那个地址是系统占用的呢？
指针访问数组
数组不仅可以通过下标访问，还可以使用指针变量来操作数组元素。
指针访问数组的两种方式。
#include <stdio.h>
int main(void)
{
int array[10] = {1,2,3,4,5,6,7,8,9,10};
int i = 0;
int *p = array;
or(i = 0;i < 10;++i)
printf("%d\t",*(p+i));
printf("\n");
for(i = 0;i < 10;++i)
printf("%d\t",*p++);//把*p++ 看成*(p = p + 1);先使地址自增。
printf("\n");
return 0;
}
数组与指针的关系。
数组和指针在什么情况相等？在数组作为函数形参时.
数组作为形参的三种形式
int fun(int array[10]);
int fun_1(int array[]);
int fun_2(int *array);
举例证明
①
#include <stdio.h>
void fun(int array[100])
{
printf("fun:\n");
printf("sizeof(array) = %d\n",sizeof(array));
}
void fun_1(int array[])
{
printf("fun_1:\n");
printf("sizeof(array) = %d\n",sizeof(array));
}
void fun_2(int *array)
{
printf("fun_2:\n");
printf("sizeof(array) = %d\n",sizeof(array));
}
int main(void)
{
int array[10] = {0};
printf("array = %d\n",sizeof(array));
fun(array);
fun_1(array);
fun_2(array);
return 0;
}
输出结果
array = 40
fun:
sizeof(array) = 4
fun_1:
sizeof(array) = 4
fun_2:
sizeof(array) = 4
在main函数内array的字节长度为40
为什么在这几个函数内部是4呢？
这就证明了 在这种情况下 指针 等效于 数组参数
还有不管你给数组形参多少容量，到编译时都转换为指针
指向二维数组的指针变量
竟然指针可以指向一维数组，那么就一定可以指向二维数组了。
二维数组的地址和指针的关系
#define N 3
int array[N][N] = {{1,2,3},{4,5,6},{7,8,9}};
int (*p)[N] = array;
int (*p1)[N][N] = array;
array 和 &array 表示整个二维数组的地址
array[n] 和 &array[n] 表示第n个一维数组的首地址
array[n][n] 表示第n个一维数组的第n个元素
&array[n][n] 表示第n个一维数组的第n个元素的地址
p+n 等效于 array 和 &array
*(p+n)+n 等效于 &array[n][n]
*(*(p+n)+n) 等效于 array[n][n]
*(*p1+n) 等效于 array 和 &array
*(*p1+n)+n 等效于 &array[n][n]
*( *(*p+n)+n ) 等效于 array[n][n]
指针法访问数组
①使用指向数组元素的指针
#include <stdio.h>
#define N 3
int main(void)
{
int i = 0;
int array[N][N] = {{1,2,3},{4,5,6},{7,8,9}};
int *p = &array;//p指向array的首地址
for(i = 0;i < N*N;++i)
{
printf("%d\t",*(p+i));
if(i % N == 2)
printf("\n");
}
return 0;
}
②使用一维数组型指针
#include <stdio.h>
#define N 3
int main(void)
{
int i = 0;
int j = 0;
int array[N][N] = {{1,2,3},{3,4,5},{6,7,8}};
int (*p)[N] = array;//指向一维数组的指针，该一维数组的容量N
for(i = 0;i < N;++i)
{
for(j = 0;j < N;++j)
printf("[%p] = %d\t",&array[i][j],array[i][j]);
printf("\n");
}
for(i = 0;i < N;++i)
{
for(j = 0;j < N;++j)
printf("%d\t",*(*(p+i)+j));//输出array[i][j]的值
printf("\n");
}
printf("\n2:\n");
for(p = array;p < array+N;++p)
{
for(j = 0;j < N;++j)
printf("%d\t",(*p)[j]);//输出array[i][j]的值
printf("\n");
}
return 0;
}
③使用二维数组型指针
#include <stdio.h>
#define N 3
int main(void)
{
int i = 0;
int j = 0;
int array[N][N] = {{1,2,3},{4,5,6},{7,8,9}};
int (*p)[N][N] = array;
for(i = 0;i < N;++i)
{
for(j = 0;j < N;++j)
printf("[%d] = %d\t",&array[i][j],*( *( *p+i )+j ));
printf("\n");
}
return 0;
}
二维数组作为形参
二维数组的地址也可以用做函数的参数。
使用数组作为形参的关键是能够成功的从实参得到有效数组地址。
在传递二维数组的地址时，可以使用三种不同的方式。
①使用指向数组元素的指针，声明方式如下：
int fun(int *p);
代码：
#include <stdio.h>
#define N 3
void print(int *p)
{
int i = 0;
int j = 0;
for(i = 0;i < N;++i)
{
for(j = 0;j < N;++j)
printf("%d\t",*p++);
printf("\n");
}
}
void reverse(int *p)
{
int i = 0;
int j = 0;
for(i = 0;i < N;++i)
{
for(j = 0;j < N;++j)
printf("%d\t",*(p+j*N+i));
printf("\n");
}
}
int main(void)
{
int array[N][N] = {{1,2,3},{4,5,6},{7,8,9}};
printf("输出数组:\n");
print(array);
printf("翻转数组:\n");
reverse(array);
return 0;
}
②使用指向一维数组的指针，声明方式如下：
int fun(int (*p)[]);
#include <stdio.h>
#define N 3
void print(int (*p)[N])
{
int i,j;
for(i = 0;i < N;++i)
{
for(j = 0;j < N;++j)
printf("%d\t",*(*(p+i)+j));
printf("\n");
}
}
void print_1(int (*p)[N])
{
int i,j;
for(i = 0;i < N;++i,++p)
{
for(j = 0; j < N;++j)
printf("%d\t",*(*p+j));//p++等效于 p+i
printf("\n");
}
}
int main(void)
{
int array[N][N] = {{1,2,3},{4,5,6},{7,8,9}};
printf("print:\n");
print(array);
printf("print_1:\n");
print(array);
return 0;
}
③使用指向二维数组的指针,声明方式如下：
int fun(int (*p)[n][n]);
#include <stdio.h>
#define N 3
void print(int (*p)[N][N])
{
int i,j;
for(i = 0;i < N;++i)
{
for(j = 0;j < N;++j)
printf("%d\t",*( *(*p+i)+j ));
printf("\n");
}
}
void print_1(int (*p)[N][N])
{
int i,j;
for (i = 0; i < N; ++i)
{
for (j = 0; j < N; ++j)
printf("%d\t", *(**p + i * N + j));//不太理解
printf("\n");
}
}
int main(void)
{
int array[N][N] = {{1,2,3},{4,5,6},{7,8,9}};
printf("print:\n");
print(array);
printf("print_1:\n");
print_1(&array);
return 0;
}
指针与字符
字符指针：指向字符的指针，其跟指向int型变量的指针一样的声明。
char c = ‘n’;
int *p = &c;
字符指针访问
这些都跟int型指针一样。
int c = ‘c’;
int *p = &c;
printf(“%c\n”,*p);
指针与字符串
指向字符串的指针。声明方式如下：
①
char str[] = “Hello,world”;
char *p = str;
②
char *pstr = “Hello,world”;
指针访问字符串
例1
#include<stdio.h>
int main(void)
{
char str[] = “Hello,world”;
char *p = str;
printf(“%s\n”,p”);
return 0;
}
例2
#include <stdio.h>
int main(void)
{
char *p = "Hello,world";
printf("%s\n",p);
return 0;
}
访问字符串中的某的元素。
①
#include <stdio.h>
int main(void)
{
char *p = "Hello,world";
int i = 0;
for(i = 0; *p != '\0';++i)
printf("%c",*p++);
return 0;
}
②
#include <stdio.h>
int main(void)
{
char *p = "Hello,world";
int i = 0;
for(i = 0;p[i] != '\0';++i)
printf("%c",p[i]);
printf("\n");
return 0;
}
演示指针字符和字符串的一些特性
/* 字符指针和字符串 */
#include <stdio.h>
int main(void)
{
char * p1 = "Hello, world!";
char * p2 = "Hello, world!";
char * p3 = "Hello, world";
printf("%p\n", p1);//4个字节
printf("%d\n", sizeof(p1));//①
printf("%p\n", p2);//4个字节
printf("%d\n", sizeof(p2));//①
printf("%p\n", "Hello, world!");//①
printf("%d\n", sizeof("Hello, world!"));//这个是14字节
printf("%p\n", p3);//另开辟了一个地址
printf("%d\n", sizeof(p3));//4个字节
return 0;
}
//①处是同一个地址
指针数组：存储地址的数组
指针数组的声明：char *p_array[n];
指针数组的赋值：
char *p_array[3] = {NULL};//都指向空
char *p_array[3] = {“printf”,”scanf”,”hello”};
char *p_array[3] = {NULL};
p_array[0] = “printf”;
p_array[1] = “scanf”;
p_array[2] = “hello”;
试例：
#include <stdio.h>
int main(void)
{
char *p_array[3] = {NULL};
p_array[0] = "printf";
p_array[1] = "scanf";
p_array[2] = "hello";
int i = 0;
for(i = 0;i < 3;++i)
puts(p_array[i]);
return 0;
}
额额，指针难啊！！打算先放一边。