1.1 数组指针
1）本质：指针，指针指向的对象的类型为数组类型
2）原型：数据类型 (*标识符)[长度]
3）说明：指针称之为行指针
长度：表示二维数组的列数
4）大小：4个字节
char (*p)[4] ;
p + 1;
char a[3][4];
a : 指向的对象的类型----?> char [4]
a+1 --->4个字节,数组的&a[1]的地址，第1行的首行地址， 行从0开始
a+i ---> i行的首地址 char [4]
char [4] ------>char
a+1 ------------>*(a+1)， 表示1行首列元素的地址 char类型
*(a+1)+1 ：偏移一个字节
#include <stdio.h>
void fun(char (*pf)[4]); int main() { char a[3][4] = {10,11,23,45, 89,90,67,55, 99,88,56,97 }; int i, j; //指针
//char *p = &a[0][0]; char *p = a[0]; //a[0]指向的对象的类型为char for(i = 0 ; i < 12; i++) printf("%d ",*(p+i)); //将二维数组转变为一维数组
printf("\n----------------------\n"); //char (*pf)[4] = a; //a指向的对象的类型为char [4] char (*pf)[4] = &a[0]; //指向的对象的类型为char [4]
for(i= 0; i < 3; i++) { for(j = 0; j < 4; j++) { //printf("%d ",*(*(pf+i)+j)) ; //printf("%d ",pf[i][j]); printf("%d ",*(pf[i]+j)); } printf("%d\n"); } printf("-------------------------------------\n");
fun(a); printf("-------------------------------------\n");
//-------------------------------------------------
//a ：本质：数组，数组的元素a[0],a[1],a[2],,a[i]元素的类型 char [4] //a[i] : a[i][0] a[i][1] a[i][2] a[i][3]
//a 指向的对象的类型 char [4]; //a+i : 偏移i行的首地址 //char [4] ---->char //a+i--->&a[i] //*(a+i)-->a[i]---->i行的首列元素的地址 //a[i]+j : 表示偏移j个字节的地址，成为i行列元素的地址 --->&a[i][j] //*(a[i]+j)---->a[i][j]--->*(*(a+i)+j) //-----------------------------------------------
char b[12] = {10,11,23,45, 89,90,67,55,99,88,56,97}; char (*pt)[4] = b;
//pt = pt +1; //偏移4个字节 //printf("%d ",**pt); //
for(i = 0; i< 12; i++) { printf("%d ",*(*pt + i)); } printf("-------------------------------\n");
}
void fun(char (*pf)[4]) { int i,j;
for(i= 0; i < 3; i++) { for(j = 0; j < 4; j++) { //printf("%d ",*(*(pf+i)+j)) ; //printf("%d ",pf[i][j]); printf("%d ",*(pf[i]+j)); } printf("%d\n"); }
} |
练习：写一个子函数，将3*3的矩阵转置，并以指针的形式操作
a[0][0] a[0][1] a[0][2]
a[1][0] a[1][1] a[1][2]
a[2][0] a[2][1] a[2][2]
a[0][1] a[1][0]
a[0][2] a[2][0]
a[1][2] a[2][1]
i != j
#include <stdio.h>
void swap(int (*p)[3]); int main() { int a[3][3] = { 1,2,3, 4,5,6, 7,8,9 }; int i,j;
swap(a);
for(i = 0; i < 3; i++) { for(j = 0; j < 3; j++) {
printf("%d ",*((*(a+i))+j)); } printf("\n"); }
}
void swap(int (*p)[3]) { int i,j; int tmp;
for(i = 0; i < 3; i++) { for(j = 0; j < i; j++) { if(i != j) { tmp = *((*(p+i))+j); *((*(p+i))+j) = *((*(p+j))+i); *((*(p+j))+i) = tmp;
} } } } |
1.2 指针数组
1）本质：数组，数组元素的类型为指针类型，元素存储地址
2）格式：数据类型 * 标识符[长度];
3）说明：数据类型表示的是指针指向的数据的类型
长度：指针的个数，数组的元素是指针
4）大小：长度*4
5）用于：一般用于指向字符串
#include <stdio.h>
int main() { int a,b,c,d; //用指针指向abcd，需要4个指针 //int *p1 = &a,*p2 = &b,*p3 = &c,*p4 = &d;
//int* p[4] = {&a,&b,&c,&d}; //表示有4个其元素类型为指针类型的元素 int *p[4]; //指针数组
p[0] = &a; p[1] = &b; p[2] = &c; p[3] = &d;
int i; //scanf("%d %d %d %d",&a,&b,&c,&d); for(i = 0; i < 4; i++) scanf("%d",p[i]); //p[i] 指针 printf("%d %d %d %d",a,b,c,d); } |
二维数组存储多个字符串，行表示字符串的个数，列表示的每个字符串所能容纳的最大的字符的个数、
二维数组初始化，字符串的长度不一样
char a[4][20] = {“jhdhda”, “dsg”,”dsjghsjlgd”,”yub”}; //浪费空间
指针指向字符串，字符串的长度受限制，
可以使用指针数组指向多个字符串，数组的元素的个数表示的字符串的个数
char *p = “jhdhda”;
#include <stdio.h>
int main() { char *pf[4] = {"hagdukAGUYgwyuADOIhu", "jhdsjsa", "jsdh", "hdsg sjg ysgd uygsd" }; //指针指向字符串，指针存储字符串首字符的地址 pf[1] = "hello world"; pf[3] = "welcome";
int i;
for(i = 0; i < 4; i++) printf("%s\n",pf[i]);
//终端输入
//char str[30]; // // pf[2] = str; //指针指向一块可以读写的连续的一块空间 // gets(pf[2]);
char buf[4][30]; //buf[0] &buf[0][0]指向的对象的类型为char
for(i = 0; i < 4; i++) { pf[i] = buf[i]; //pf[0] = buf[0] gets(pf[i]); //将终端输入的字符串存储pf[i]指针指向的空间 }
printf("------------------\n"); for(i = 0; i < 4; i++) printf("%s\n",pf[i]); } |
1.3 指针函数
1）本质：函数，函数的返回值类型为指针类型，函数需要返回的是一个地址
2）格式：数据类型 * 函数名(参数列表)
3）说明：数据类型：指针指向的数据的类型
指针函数跟前面学习的函数写法一致
1.4 函数指针
1）本质：指针，指针指向的对象是函数，函数名代表函数的入口地址
2）格式：数据类型 (*指针名)(参数列表)
3）说明：
数据类型：函数返回值类型，要跟指针指向的函数的返回值类型保持一致
参数列表：可以写也可以不写，如果需要写参数列表，则只需要写参数的数据类型即可
4）函数指针调用函数的格式：
指针名(实参)
(*指针名)(实参)
#include <stdio.h>
int str_len(char *str); int str_cmp(const char *buf,const char *str);
char *str_cat(char *str,const char *buf); char * str_cpy(char *str,const char *buf);
int main() {
char buf[50] = {"hello world!"}; int len; #if 0
int (*p_strint)(); //如果指针指向多个函数的时候，函数的参数个数以及参数类型不一致，则此时不需要写参数 //在进行用指针调用函数的时候，其参数的传递是按照指针指向的函数的参数进行传递的 //如果函数指针的参数列表有写参数，则用指针调用函数的时候，其参数的传递需要按照 //函数指针的参数列表的参数进行传递
//--------------指针指向求字符串长度函数---------------------------
//len = str_len("shag jhdsg");
p_strint = str_len; //指针指向 str_len函数
//len = p_strint("shag jhdsg"); //将指针名当成函数名调用函数 len = (*p_strint)("shag jhdsg"); //能够很容易看出来是用指针调用函数
printf("%d\n",len);
//-----------------------指针指向字符串比较函数--------------------
p_strint = str_cmp; //指针指向str_cmp函数
len = (*p_strint)("hello","hell");
printf("%d\n",len);
#else
char * (*p_strfun)(char *,const char *); //当指针指向多个函数的时候，如果函数的参数个数以及类型一致，可以定义函数指针的参数列表 char *p ;
p_strfun = str_cpy; //指向字符串拷贝函数
p = (*p_strfun)(buf,"abcdefghi jkl");
puts(buf); puts(p);
//----------------------------------------------------
p_strfun = str_cat;
p = p_strfun(buf," hello world"); puts(p); puts(buf);
#endif }
int str_len(char *str) { int i = 0;
while(*str) { i++; str++; }
return i; }
char * str_cpy(char *str,const char *buf) { char *st = str;
if(str == NULL || buf == NULL) return NULL;
while(*buf) { *str = *buf; str++; buf++; } *str = '\0';
return st; }
char *str_cat(char *str,const char *buf) { char *st = str;
if(str == NULL || buf == NULL) return NULL;
while(*str) { str++; } while(*buf) { *str = *buf; str++; buf++; } *str = '\0';
return st; }
int str_cmp(const char *buf,const char *str) { if(str == NULL || buf == NULL) return NULL;
while(*buf || *str) { if(*buf > *str) return 1; else if(*buf < *str) return -1; buf++; str++; }
return 0; } |
1.5 二级指针
1）本质：指针，指向的对象的类型为指针类型
2）原型：数据类型* *指针名
3）说明：数据类型一级指针指向的对象的类型决定
4）大小：4个字节
#include <stdio.h> int main() { int a = 10;
int *p = &a;
int* *pf = &p; printf("%#X\n",pf); //打印pf的值--->p的地址 printf("%#X\n",&p); //指针变量p的地址 printf("%#X\n",p); //打印p的值，--->a的地址 printf("%#X\n",&a); //a的地址 printf("%#X\n",*pf); //取pf指向的空间的里面的内容--->p的值-->a的地址 printf("%#X\n",*p); // 取p指向的空间里面的内容，a的值 printf("%#X\n",**pf); //a的值 } |
二级指针的用法
#include <stdio.h>
void fun(char* *p);
int main() { char *pf[4] = {"hagdukAGUYgwyuADOIhu", "jhdsjsa", "jsdh", "hdsg sjg ysgd uygsd" }; //指针数组 ，有4个元素，元素的类型为 char * //数组的首元素地址 pf，&pf[0] --->指向的首元素的类型
fun(pf); }
void fun(char**p) //指针指向首元素 { int i;
for(i = 0; i < 4; i++ ) { printf("%s\n",*(p+i)); //p是首元素的地址--&p[0]-- p[0] //*(p+i) = p[i] } //p+i ： 偏移一个元素字节大小，元素的类型 char *
printf("%#p\n",p); printf("%#p\n",p+1); } |
#include <stdio.h>
int main() { char* a[]={"Pascal","C language","dBase","Coble"}; //指针数组 char **p; int j;
p=a+3; //&a[3] 元素的类型为char *
// printf("%s\n",*(p-1));
for(j=3;j>=0;j--) printf("%s\n",*(p--)); //(p-1)--->&a[2] //*(p-1) -->a[2]--->指针指向"dBase", } |