共计 12567 个字符，预计需要花费 32 分钟才能阅读完成。
一、绪论
指针也就是内存地址，指针变量是用来寄存内存地址的变量，不同类型的指针变量所占用的存储单元长度是雷同的，而存放数据的变量因数据的类型不同，所占用的存储空间长度也不同。有了指针当前，不仅能够对数据自身，也能够对存储数据的变量地址进行操作。
指针绝对于一个内存单元来说，指的是单元的地址，该单元的内容外面寄存的是数据。在 C 语言中，容许用指针变量来寄存指针，因而，一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。
二、指针的定义与应用
变量的指针与指针变量：
在 C 语言中，容许用一个变量来寄存指针，这种变量称为指针变量。指针变量的值就是某份数据的地址，这样的一份数据能够是数组、字符串、函数，也能够是另外的一个一般变量或指针变量。
变量的指针就是变量的存储地址，指针变量就是存储指针的变量。指针变量是寄存一个变量地址的变量，不同于其余类型变量，它是专门用来寄存内存地址的，也称为地址变量。定义指针变量的个别模式为：类型说明符 变量名 类型说明符示意指针变量所指向变量的数据类型； 示意这是一个指针变量；变量名示意定义的指针变量名，其值是一个地址，例如：char p1; 示意 p1 是一个指针变量，它的值是某个字符变量的地址：
// 定义指针变量与定义一般变量十分相似，不过要在变量名后面加星号 *，格局为：
int fp;//示意这是一个指针变量，fp 是一个指向 int 数据类型的指针
float a,b; // 示意 a 和 b 都是指针变量，都指向一个为 float 数据类型的指针
指针变量的应用：
取地址运算符 &：单目运算符 & 是用来取操作对象的地址。例：&i 为取变量 i 的地址。对于常量表达式、寄存器变量不能取地址（因为它们存储在存储器中，没有地址）。指针运算符 （间接寻址符）：与 & 为逆运算，作用是通过操作对象的地址，获取存储的内容。例：x = &i x 为 i 的地址，x 则为通过 i 的地址，获取 i 的内容。
// 赋值
int a = 100;// 定义了一个 a 的整形变量
int *p_a = &a;// 将一个 int 类型的指针 p_a，p_a 指向了 a（也叫 p_a 指向了 a 的地址）在定义指针变量 p_a 的同时对它进行初始化，并将变量 a 的地址赋予它，此时 p_a 就指向了 a。值得注意的是，p_a 须要的一个地址，a 后面必须要加取地址符 &，否则是不对的。和一般变量一样，指针变量也能够被屡次写入，只有你想，随时都可能扭转指针变量的值:
// 定义一般变量
float a = 99.5, b = 10.6;
char c = '@', d = '#';
// 定义指针变量
float *p1 = &a;//P1 指向 a 的地址
char *p2 = &c;//p2 指向 c 的地址
// 批改指针变量的值
p1 = &b;// 将 p1 扭转指向为 b
p2 = &d;// 将 p2 扭转指向为 a 是一个特殊符号，表明一个变量是指针变量，定义 p1、p2 时必须带 。而给 p1、p2 赋值时，因为曾经晓得了它是一个指针变量，就没必要多此一举再带上 ，后边能够像应用一般变量一样来应用指针变量。也就是说，定义指针变量时必须带 *，给指针变量赋值时不能带。
// 留神
不容许把一个数赋予指针变量
int *p;
p = &a;
*p = 100;// 这样是谬误的
或者：int b=200;
int *a;
a=b; // 这样也谬误，因为没有加上取地址符 & 指针变量存储了数据的地址，通过指针变量可能取得该地址上的数据：
#include <stdio.h>
int main(){
int a = 66;// 定义整形变量
int *p = &a; // 定义 int 的指针变量并指向 a 变量的地址
printf("%d, %dn", a, *p); // 两种形式都能够输入 a 的值
return 0;
}
// 假如 a 的地址是 0X1000，p 指向 a 后，p 自身的值也会变为 0X1000，*p 示意获取地址 0X1000 上的数据，也即变量 a 的值。所以从运行后果看，*p 和 a 是等价的。CPU 读写数据必须要晓得数据在内存中的地址，一般变量和指针变量都是地址的助记符，尽管通过 *p 和 a 获取到的数据一样，但它们的运行过程稍有不同：a 只须要一次运算就可能获得数据，而 *p 要通过两次运算，多了一层“间接”。// 程序被编译和链接后，a、p 被替换成相应的地址。应用 *p 的话，要先通过地址 0XF0A0 获得变量 p 自身的值，这个值是变量 a 的地址，而后再通过这个值获得变量 a 的数据
也就是说，应用指针是间接获取数据，应用变量名是间接获取数据，前者比后者的代价要高。能够用指针来扭转被指向那个变量的值 如：
#include <stdio.h>
int main(void){
int a = 1, b = 66, c = 2;// 定义一般变量
int *p = &a; // 定义指针变量并指向 a 的地址
*p = b; // 通过指针变量将 a 的值扭转了（因为在这里，* p 指向了 a 就等于 * p 和 a 身处同一个内存空间了，所以对 * p 批改 就相当于对 a 批改）c = *p; // 把指针 p 的值的赋值给了 C (依据后面说的，相当于将 a 赋值给了 C)
printf("%d, %d, %d, %dn", a, b, c, *p);// 所以他们的值都是同一个了
return 0;
}
* 在不同的场景下有不同的作用：* 能够用在指针变量的定义中，表明这是一个指针变量，以和一般变量辨别开；应用指针变量时在后面加 * 示意获取指针指向的数据，或者说示意的是指针指向的数据自身。也就是说，定义指针变量时的_和应用指针变量时的_意义齐全不同。
以上面的语句为例：
int *p = &a;// 这里示意指向 a 的地址
*p = 100; // 这里示意获取指针所指向的数据 其余一些骚操作：
int x, y, *px = &x, *py = &y;
y = *px + 5; // 示意把 x 的内容加 5 并赋给 y，*px+ 5 相当于(*px)+5
y = ++*px; //px 的内容加上 1 之后赋给 y，++*px 相当于 ++(*px)
y = *px++; // 相当于 y =(*px)++
py = px; // 把一个指针的值赋给另一个指针 对于“&”和“*”
“&”和“”都是右联合的。假如有变量 x = 10，则 &x 的含意是，先获取变量 x 的地址，再获取地址中的内容。因为“&”和“*”互为逆运算，所以 x = _&x。
假如有一个 int 类型的变量 a，pa 是指向 a 的指针，那么_&a 和 &_pa 别离是什么意思呢？
_&a 能够了解为_(&a)，&a 示意取变量 a 的地址（等价于 pa），_(&a)示意取这个地址上的数据（等价 pa），绕来绕去，又回到了原点，&a 依然等价于 a。
&pa 能够了解为 &(pa)，pa 示意获得 pa 指向的数据（等价于 a），&(pa)示意数据的地址（等价于 &a），所以 &*pa 等价于 pa。
看这里点击这里间接进群
三、野指针与空指针
空指针是说, 这个指针没有指向一块有意义的内存, 比如说:char k; 这里这个 k 就叫空指针. 咱们并未让它指向任意点. 又或者 char k = NULL; 这里这个 k 也叫空指针, 因为它指向 NULL 也就是 0, 留神是整数 0, 不是’0’一个空指针咱们也无奈对它进行取内容操作, 空指针只有在真正指向了一块有意义的内存后, 咱们能力对它取内容. 也就是说要这样 k =“hello world!”; 这时 k 就不是空指针了.
对于空指针值，个别的文档中偏向于用 NULL 示意，而没有间接说成 0。然而咱们应该分明：对于指针类型来说，返回 NULL 和 返回 0 是齐全等价的，因为 NULL 和 0 都示意“null pointer”（空指针）。一句话，空指针是什么，就是一个被赋值为 0 的指针，在没有被具体初始化之前，其值为 0.（百度解释）
如：
int *a;// 定义一个指针 a =NULL;// 让这个指针指向空 a =0;// 这样也是让一个指针指向空的形式 留神：void 这不叫空指针, 这叫无确切类型指针. 这个指针指向一块内存, 却没有通知程序该用何种形式来解释这片内存. 所以这种类型的指针不能间接进行取内容的操作. 必须先转成别的类型的指针才能够把内容解释进去. 还有’0’, 这也不是空指针所指的内容. ‘0’是示意一个字符串的结尾而已, 并不是 NULL 的意思 void因为是示意不晓得要指向什么货色的指针，计算时于 char 雷同（但不相通）
野指针不同于空指针，空指针是指一个指针的值为 null，而野指针的值并不为 null，野指针会指向一段理论的内存，只是它指向哪里咱们并不知情，或者是它所指向的内存空间曾经被开释，所以在理论应用的过程中，咱们并不能通过指针判空去辨认一个指针是否为野指针。防止野指针只能靠咱们本人养成良好的编程习惯。
野指针就是指针指向的地位是不可知的（随机的、不正确的、没有明确限度的）指针变量在定义时如果未初始化，其值是随机的，指针变量的值是别的变量的地址，意味着指针指向了一个地址是不确定的变量，此时去解援用就是去拜访了一个不确定的地址，所以后果是不可知的。（百度解释）上面说说哪些状况下会产生野指针，以及怎么防止。
1、指针变量的值未被初始化：申明一个指针的时候，没有显示的对其进行初始化，那么该指针所指向的地址空间是乱指一气的。如果指针申明在全局数据区，那么未初始化的指针缺省为空，如果指针申明在栈区，那么该指针会随便指向一个地址空间。所以良好的编程习惯就是在申明指针的时候就对其进行初始化，如果临时不晓得该初始化成什么值，就先把指针置空。
int main(void){
int *a;// 野指针
if(a!=NULL){....}
/*
int *a;
a=NULL/0; 正确的援用
*/
} 2、指针所指向的地址空间曾经被 free 或 delete：在堆上 malloc 或者 new 进去的地址空间，如果曾经 free 或 delete，那么此时堆上的内存曾经被开释，然而指向该内存的指针如果没有人为的批改过，那么指针还会持续指向这段堆上曾经被开释的内存，这时还通过该指针去拜访堆上的内存，就会造成不可预知的后果，给程序带来隐患，所以良好的编程习惯是：内存被 free 或 delete 后，指向该内存的指针马上置空。
void func()
{int *ptr = new int[5];
delete [ ]ptr;
// 执行完 delete 后，ptr 野指针
// 还应该这样做：ptr=NULL; 正确
} 3、指针操作超过了作用域，如果在一个程序块中让一个指针指向那个块中的某个变量，然而那个变量只是在块中无效，出了那个程序块，此变量就有效了，此时指向它的指针也就变成了野指针。
void func()
{
int *ptr = nullptr;
{
int a = 10;
ptr = &a;
} // a 的作用域到此结束
int b = *ptr; // ptr 指向的 a，然而 a 曾经被回收，所以 ptr 变成野指针
// 还应该这样做：ptr=NULL; 正确
} 所以 应用指针时该当留神”躲避“：初始化时置 NULL，开释时置 NULL。
四、指针的运算
C 指针是一个用数值示意的地址。因而，您能够对指针执行算术运算。能够对指针进行四种算术运算：++、–、+、-。递增递加加减，两个指针相减。
#include<stdio.h>
int main(void) {
int a=10;
int *pa = &a,*pA=&a;
double b = 22.2;
double *pb = &b;
char c = 'C';
char *pc = &c;
// 最后的值
printf("1- %#x %#x %#x n", &a, &b, &c);//%#x 示意 转换成十六进制带格局输入地址,
// 成果为在输入前加 0x
printf("2- %#x %#x %#x n", pa, pb, pc);
// 指针加法
pa += 2; pb += 2; pc += 2;
printf("3- %#x %#x %#x n", pa, pb, pc);
// 指针减法
pa -= 2; pb -= 2; pc -= 2;
printf("4- %#x %#x %#xn", pa, pb, pc);
// 指针的比拟
if (pa == pA) {printf("5=%dn", *pA);
}
else {printf("6=%dn", *pa);
}
return 0;
}
// 从运算后果能够看出：pa、pb、pc 每次加 1，它们的地址别离减少 4、8、1，正好是 int、double、char 类型的长度；减 2 时，地址别离缩小 8、16、2，正好是 int、double、char 类型长度的 2 倍。/* 简略的概括就是：指针的每一次递增，它其实会指向下一个元素的存储单元。指针的每一次递加，它都会指向前一个元素的存储单元。指针在递增和递加时跳跃的字节数取决于指针所指向变量数据类型长度，比方 int 就是 4 个字节。指针变量除了能够参加加减运算，还能够参加比拟运算。当对指针变量进行比拟运算时，比拟的是指针变量自身的值，也就是数据的地址。如果地址相等，那么两个指针就指向同一份数据，否则就指向不同的数据。当然还有其余逻辑运算符
下面的代码（第一个例子）在比拟 pa 和 pA 的值时，pa 曾经指向了 a 的上一份数据，所以它们不相等。而 a 的上一份数据又不晓得是什么，所以会导致 printf() 输入一个没有意义的数，这正好印证了下面的观点，不要对指向一般变量的指针进行加减运算
留神：不能对指针变量进行乘法、除法、取余等其余运算，除了会产生语法错误，也没有理论的含意。#include<stdio.h>// 指针的加减法其实上的地址上的挪动
int main(void) {char a[] = {2,3,4,5,6};
char *p = &a[0];
char *p1 = &a[10];
printf("p1-p=%dn", p1 - p);
printf("p=%pn", p);
printf("p1=%pn", p1);
// 这里如果运算为大于零，就是真 输入 0
// 如果运算为小于零，就是假 输入 -1
int *t = a[0];
int *k = a[3];
printf("* %dn", t-k);
int b[] = { 1,2,3,4,5,6};
int *q = &b[0];
int *q1 = &b[6];
printf("q1-q=%dn", q1 - q);
printf("%pn", q1);
printf("%pn", q);
return 0;
} 常见的指针运算：
*（++p）: 先挪动指针，取下一个单元的值
*（p++）: 先取出以后单元的值，再挪动指针
（* p）++ : 先取出以后单元的值，再使以后单元的值加 1（指针不挪动）
++（* p）: 先使以后单元的值加 1，再取出以后单元的值（指针不挪动）
指针的类型转换：
int p=&i; void q=(void )p; 这并没有扭转 p 所指向的变量的类型，而是让前人用不同的眼光通过 p 看它所指的变量 意思是：这里的 p 我不再当你是 int 了，认为你就是个 void 类型的。留神因为优先级的问题 p++ 和 *（p++）是等价的取地址符 & 补充：取得变量的地址，它的操作必须是变量，int i,printf(“%x”,&i); 获得 i 的地址并输入。int i,printf(“%p”,&i); 获得 i 的地址并输入。地址的大小是否于 int 雷同取决于编译器。留神 应用指针的时候的类型，无论指向什么类型，所有的指针的大小都是一样的，因为都是地址，然而指向不同类型的指针是不能互相赋值的，这是为了防止用错指针。
五、字符串与指针、数组与指针
定义数组时，要给出数组名和数组长度，数组名能够认为是一个指针，它指向数组的第 0 个元素。在 C 语言中，咱们将第 0 个元素的地址称为数组的首地址，数组名的本意是示意整个数组，也就是示意多份数据的汇合，但在应用过程中常常会转换为指向数组第 0 个元素的指针，所以下面应用了“认为”一词，示意数组名和数组首地址并不总是等价。
#include<stdio.h>
int main(void) {int a[] = {1,2,3,4,5,6};
int line = sizeof(a) / sizeof(a[0]);// 计算数组长度
int i;
for (i = 0; i < line; i++) {printf("%d", *(a + i)); // 这里的 *(a + i)相当于 a[i]
}
return 0;
}
咱们应用的 *(a+i)这个表达式，a 是数组名，指向数组的第 0 个元素，示意数组首地址，a+i 指向数组的第 i 个元素，*(a+i) 示意取第 i 个元素的数据，它等价于 a[i]。咱们也能够定义一个指向数组的指针，例如：
int a[]={1,2,3,4,5,6};
int *p=a;
a 自身就是一个指针，能够间接赋值给指针变量 p。a 是数组第 0 个元素的地址，所以 int *p = a;
也能够写作 int *p = &a[0];。也就是说，a、p、&a[0] 这三种写法都是等价的，它们都指向数组第 0 个元素，或者说指向数组的结尾。留神：a 自身就是一个指针”这种表述并不精确，严格来说应该是“a 被转换成了一个指针，如果一个指针指向了数组，咱们就称它为数组指针（Array Pointer）数组指针指向的是数组中的一个具体元素，而不是整个数组，所以数组指针的类型和数组元素的类型无关，下面的例子中，p 指向的数组元素是 int 类型，所以 p 的类型必须也是 int *。反过来想，p 并不知道它指向的是一个数组，p 只晓得它指向的是一个整数，到底如何应用 p 取决于程序员的编码。
数组在内存中只是数组元素的简略排列，没有开始和完结标记，在求数组的长度时不能应用指针 p 来 sizeof§ / sizeof(int)这样来求，因为 p 只是一个指向 int 类型的指针，编译器并不知道它指向的到底是一个整数还是一系列整数（数组），所以 sizeof§ 求得的是 p 这个指针变量自身所占用的字节数，而不是整个数组占用的字节数。如果不晓得数组的长度，那么就无奈遍历整个数组
引入数组指针后，咱们就有两种计划来拜访数组元素了，一种是应用下标，另外一种是应用指针：1) 应用下标 也就是采纳 arr[i] 的模式拜访数组元素。如果 p 是指向数组 arr 的指针，那么也能够应用 p[i] 来拜访数组元素，它等价于 arr[i]。
应用指针 也就是应用 (p+i) 的模式拜访数组元素。另外数组名自身也是指针，也能够应用 (arr+i) 来拜访数组元素，它等价于 *(p+i)。
不论是数组名还是数组指针，都能够应用下面的两种形式来拜访数组元素。不同的是，数组名是常量，它的值不能扭转，而数组指针是变量（除非特地指明它是常量），它的值和它的所指向能够任意扭转。也就是说，数组名只能指向数组的结尾，而数组指针能够先指向数组结尾，再指向其余元素。
// 利用自增来遍历数组
#include<stdio.h>
int main(void) {int a[] = {1,2,3,4,5,6};
int line = sizeof(a) / sizeof(a[0]);
int i;
int *p = a;// 指针 p 指向数组首地址
for (i = 0; i < line; i++) {printf("地址 a[%d]：%pn",i,p);
printf("值 a[%d]:%d n", i, *p);
// 指针自增挪动
p++;
}
return 0;
}
/* 自减也是同样的成果
递增递加须要留神的：*p++；示意取出 p 所指向的那个数据来，完预先顺便把 p 挪动到下一个地址地位去，* 的优先级尽管高，然而没
有 ++ 高，这个是罕用于数组之类的间断空间中，留神：//int b[ ] = a; 不能够做
//int *p = a; 能够做
// b = a; 不能够做
//int b[] = -- > int * const b; 因为 const 示意 b 常量的数不能扭转 另外：const int a[]={1,2,3,4,5,6}; 数组变量曾经是 const 的指针了，这里的 const 示意数组的每个单元都是 const int 所以必须通过初始化进行赋值。数组变量是非凡的指针，数组变量自身表白地址，所以 int a[10];int *p=a // 不必取地址值，然而数组的单元表白的是变量，须要用 & 取地址，int b==&a[0]; []运算符能够对数组做，也能够对指针做：p[0]=a[0];
C 语言中没有特定的字符串类型，咱们通常是将字符串放在一个字符数组中，所以字符数组归根结底还是一个数组，上节讲到的对于指针和数组的规定同样也实用于字符数组。更改下面的代码，应用指针的形式来输入字符串：
#include<stdio.h>
#include<stdlib.h>
int main(void) {char s[] = "hello world";
char *p = s;
int len = strlen(s);// 取得字符串长度函数
int i;
// 应用指针遍历字符串输入
for (i = 0; i < len; i++) {printf("%c", *(p + i));
}
printf("n");
// 应用数组的形式遍历输入
for (i = 0; i < len; i++) {printf("%c", p[i]);
}
printf("n");
// 应用指针的模式输入
for (i = 0; i < len; i++) {printf("%c", *(s + i));
}
printf("n");
return 0;
} 除了字符数组，C 语言还反对另外一种示意字符串的办法，就是间接应用一个指针指向字符串，例如：
char *str;
str = "hello world";
/* 字符串指针指向的是一个字符串,str 是一个 char 类型的指针变量，指向字符串 "hello world"，指针变量 str 寄存的是这个字符串的首地址。所以输入的是一个字符串，应改写成 printf(“%sn”,str); 字符串中的所有字符在内存中是间断排列的，str 指向的是字符串 (字符数组) 的第 0 个字符；咱们通常将第 0 个字符的地址称为字符串的首地址。字符串中每个字符的类型都是 char，所以 str 的类型也必须是 char _。
这所有看起来和字符数组是如许地类似，它们都能够应用 %s 输入整个字符串，都能够应用_或 [] 获取单个字符，这两种形式的区别如下：
它们最基本的区别是在内存中的存储区域不一样，字符数组存储在全局数据区或栈区，第二种模式的字符串存储在常量区。全局数据区和栈区的字符串（也包含其余数据）有读取和写入的权限，而常量区的字符串（也包含其余数据）只有读取权限，没有写入权限。内存权限的不同导致的一个显著后果就是，字符数组在定义后能够读取和批改每个字符，而对于第二种模式的字符串，一旦被定义后就只能读取不能批改，任何对它的赋值都是谬误的。
咱们将第二种模式的字符串称为字符串常量，意思很显著，常量只能读取不能写入：
char *str = "Hello World!";// 这里是字符常量是指针
str = "I love C!"; // 正确 让常量字符串指针从新指向一个字符串
str[3] = 'P'; // 谬误 这个是想通过一个字符常量指针让一个字符数组赋值 六、指针做函数参数，指针做函数返回类型
有时候咱们能够应用函数的返回值来回传数据，在简略的状况下是能够的，然而如果返回值有其它用处（例如返回函数的执行状态量），或者要回传的数据不止一个，返回值就解决不了了。所以要援用上指针来传递
指针做函数参数：
在 C 语言中，函数的参数不仅能够是整数、小数、字符等具体的数据，还能够是指向它们的指针。用指针变量作函数参数能够将函数内部的地址传递到函数外部，使得在函数外部能够拜访到函数内部的数据，并且这些数据不会随着函数的完结而被销毁。像数组、字符串、动态分配的内存等都是一系列数据的汇合，没有方法通过一个参数全副传入函数外部，只能传递它们的指针，在函数外部通过指针来影响这些数据汇合。有的时候，对于整数、小数、字符等根本类型数据的操作也必须要借助指针，一个典型的例子就是替换两个变量的值：
#include <stdio.h>
void swap(int a, int b){
int temp; // 长期变量
temp = a;
a = b;
b = temp;
}
int main(){
int a = 66, b = 99;
swap(a, b);
printf("a = %d, b = %dn", a, b);
return 0;
}
/*
从后果能够看出，a、b 的值并没有产生扭转，替换失败。这是因为 swap() 函数外部的 a、b 和 main() 函数外部的 a、b 是不同的变量，占用不同的内存，它们除了名字一样，没有其余任何关系，swap() 替换的是它外部 a、b 的值，不会影响它内部（main() 外部）a、b 的值。他们会随着函数段的完结而失去了作用域 利用指针：
#include <stdio.h>
void swap(int *p1, int *p2){// 这里接管到的是 a 和 b 的地址
int temp;
temp = *p1;// 利用地址将值做批改
*p1 = *p2;
*p2 = temp;
}
int main(){
int a = 66, b = 99;
swap(&a, &b);// 这里将 a 和 b 的地址获取传入
printf("a = %d, b = %dn", a, b);
return 0;
}
// 函数运行完结后尽管会将 p1、p2 销毁，但它对外部 a、b 造成的影响是“长久化”的，不会随着函数的完结而“复原原样”。因为咱们对它做的是进入到地址的批改 用数组做函数参数：
如果一个函数按值传递数组，则必须调配足够的空间来存储原数组的正本，而后把原数组的所有数组拷贝到新的数组中去，如果把数组的地址传递给函数，让函数来间接解决原来数组则效率要高。然而 传递地址的时候，总会导致一些问题，C 通常安值传递数据，因为这样做能够保证数据的完整性，如果函数应用的是原始的数组的正本，就不会产生批改原始数据，然而，解决数组的函数通常都须要应用原始数据，因而这样的函数能够批改原数组，有时，这正是咱们须要的：void add(double a[],int n,int b); 调用此函数，将能够将原来数组的值进行批改，也能够说是函数通过指针，间接将原数组做批改了
数组是一系列数据的汇合，无奈通过参数将它们一次性传递到函数外部，如果心愿在函数外部操作数组，必须传递数组指针。上面的例子定义了一个函数 max()，用来查找数组中值最大的元素：
#include<stdio.h>
int max(int len, int a[]);// 申明 留神这里的 a[ ] 里边没有任何货色，其实也能够放货色也能够不放的
/* 实际上这种模式的数组定义都是假象，不论是 int a[100]还是 int a[]都不会创立一个数组进去，编译器也不会为它们分配内存，理论的数组是不存在的，它们最终还是会转换为 int *intArr 这样的指针。这就意味着，两种模式都不能将数组的所有元素“一股脑”传递进来，大家还得规规矩矩应用数组指针。*/
// 真正传递的数组能够有少于或多于 100 个的元素。int main(void) {
int n;
int a[100];
int i;
scanf("%d", &n);
for (i = 0; i < n; i++) {scanf("%d", a+i);// 给数组里边的值初始化
} // 这个 a 的原型是 int *a
// 所以这里能够应用 &a[i] 或者 a+i
printf("max=%d", max(n,&a));
return 0;
}
int max(int len, int a[]) {// 定义
int t = a[0];
int i;
for (i = 1; i < len; i++) {// 顺次比拟
if (t < a[i]) {t = a[i];
}
}
return t;// 返回 max
}
留神 不论应用哪种形式传递数组，都不能在函数外部求得数组长度，因为 intArr 仅仅是一个指针，而不是真正的数组，所以必须要额定减少一个参数来传递数组长度。// 有时候，因为把数组传入函数时传递的是地址，所以那个函数外部能够批改数组的值，为了爱护数组的值不被函数批改毁坏，能够设置参数为 const:
int sum (const int a[],int b); C 语言为什么不容许间接传递数组的所有元素，而必须传递数组指针呢？参数的传递实质上是一次赋值的过程，赋值就是对内存进行拷贝。所谓内存拷贝，是指将一块内存上的数据复制到另一块内存上。
对于像 int 等根本类型的数据，它们占用的内存往往只有几个字节，对它们进行内存拷贝十分疾速。而数组是一系列数据的汇合，数据的数量没有限度，可能很少，也可能成千上万，对它们进行内存拷贝有可能是一个漫长的过程，会重大拖慢程序的效率，为了避免技能不佳的程序员写出低效的代码，C 语言没有从语法上反对数据汇合的间接赋值。
指针的函数返回类型：程序编译后, 每个函数都有执行第一条指令的地址即首地址, 称 [函数指针。函数指针即指向函数的指针变量, 要间接调用函数能够应用指针变量来实现。
int (_pf)(int, int);
通过将 pf 与括号中的“_”强制组合组合在一起, 示意定义的 pf 是一个指针, 而后与上面的“()”再次组合, 示意的是该指针指向一个函数, 括号里示意为 int 类型的参数, 最初与后面的 int 组合, 此处 int 示意该函数的返回值。因而,pf 是指向函数的指针, 该函数的返回值为 int。函数指针与返回指针的函数的含意大不相同。函数指针自身是一个指向函数的指针。指针函数自身是一个返回值为指针的函数。
#include<stdio.h>
#include<stdlib.h>
char *strs(char *strl1, char *strl2);// 申明一个 char* 类型的指针函数
int main(void) {char str1[50];// 定义字符串
char str2[50];
char *str;// 定义字符指针
gets(str1);// 输出
gets(str2);
str = strs(str1, str2);
printf("%s", str);
return 0;
}
char *strs(char *strl1, char *strl2) {if (strlen(strl1) > strlen(strl2)) {// 比拟长度 谁长返回谁
return strl1;
}
else {return strl2;}
} 用指针作为函数返回值时须要留神的一点是，函数运行完结后会销毁在它外部定义的所有部分数据，包含局部变量、部分数组和形式参数，函数返回的指针请尽量不要指向这些数据，C 语言没有任何机制来保障这些数据会始终无效，它们在后续应用过程中可能会引发运行时谬误 , 然而，这里所谓的销毁并不是将部分数据所占用的内存全副抹掉，而是程序放弃对它的应用权限，弃之不理，前面的代码能够随便应用这块内存 , 如果应用及时也可能失去正确的数据，如果有其它函数被调用就会笼罩这块内存，失去的数据就失去了意义。而笼罩它的到底是一份什么样的数据咱们无从推断（个别是一个没有意义甚至有些怪异的值）。
#include <stdio.h>
int *func(){
int n = 100;
return &n;
}
int main(){int *p = func(), n;
n = *p;
printf("value = %dn", n);// 因为后面没有笼罩，所以还是能失去之前的值
return 0;
}
****** 与上面比拟：******
#include <stdio.h>
int *func(){
int n = 100;
return &n;
}
int main(){int *p = func(), n;
printf("c.biancheng.netn");// 这里会笼罩掉
n = *p;
printf("value = %dn", n);// 所以输入的值会无从得悉
return 0;
} 还应该留神函数指针变量的调用：
剖析函数指针变量不能进行算术运算，这是与数组指针变量不同的。数组指针变量加减一个整数可使指针挪动指向前面或数组元素，而函数指针的挪动是毫无意义的。函数调用中“（ 指针变量名）”的两边的括号不可少，其中的“”不应该了解为求值运算，在此处只是一种示意符号。要把“z= pomax(x,y);”改成“z=(pomax)(x,y);”。
