9.1指针基本用法
C语言中使用指针可以
·使程序简洁，紧凑，高效
·有效的表达复杂的数据结构
·动态分配内存
·得到多余的一个函数返回值
在计算机内存中，每一个字节单元都有一个字节编号，称为地址：
编译或函数调用时为其分配内存单元
变量是对程序中数据存储空间的抽象
9.2指针的概念
在C语言中，内存单元的地址称为指针，专门用来存放地址的变量，有时对地址，指针和指针变量不区分，统称指针。
指针变量的说明
一般形式：
<存储类型> <数据类型> *<指针变量名>
例如：
char *pname;
指针的存储类型是指针变量本身存储类型
指针说明时指定的数据类型不是指针变量本身的数据类型，而是指针目标的数据类型，简称为指针的数据类型
指针在说明的同时，也可以被赋予初值，叫做指针的初始化。
一般形式：
<存储类型> <数据类型> *<指针变量名> = <地址量>;
例如：
int a=1,*pa;
pa = &a;
*pa = 1;
9.3指针的含义
指针指向的内存区域中的数据称为指针的目标
如果它指向的区域是程序的一个变量的内存空间，则这个变量称为指针的目标变量，简称为指针的目标
引入指针要注意程序中的px，*px和&px三种表示方法的不同意义，设px为一个指针，则：
·px，指针变量，它的内容是地址量
·*px，指针所指对象，它的内容是数据
·&px，指针变量占用的存储区域的地址，是一个常量
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a = 10;
int *pa;
pa = &a;
printf("%d %d \n",a,*pa);
printf("%p %p \n",&a,pa);
printf("%p",&pa);
return 0;
}
指针的赋值运算指的是通过赋值运算符向指针变量送一个地址值
向一个指针变量赋值时，送的值必须是地址常量或指针变量，不能是普通整数（除了赋零以外）
指针赋值运算常见有以下几种形式：
1.把一个普通变量的地址赋给一个具有相同数据类型的指针
double x=15,*px;
px = &x;
2.把一个已有地址值指针变量赋给具有相同数据类型的另一个指针变量
float a,*px,*py;
px = &a;
py = px;
3.把一个数组的地址赋给具有相同数据类型的指针
int a[10],*pa;
pa = a; //等价于 pa = &a[0]
9.4指针的运算
·指针运算是指以指针变量所存放的地址量作为运算量而进行的运算
·指针运算的实质就是地址的运算
·指针运算的种类是有限的，它只能进行赋值运算、算数运算和关系运算
指针的算数运算见下表：
| 运算符 | 计算形式 | 意义 |
| + | px+n | 指针向地址大的方向移动n个数据 |
| - | px-n | 指针向地址大的方向移动n个数据 |
| ++ | px++或++px | 指针向地址大的方向移动1个数据 |
| -- | px--或--px | 指针向地址小的方向移动1个数据 |
| - | px-py | 两个指针之间相隔数据元素的个数 |
·不同数据类型的两个指针实行加减法整数运算是没有意义的
px+n表示的实际位置的地址量是：
(px)+sizeof(px的类型)*n
px-n表示的实际位置的地址量是：
(px)-sizeof(px的类型)*n
两个指针相减运算
·px-py运算的结果是两个指针指向的地址位置之间相隔的数据个数，因此，两个指针相减不是两个指针持有的地址值相减的结果
·两个指针相减的结果值不是地址量，而是一个整数值，表示两指针之间相隔数据的个数
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a[5]={1,2,3,4,5};
int *pa,*pb;
pa = a;
pb = &a[3];
printf("%p %p %d %d\n",pa,pb,*pb,pb-pa);
return 0;
}如上，pb-pa的结果为3
指针的关系运算符
| 运算符 | 说明 | 例子 |
| > | 大于 | px>py |
| < | 小于 | px<py |
| >= | 大于等于 | px>=py |
| <= | 小于等于 | px<=py |
| != | 不等于 | px!=py |
| == | 等于 | px==py |
·两个指针之间的关系运算符表示它们指向的地址位置之间的关系，指向地址大的指针大于指向地址小的指针
·指针与一般整数变量之间的关系运算没有意义，但可以和零进行等于或不等于的关系运算，判断指针是否为空
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a = 10;
int *pa = NULL;
printf("%d %p",pa,pa);
return 0;
}9.5指针和数组
·在C语言中，数组的指针是指数组在内存中的起始地址，数组元素的地址是指数组元素在内存中的起始地址
·一维数组的数组名为一维数组的指针(起始地址)
例如：
double x[6]; //x为数组的起始地址
设指针变量px的地址值等于数组指针x(即指针变量px指向数组的首元素)，则：
x[i]、(px+i)、(x+i)和px[i]具有完全相同的功能：访问数组的第i+1个数组元素(px[i]<==>*(px+i))
例如：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a[] = {1,2,3,4,5,6,7,8,9,10};
int *p,i,n;
p = a;
n = sizeof(a)/sizeof(int);
for(i=0;i<n;i++)
{
printf("%d %d %d %d \n",a[i],*(p+i),*(a+i),p[i]);
}
return 0;
}注意:
·指针变量和数组在访问数组中元素时，一定条件下其使用方法具有相同形式，因为指针变量和数组名都是地址量
·但是指针变量和数组的指针(数组名)在本质上不同,前者是地址变量，后者是地址常量
数组反序存放:
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a[] = {1,2,3,4,5,6,7,8,9,10};
int *p1,*p2,n,t;
n = sizeof(a)/sizeof(int);
p1 = a;
p2 = &a[n-1];
while(p1<p2)
{
t = *p1;
*p1 = *p2;
*p2 = t;
p1++;
p2--;
}
for(t=0;t<n;t++)
{
printf("%d ",a[t]);
}
return 0;
}
9.6指针和二维数组
在C语言中，二维数组的元素连续存储，按行优先存储
用一级指针遍历二维数组:
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a[3][2] = {{1,2},{3,4},{5,6}};
int *p1,n,t;
p1 = a;
n = sizeof(a)/sizeof(int);
for(t=0;t<n;t++)
{
printf("%d ",*(p1+t));
}
return 0;
}可以把二维数组看做由多个一维数组组成，比如:
int a[3][3]，含有三个元素，a[0]，a[1]，a[2]，元素a[0]，a[1]，a[2]都是一维数组名
·二维数组名代表数组的起始地址，数组名加1，是移动一行元素，因此，二维数组名常被称为行地址
例如：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a[3][2] = {{1,2},{3,4},{5,6}};
int *p1;
p1 = a;
printf("%p %p \n",a,a+1);
printf("%p %p \n",p1,p1+1);
return 0;
}如上，a+1移动了一行元素(2个)，而p1+1只移动了一个元素
·存储行地址的指针变量，叫做行指针变量，形式如下:
<存储类型> <数据类型> (*<指针变量名>){表达式n};
例如: int a[2][3]; int (*p)[3];
方括号中的常量表达式表示指针加1，移动几个数据
例如：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a[2][3] = {{1,2},{3,4},{5,6}};
int (*p)[3];
p = a;
printf("%p %p \n",a,a+1);
printf("%p %p \n",p,p+1);
return 0;
}如上a+1和p+1都移动了一行元素
当用行指针操作二维数组时，表达式一般写成1行的元素个数，即列数
使用行指针遍历二维数组：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a[2][3] = {{1,2,3},{4,5,6}};
int (*p)[3],i,j;
p = a;
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
printf("%d %d %d %d \n",a[i][j],p[i][j],*(*(a+i)+j),*(*(p+i)+j));
}
return 0;
}9.7字符指针和字符串
·C语言通过字符数组来处理字符串
·通常，我们把char数据类型的指针变量称为字符指针变量。字符指针变量与字符有着密切关系，它也被用来处理字符串
·初始化字符指针是把内存中字符串的首地址赋予指针，并不是把该字符串复制到指针中
char str[] = "hello world";
char *p = str;
·在C语言编程中，当一个字符指针指向字符串常量时，不能修改指针指向对象的值
char *p = "hello world";
*p = 'h';
例如：
#include<stdio.h>
#include<stdlib.h>
int main()
{
char ch1[] = "hello world";
char *p;
p = ch1;
if(isalpha(*p))
{
if(isupper(*p))
{
*p = tolower(*p);
}
else
{
*p = toupper(*p);
}
}
printf("%s \n",p);
printf("%s \n",ch1);
return 0;
}如上运行结果为:
Hello world
Hello world
不使用任何字符串函数，实现字符串函数连接功能：
#include<stdio.h>
#include<stdlib.h>
int main()
{
char ch[50]="hello";
char *p="world",*a;
int i=0;
a = p;
while(*(ch+i) !='\0')
{
i++;
}
while(*p !='\0')
{
*(ch+i) = *p;
p++;
i++;
}
*(ch+i) = *p;
p = a;
puts(ch);
puts(p);
return 0;
}9.8指针数组
所谓指针数组是指由若干个具有相同存储类型和数据类型的指针变量构成的合集
指针数组的一般说明形式：
·<存储类型><数据类型>*<指针数组名>[大小]
·指针数组名表示该指针的起始地址
声明一个指针数组
int *pa[2] ，a[3][2];
把一维数组a[0]和a[1]的首地址分别赋予指针变量数组的数组元素pa[0]和pa[1]
pa[0] = a[0]; //等价于pa[0] = &a[0][[0]
pa[1] = a[1]; //等价于pa[1] = &a[1][[0]
此时pa[0]指向了一维数组a[0]的第一个元素，pa[1]指向了一维数组a[1]的第一个元素
例如：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int *p[2];
int a[2][3]={{1,2,3},{4,5,6}};
p[0] = a[0];
p[1] = a[1];
printf("%d \n",a[0][1]);
printf("%d \n",*(p[0]+1));
return 0;
}使用指针数组处理二维数组，求出二维数组所有元素的和：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int *p[2];
int a[2][3]={{1,2,3},{4,5,6}};
int i,j,sum;
p[0] = a[0];
p[1] = a[1];
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
printf("%d %d %d\n",a[i][j],*(a[i]+j),*(p[i]+j));
sum += *(p[i]+j);
}
}
printf("%d \n",sum);
return 0;
}9.9多级指针
定义
·把一个指向指针变量的指针变量称为指针变量
·对于指向处理数据的指针变量称为一级指针变量，简称一级指针
·而把指向一级指针变量的指针变量称为二级指针变量，简称二级指针
·二级指针变量的说明形式如下：
<存储类型><数据类型>**<指针名>;
多级指针的运算
1.指针变量+1，是向地址大的方向移动一个目标数据。同理，多级指针运算也是以其目标变量为单位进行偏移
2.比如:int**p; p+1是移动一个int*变量所占的内存空间
多级指针和指针数组
·指针数组也可以用另外一个指针来处理
例如：
#include<stdio.h>
#include<stdlib.h>
int main()
{
char *p[]={"beijing","chengdu","mianyang"};
char **q;
q = p;
int n,i=0;
n = sizeof(p)/sizeof(char);
while(i<n)
{
printf("%s %s\n",p[i],*(q+i));
i++;
}
return 0;
}9.10void指针
void指针是一种不确定数据类型的指针变量，它可以通过强转类型转换让该变量指向任何数据类型的变量
一般形式为：
viod *<指针变量名称>;
对于void指针，在没有强制转换类型之前，不能进行任何指针的算数运算
举例(使用void指针遍历一维数组)：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a[]={1,2,3,4,5};
int n,i=0;
n = sizeof(a)/sizeof(int);
void *p;
p = a;
while(i<n)
{
printf("%d \n",*((int *)p+i));
i++;
}
return 0;
}9.11const修饰指针
常量化变量的值
一般说明形式如下:
const <数据类型> 变量名 =[<表达式>];
常量化变量是为了使得变量的值不能修改
变量有const修饰时，若想用指针间接访问变量，指针也要有const修饰。
const放在指针声明什么位置呢?
常量化指针目标表达式
一般说明形式如下
const <数据类型> *<指针变量名称> [=<指针运算表达式>];
常量化指针目标限制通过指针改变其目标的数值
但是指针变量存储的地址可以修改
例如:
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10,n=5;
const int* p;
p = &a; //可以修改
(*p)++; //不能修改
p = &n;
return 0;
}
常量化指针变量及其目标表达式
一般说明形式如下:
const <数据类型>* const <指针变量名> = <指针运算表达式>
常量化指针目标是限制通过指针改变其目标的数值
但是<指针变量>存储的地址值可以修改
例如：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10,n=5;
const int* const p;
p = &n; //不能修改
(*p)++; //不能修改
return 0;
}常量化指针变量
一般说明形式
<数据类型> *const <指针变量名称> [<指针运算表达式>]
使得<指针变量>存储的地址值不能修改。
但可以通过*<指针变量名称>可以修改所指向变量的数值。
例如:
#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10,n=5;
int* const p;
p = &n; //不能修改
(*p)++; //可以修改
return 0;
}口诀：左变右不变
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
