c语言基础学习07_指针

=============================================================================

涉及到的知识点有：

1、指针、指针的概念、指针变量的定义、取地址运算符 &、无类型指针、
指针占用内存的说明、野指针 与 空指针、空指针理解的扩展、指针的兼容性（即指针类型之间一定要匹配）、
不同的数据类型在内存中占用的地址、指向常量的指针 和 指针常量、指针与数组的关系、指针运算、
通过指针使用数组元素、不同类型的指针的区别以及与数组的关系、小案例：int类型与ip地址的对应关系
使用指针给二维数组排序、

2、指针数组、二级指针（指向指针的指针）、三级指针及其以上指针、函数的参数为指针变量时（指针变量作为函数的参数）、
函数的参数为数组名时（即数组名作为函数的参数）、函数的返回值为指针时（即指针作为函数的返回值）、
几个c语言的库函数：memset、memcpy、memmove函数，使用的时候需要包含头文件 #include <string.h>、

3、字符指针 与 字符串、通过指针访问字符串数组、通过指针使得字符串逆置、函数的参数为char *（即char *作为函数的参数）、
自定义函数实现求字符串长度和字符串拷贝、例外：如果函数的参数是一个字符串时，那么并不需要再传递一个参数说明这个字符串有多长、

4、指针数组作为main函数的形参、举个小例子：用到main函数的参数，实现计算两个数的和、
课后作业写一个程序，需要用到main函数的参数、

=============================================================================
c语言是面向过程的语言，是弱类型语言，c语言的源代码基本就是无数个函数的堆砌。
即很多函数就组成c语言源代码了，也即它的源代码基本就是函数构成的。

C语言里面的test()和test(void)是不一样的。什么也不写的话，C语言就比较含糊了，容易出错，结果不可知。
C++语言里面的test()和test(void)是一样的。

c语言几个松散的地方（不足的地方，不严禁的地方，它容易出错的地方）。

课后思考：
写一个函数求字符串的长度。课后思考，用递归函数实现求字符串长度。

=============================================================================
指针

指针是c语言里面最抽象的、最重要的、最常用的。

指针的概念：

指针变量也是一个变量，
指针存放的内容是一个地址，该地址指向一块内存空间，
指针是一种数据类型(指针类型)。
--------------------------------------
计算机内存的最小单位是什么？BYTE(字节)

对于内存，每个BYTE(字节)都有一个唯一不同的编号，这个编号就是内存地址。

操作系统就给内存的每一个字节编了一个号，所以说：一个编号对应的是一个BYTE(字节)的空间大小。

打比方：
1 　　 -> 　　 BYTE
2 　　 -> 　　 BYTE
3　　  -> 　　 BYTE
4　　  -> 　　 BYTE
　　  对应于
--------------------------------------
一个int多大？答：4个BYTE(字节)，所以一个int占用了了4个编号(即4个不同的内存地址)。

地址的编号：在32位系统下是一个4个字节的无符号整数；在64位系统下是一个8个字节的无符号整数。
(因为地址不可能是负的，又因为无符号数可以表达一个更大的地址，有符号数表示的最大地址会变小)
-----------------------------------------------------------------------------
指针变量的定义：

可以定义一个指向一个变量的指针变量。
-----------------------------------------------------------------------------
取地址运算符 &

& 可以取得一个变量在内存当中的地址。（取地址取的是内存地址）

register int a; //寄存器变量，这种变量不在内存里面，而在cpu里面，所以是没有地址的，
所以寄存器变量不能使用&来得到地址。
-----------------------------------------------------------------------------
无类型指针

定义一个指针变量，但不指定它指向具体哪种数据类型。可以通过强制转化将 void * 转化为其他类型指针，
也可以用 (void *) 将其他类型强制转化为void类型指针。

void *p; 指针之间赋值需要类型相同，但任何类型的指针都可以赋值给 void * 。
-----------------------------------------------------------------------------

linux下示例代码如下：

int main()
{
    int *p; //定义了一个可以指向int类型地址的指针变量，指针变量的名字叫p。*不是指针变量名字的一部分。
            //int * 是一种数据类型。
    int a;  //定义了一个int类型的变量，int变量的名字叫a。

    a = 1;  //int * 和 int是两种不同的数据类型。
    p = &a; //把a的内存地址赋值给指针变量p。

    printf("%p
", p);  //0x7fff5b2faedc 输出的是a的首地址的编号，不会把四个编号都输出的。
                        //而且注意：每一次执行该代码后，输出的编号都会发生变化！

    *p = 10;    //通过指针变量间接的访问a的值，*p代表指针指向变量的值，p代表指向变量的地址。
    printf("a = %d
", a);  //a = 10; 通过上面的方法把a的值改变了。

    a = 100;
    printf("%d
", *p); //100   通过指针变量间接的访问a的值。

    int b = 2;
    p = &b; //又把b的内存地址赋值给p。
    *p = 20;
    printf("b = %d
", b);  //20

    //char *p1 = &a;  //相当于 char *p1; p1 = &a;//两个类型不相同的地址。即指针类型不兼容。那么我们强转试试！
    char *p1 = (char *)&a;
    a = 123456;
    *p1 = 0;
    printf("a = %d
", a);  //a = 123392  就算强转后也会出现问题，所以要避免指针类型不兼容问题。

    void *p2;   //可以指向任何类型的地址，void代表无类型。

    return 0;
}

-----------------------------------------------------------------------------

指针占用内存的说明

在同一个系统下，不管指针指向什么样类型的变量，地址的大小(或叫编号的大小)总是一样的。

linux下示例代码如下：

int main()
{
    char *p1;
    int *p2;
    long long *p3;

    printf("%lu, %lu, %lu
", sizeof(p1), sizeof(p2), sizeof(p3));  //实质是：编号的大小是多少？
    return 0;   //输出的是 8, 8, 8
                //地址的编号：在32位系统下是一个4个字节的无符号整数；在64位系统下是一个8个字节的无符号整数。
                //指针变量的名字叫p1、p2、p3。指针变量的大小是多大呢？因为指针变量对应的是某某的首地址的编号，
                //即指针变量对应的是编号，而编号就是内存地址。即编号在64位系统下是一个8个字节的无符号整数。
                //所以指针变量的大小就是编号的大小，而编号在64位系统下用8个字节的无符号整数表示。
                //举例子说明下：同一个酒店，房间的编号的长度都是一样的。

}

--------------------------------------
再比如：

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int *p1;
    int a = 0;
    p1 = &a; 
    *p1 = 10; 
    //p1 = 10;

    int *p2;
    p2 = &a; 
    //*p2是什么？不管是*p1还是*p2都代表变量a的值，但p1和p2确实是两个不同的指针变量。
    return 0;
}

画图说明如下：

=============================================================================
野指针 与 空指针

野指针：没有指向任何有效地址的指针变量，所以在代码中避免出现野指针，
如果一个指针不能确定指向任何一个变量地址，那么就将这个指针变成空指针。

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int *p; 
    *p = 100;   //不能这样写，没有初始化过值的指针，这种指针叫野指针。
    return 0;   //因为地址编号所占用的内存不是你程序要调用的内存。对于操作系统而言，不是你的内存你就不能改！
                //如果你非要改的话，操作系统就会发现你在做非法操作，会直接把你清理出去了。即程序出错。
}

编译上段程序没有错误，运行上段程序会出现一个错误：Segmentation fault（段错误，也即分段故障）
-----------------------------------------------------------------------------
空指针：就是指向了NULL的指针变量。

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int *p;     //两句代码相当于一句：int *p = NULL;
    p = NULL;   //如果一个指针变量没有明确的指向一块内存，那么就把这个指针变量指向NULL。
                //这个指针就是空指针，空指针是合法的。
                //实际上NULL并不是c语言的关键字，NULL在c语言中的定义是：#define NULL 0
                //NULL在c语言里面就是一个宏常量，值是0。那么我们为什么不直接写0呢？
                //NULL代表的是空指针，而不是一个整数零，这样看的会舒服些。（这只是粗浅易懂的解释）
    return 0;
}

程序中不要出现野指针，但可以出现空指针。
--------------------------------------
空指针理解的扩展：

注意：
int a = 0;
int *p = &a;    //相当于 int *p; p = &a;

int *node = NULL;    //相当于：int *node; node = NULL;

NULL就是系统定义特殊的0，把你初始化的指针指向它，可以防止“野指针”的恶果。

NULL是个好东西，给一出生的指针一个安分的家。
--------------------------------------
用C语言编程不能不说指针，说道指针又不能不提NULL，那么NULL究竟是个什么东西呢？ C语言中又定义，定义如下：

1 #undef NULL
#if defined(__cplusplus)
#define NULL 0
#else
#define NULL ((void *)0)
#endif

所以我觉得，如果一个指针被赋予NULL，应该就相当于这个指针执行了0x0000这个逻辑地址，
但是C语言中0x0000这个逻辑地址用户是不能使用的，
（有些人说是因为0x0000没有映射到物理地址，也有人说是因为0x0000映射到的地址是操作系统用于判断野指针的，我也不太懂，总之就是用户不能使用啦）
所以当你试图取一个指向了NULL的指针的内容(或者叫值)时，就会提示段错误，听着有点绕，看程序：

int *node = NULL;
int a = 0;
a = *node;    //*node的意思是：取指针变量node的值。然后赋值给a。
    
printf("%d
", a);

*node的意思是：取指针变量node的值，也就是逻辑地址0x0000，而这个地址是不能被访问的(即不能被取出来的)，
c语言语法上没有问题，所以编译器编译没有问题，但是编译器编译后运行会出现段错误。

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int *p = NULL;    //相当于 int *p = 0; 但一般不这么写啊！
    int a = 0;
    a = *p; 
    printf("%d
", a); 

    return 0;
}
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# gcc -o p6 p6.c
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# p6
Segmentation fault（段错误，也即分段故障）
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# 

=============================================================================
指针的兼容性（即指针类型之间一定要匹配）

指针之间赋值比普通数据类型赋值检查更为严格，例如：不可以把一个 double * 赋值给int。

#include <stdio.h>

int main()
{
    int *p; 
    char b = 1;
    p = &b;     //指针类型之间一定要匹配，不然会有警告，强行运行的话，结果不可控！

    return 0;
}

警告如下：
warning: assignment from incompatible pointer type [-Wincompatible-pointer-types]
警告：不兼容的指针类型分配[-Wincompatible-pointer-types]

=============================================================================

我们不要把指针想象的特别神秘！其实指针变量也是一个变量。
它里面放的就是一个地址的编号，地址的编号就是一个8个字节的无符号的整数（64位系统下）。
区别是：这个整数不能直接赋值，而是来自于对另外一个变量的取地址操作而得到！

=============================================================================
不同的数据类型在内存中占用的地址

我们先看几个现象：

linux下示例代码如下：

#include <stdio.h>

int main()
{
    char a[10];
    printf("%p, %p, %p, %p
", a, &a[0], &a[1], &a[2]);
    return 0;
}
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# gcc -o p8 p8.c
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# p8
0x7ffe4f449e90, 0x7ffe4f449e90, 0x7ffe4f449e91, 0x7ffe4f449e92
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# gcc -o p8 p8.c
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# p8
0x7ffdae4e3c20, 0x7ffdae4e3c20, 0x7ffdae4e3c21, 0x7ffdae4e3c22
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# gcc -o p8 p8.c
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# p8
0x7ffd37b6f530, 0x7ffd37b6f530, 0x7ffd37b6f531, 0x7ffd37b6f532
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针#

每一次编译后执行，输出的地址会发生变化，但是相邻地址间的间隔不变。
--------------------------------------
再比如：

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int a[10];
    printf("%p, %p, %p, %p
", a, &a[0], &a[1], &a[2]);
    return 0;
}

root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# gcc -o p8 p8.c
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# p8
0x7ffe9e845ec0, 0x7ffe9e845ec0, 0x7ffe9e845ec4, 0x7ffe9e845ec8
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# gcc -o p8 p8.c
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# p8
0x7ffed37c6bc0, 0x7ffed37c6bc0, 0x7ffed37c6bc4, 0x7ffed37c6bc8
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# gcc -o p8 p8.c
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# p8
0x7ffdb8b422c0, 0x7ffdb8b422c0, 0x7ffdb8b422c4, 0x7ffdb8b422c8
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# 

每一次编译后执行，输出的地址会发生变化，但是相邻地址间的间隔不变。

其余的类型就不一一举例啦！

=============================================================================
指向常量的指针 和 指针常量

const int *p; 　//定义一个指向常量的指针。

int *const p；  //定义一个指针常量，一旦指向某一变量的地址后，不可再指向其他变量的地址。（注意：指针常量也叫常量指针）

二者区别：
const int *p; //p是一个变量，但指向一个常量。（即p可以指向任何地址，但是只能通过*p来读这块地址的内容，不能通过*p来写这块地址的内容）

int *const p; //p是一个常量，但指向一个变量或者常量。（即如果一旦p指向了任何一个有效的地址后，就不可再指向其他变量的地址，但可以通过*p来读写这块地址的内容）

--------------------------------------

linux下示例代码如下：

#include <stdio.h>

int main01()
{
    int a = 0;
    int *p = &a;        //此时的p指向了一个int类型的地址，可以通过*p的方式来修改这个内存a的值。
    *p = 10;
    printf("a = %d
", *p); //或者printf("a = %d
", a);    //此时的*p可读可写。

    return 0;
}

int main()
{
    int a = 0;
    const int *p = &a;  //此时的p指向了一个int类型的地址，但不可以通过*p的方式来修改这个内存a的值。
    //*p = 10;
    a = 10;             //但是呢，不可以通过*p来改a的值，可以通过a去修改a的值。
    printf("a = %d
", *p); //或者printf("a = %d
", a);    //此时的*p可读不可写。

    //c语言的一个小漏洞
    const int b = 100;
    //b = 0;    //定义了一个常量，那么这个常量权限是只读了。

    //通过指针的方法：即可以通过指向一个变量地址的指针去指向它，然后通过*p1去间接的修改b的值。
    //注意编译的时候会出现警告！我们忽略这个警告强行改！这时把b的值改了！！！
    //warning: assignment discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
    //警告：赋值时从指针目标类型丢弃“const”限定符[-Wdiscarded-qualifiers]
     
    //这就是在c语言中用常量的时候不用const了！
    //因为c语言中的const是有问题的，因为可以通过指针变量间接的修改const定义的常量的值，所以在c语言中用#define定义常量的时候更多。
      
    //为什么#define不能改呢？实质上#define就是一个文本替换，直接把它替换成一个整数了，整数又不是一个变量。
    //但是在C++中就没有这个漏洞了。为什么呢？因为c++里面的const是个真的const，而c语言中的const只是在语法的角度不让你去赋值，实际上是假的。
    //这是c语言本身存在的弱项。

    int *p1;    
    p1 = &b;    //为了避免这个warning，使用强转即可：p1 = (int *)&b;
    *p1 = 0;
    printf("b = %d
", b);  //或者printf("b = %d
", *p);

    int *const p2 = &a；    //表示p2指向了a的地址，而且p2只能指向a的地址，不可再指向其他变量的地址。
    //p2 = &b;//直接编译错误//p2是一个指针常量，p2只能指向固定的一个变量的地址，但可以用*p2读写这个变量的值。

    return 0;
}

=============================================================================
指针与数组的关系

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  //数组的名字a就是数组首元素的地址。
    int *p; 
    p = a;      //当指针变量指向一个数组的时候，c语言规定指针变量名可以当做数组名使用。
    //p = a[0]; //二者等价

    a[2] = 200;
    p[3] = 100; //相当于a[3] = 100;但二者之间也有区别哦！区别如下：
    printf("%lu, %lu
", sizeof(a), sizeof(p));//40, 8  二者所占内存大小不一样。

    int i;
    for (i = 0; i <10; i++)
    {   
        //printf("a[%d] = %d
", i, a[i]);  //输出没有问题
        printf("a[%d] = %d
", i, p[i]);  //输出也没有问题，完全把指针当数组用！
    }   

    return 0;
}

--------------------------------------
一级指针画图小说明如下：

=============================================================================
指针运算

指针变量可以进行计算，如果是 int * 类型每加一，变化4个整数；
如果是 char * 类型每加一，变化1个整数。其他类型以此类推。

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int a = 0;
    int *p = &a; 
    printf("%p, %p, %p
", p, p + 1, p + 2 );   //0x7fff5c2a518c, 0x7fff5c2a5190, 0x7fff5c2a5194

    return 0;
}

-----------------------------------------------------------------------------
指针运算小例子：

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int a[10] = { 0 };
    int *p = a;

    p += 5;
    *p = 1;

    p -=2;
    *p = 3;

    int i;
    for (i = 0; i < 10; i++)
    {   
        printf("a[%d] = %d
", i, a[i]);
    }   

    return 0;
}
输出的是：
a[0] = 0
a[1] = 0
a[2] = 0
a[3] = 3
a[4] = 0
a[5] = 1
a[6] = 0
a[7] = 0
a[8] = 0
a[9] = 0

-----------------------------------------------------------------------------
通过指针使用数组元素

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int *p = a; //指针p指向a的首地址。
    p[3] = 100; //等价于 *(p + 3) = 100; 一般写成左边那样。

        printf("a[%d] = %d
", i, a[i]);
    int i;
    for (i = 0; i < 10; i++)
    {   
    }   

    return 0;
}

=============================================================================
不同类型的指针的区别以及与数组的关系

极端例子如下：
linux下示例代码如下：

#include <stdio.h>

int main()
{
    int a = 0x12345678;
    char *p = (char *)&a;
    printf("%x, %x, %x, %x, %x
", *p, p[0], p[1], p[2], p[3]); //%x的意思是按照十六进制的有符号整数输出（小写） 
    printf("--------------------
");

    *p = 0;
    p[3] = 0;
    printf("%08x
", a); 
    printf("--------------------
");

    char b[20] = { 0 };
    int *p1 = (int *)&b;
    p1[3] = 0x12345678;

    int i;
    for (i = 0; i < 20; i++)
    {   
        printf("b[%d] = %x
", i, b[i]);
    }   
    printf("--------------------
");

    return 0;
}

输出的结果是：
78, 78, 56, 34, 12
--------------------
00345600
--------------------
b[0] = 0
b[1] = 0
b[2] = 0
b[3] = 0
b[4] = 0
b[5] = 0
b[6] = 0
b[7] = 0
b[8] = 0
b[9] = 0
b[10] = 0
b[11] = 0
b[12] = 78
b[13] = 56
b[14] = 34
b[15] = 12
b[16] = 0
b[17] = 0
b[18] = 0
b[19] = 0

--------------------
说明：小端对齐输出。

小结：c语言中所有的数据类型都可以理解为一个char的数组。

-----------------------------------------------------------------------------
小案例：int类型与ip地址的对应关系。

实际上的ip地址是一个无符号的整数构成的。1个int，4个字节。

1、把整数转换为ip地址

ip地址的格式：
0.0.0.0 ~ 255.255.255.255

linux下示例代码如下：

#include <stdio.h>

int main()
{
    unsigned int a = 235423523; //0x 0e 08 47 23  (14.8.71.35)  0e的0可以省略哦！
    scanf("%u", &a);
    unsigned char *p = (unsigned char*)&a;
    printf("%u.%u.%u.%u
", p[3], p[2], p[1], p[0]);
    printf("---------------------
");

    int i;
    for (i = 0; i < 4; i++)
    {   
        printf("%2x，%2u
", p[i], p[i]);
    }   

    return 0;
}
输出结果是：

56596596529659
108.8.25.251
---------------------
fb，251
19，25
 8， 8
6c，108

-----------------------------------------------------------------------------
2、把ip地址转换为整数

输入一个ip地址
char a[100] = "192.168.2.5"
把这个ip转化为unsigned int类型的整数。

linux下示例代码如下：

#include <stdio.h>

int main()
{
    char a[] = "192.168.2.5";
    unsigned int ip = 0;
    unsigned char *p = (unsigned char *)&ip;
    int a1, a2, a3, a4; 

    sscanf(a, "%d.%d.%d.%d
", &a1, &a2, &a3, &a4);    //sscanf从某一个格式化字符串中读取到我们想要的东西，找到后通过转义的方式取出来.
    //printf("%d.%d.%d.%d
", a1, a2, a3, a4);
    
    p[0] = a4;//*p = a4; 二者等价
    p[1] = a3; 
    p[2] = a2; 
    p[3] = a1; 
   
    /*  
    *p = a4;
    p++;
    *p = a3;
    p++;
    *p = a2;
    p++;
    *p = a1;
    */

    printf("%u
", ip);

    return 0;

}
输出结果是：

root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# gcc -o p16 p16.c
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# p16
3232236037
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# ping 3232236037
PING 3232236037 (192.168.2.5) 56(84) bytes of data.

-----------------------------------------------------------------------------
3、使用指针给二维数组排序

linux下示例代码如下：

#include <stdio.h>

int main()
{
    char a[2][5] = { { 4, 3, 5, 9, 78 }, { 52, 21, 5, 6, 4 } };
    char *p = (char *)a;

    int i, j;
    for (i = 0; i < 10; i++)
    {   
        for (j =1; j < 10 - i; j++)
        {   
            if (p[j] < p[j - 1]) 
            {   
                char tmp = p[j];
                p[j] = p[j - 1]; 
                p[j - 1] = tmp;

            }   
        }   
    }   

    for (i = 0; i < 2; i++)
    {   
        for (j = 0; j < 5; j++)
        {   
            printf("%d
", a[i][j]);
        }   
    }   

    return 0;

}

输出的结果是：
3
4
4
5
5
6
9
21
52
78

=============================================================================
指针数组

linux下示例代码如下：

#include <stdio.h>

int main()
{
    char *a[10];    //定义了一个指针数组，指针数组的名字叫a，每个成员是char *类型，一共10个成员。
    int *b[10];     //定义了一个指针数组，指针数组的名字叫b，每个成员是char *类型，一共10个成员。

    printf("%lu, %lu
", sizeof(a), sizeof(b)); //80, 80

    int i = 0;
    //a = &i;       //指针数组名不能做左值。
    //b = &i;       //指针数组名不能做左值。

    b[0] = &i;      //b[0]的类型是int *。
    printf("%lu, %lu
", sizeof(b[0]), sizeof(*b[0]));  //8, 4  *b[0]是一个数组的成员。

    return 0;

}

-----------------------------------------------------------------------------
linux下示例代码如下：

#include <stdio.h>

int main()
{
    int *a[10] = { NULL };  //定义了一个指针数组，指针数组的名字叫a，每个成员是int *类型的，一共有10个成员。
    int b, c, d;            //对于指针数组来说，要先有指针的性质，再有数组的性质，即先得获得地址，然后对数组进行操作。

    a[0] = &b;      //a是指针数组的名字。
    a[1] = &c;      //a[0]是指针变量,
    a[2] = &d; 

    *a[0] = 10;     //*a[0]是一个数组的成员之一。

    printf("%d
", b); 

    return 0;
}

=============================================================================
二级指针（指向指针的指针）

指针是一个变量，既然是变量就也存在内存地址，所以可以定义一个指向指针的指针。

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int a = 0;
    int *p = &a; 
    int **pp = &p;  //二级指针：指向指针的指针。
    pp = &p;        //pp代表一级指针内存地址的编号。
    
    //*pp = 1000;   //等号左端是指针类型的变量，等号右边是int类型。
                    //或者可以这么理解，指针变量指的是一个地址，无法对它进行赋值。
                    //再或者说，我们两对应的内存地方不一样。操作系统不让你干这非法的事情。(分段错误)

    **pp = 10; 
    printf("%d
",a );  //10

    return 0;
}

二级指针说明图如下：

=============================================================================
三级指针及其以上指针

linux下示例代码如下：

#include <stdio.h>

int main()
{
    int a = 0;//零级“指针”，a有内存地址编号，a的内容(值)为0。
    int *p = &a;//一级指针，p代表a的内存地址编号；*p代表a的内容(值)。
    int **pp = &p;//二级指针，pp代表p的内存地址编号；*pp代表a的内存地址编号；**pp代表a的内容(值)。
    int ***ppp = &pp;//三级指针，ppp代表pp的内存地址编号；*ppp代表p的内存地址编号；**ppp代表a的内存地址编号，***ppp代表a的内容(值)。
    int ****pppp = &ppp;//四级指针

    ****pppp = 100;
    printf("a = %d
", a); //100

    return 0;
}
pppp代表ppp的内存地址编号；
*pppp代表pp的内存地址编号；
**pppp代表p的内存地址编号；
***pppp代表a的内存地址编号；
****pppp代表a的内容(值)。

linux下示例代码如下图所示：

特别注意：
能用一级指针解决的问题不要用二级指针，能用二级指针解决的不用三级指针，指针级数过多会导致程序很复杂。
工作中大量使用的是一级指针，二级指针也很常用，三级指针就很罕见了，四级指针几乎没有。但笔试会考你哦！可以画图解决！

=============================================================================

函数的参数为指针变量(指针变量作为函数的参数)

实际上指针更多的时候用在函数的参数上。

函数的参数可以使是指针类型。它的作用是将一个变量的地址编号传送给另一个函数。

void test(int *p); //定义一个函数，形参是int *类型。

c语言中如果想通过在一个函数的内部修改外部实参的值，那么就需要给函数的参数传递这个实参的地址。
-----------------------------------------------------------------------------
linux下示例代码如下：

#include <stdio.h>

void swap(int a, int b) //swap是交换的意思。
{
    int tmp = a;
    a = b;
    b = tmp;
    printf("a = %d, b = %d
", a, b);//a = 2, b = 1  形参中的值发生变化了。
}

int main()
{
    int a = 1;
    int b = 2;

    swap(a, b); 
    printf("a = %d, b = %d
", a, b);//a = 1, b = 2  c语言中实参的值会传给形参，而形参值的改变并不会影响到实参。
    return 0;
}
-----------------------------------------------------------------------------
那么现在我就想在一个函数的内部修改外部实参的值，那么就需要给函数的参数传递这个实参的地址。代码如下：

#include <stdio.h>

void swap(int *a, int *b) 
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
    printf("a = %d, b = %d
", a, b);//a = 2, b = 1  形参中的值发生变化了。
}

int main()
{
    int a = 1;
    int b = 2;

    swap(&a, &b); //那么现在我就想在一个函数的内部修改外部实参的值，那么就需要给函数的参数传递这个实参的地址。
    printf("a = %d, b = %d
", a, b);//a = 2, b = 1  实参中的值发生变化了。
    return 0;
}

函数参数是指针变量的画图说明如下：

即：c语言想通过函数内部来修改实参的值，只能给函数传递实参的地址来间接的修改实参的值。
例如scanf函数：
int a;
scanf("%d", &a);//scanf是一个函数，现在要通过函数内部来修改实参a的值，只能用传递a的地址的方式修改a的值
=============================================================================

函数的参数为数组名时（即数组名作为函数的参数）

当一个数组名作为函数的形参的时候，c语言将数组名解释为指针变量，其实是一个指针变量名。

如果数组名作为函数的参数，那么这个就不是数组名了，而是一个指针变量名。

当把一个数组名作为函数的参数时，修改形参的值的时候，同时也影响实参的数组成员的值。

如果把一个数组名作为函数的参数，那么在函数内部就不知道这个数组的元素个数了，需要再增加一个参数来标明这个数组的大小。

如果将一个数组作为函数的形参进行传递，那么数组的内容可以在被调用函数的内部进行修改，
有时候不希望这样的事情发生，所以要对形参采用const进行修饰。

-----------------------------------------------------------------------------
linux下示例代码如下：

#include <stdio.h>

//此三种写法均可：常写的是void test(int *a)这一种！
//void test(int a[10])
//void test(int a[])
/*
void test(int *a)
{
    printf("%lu
", sizeof(a));
    a[50] = 50;
}
*/

/*
//为了从语法的角度不让在函数的内部修改数组成员的值，用const进行限定，如下：
void test(const int *a)
{
    printf("%lu
", sizeof(a));
    //a[5] = 100;   该句编译通不过，出现错误。因为此时的数组只能读，不能改。
}
*/

//现在我非要在加有const的函数内部进行修改呢？可以，使用指针就可以绕过c语言的语法！
void test(const int *a) 
{
    printf("%lu
", sizeof(a));

    int *p = (int *)a;
    p[5] = 50;  //此时可以修改了！
}

int main()
{
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    printf("%lu
", sizeof(a));
    printf("----------------------
");

    test(a);

    int i;
    for (i = 0; i < 10; i++)
    {   
        printf("a[%d] = %d
", i, a[i]);
    }   

    return 0;
}

=============================================================================
函数的返回值为指针时（即指针作为函数的返回值）

int *test()    //函数的返回值类型是指针类型（具体的讲解在下一节：内存管理）
{
    return NULL;    
}

=============================================================================
几个c语言的库函数：memset、memcpy、memmove函数，使用的时候需要包含头文件 #include <string.h>

这三个函数分别实现内存设置、内存复制、内存移动功能。

--------------------------------------
memset的功能是：将指定区域的内存置空(设置为0)。
void *memset(void *s, int c, size_t n);
第一个参数是：指定要置空的内存的首地址；
第二个参数是：要设置的值，一般写0；
第三个参数是：这块内存的大小，单位：字节。

linux下示例代码如下：

#include <stdio.h>
#include <string.h>

int main()
{
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    //想把一个已经初始化的数组成员的值都变成0。
    
    //法一：传统的方法如下：
    //a[10] = { 0 };//不能这样来啊，这叫定义后立马进行初始化。
    /*  
    int i;
    for (i = 0; i < 10; i++)
    {
        a[i] = 0;
    }
    */

    //法二：使用c语言库函数memset。
    memset(a, 0, sizeof(a));

    int i;
    for (i = 0; i < 10; i++)
    {   
        printf("a[%d] = %d
", i, a[i]);
    }   

    return 0;
}

-----------------------------------------------------------------------------
memcpy功能是：两块内存之间拷贝数据。

使用memcpy时，首先一定要确保内存没有重叠区域。

void *memcpy(void *dest, const void *src, size_t n);
第一个参数是：目标地址(目标内存首地址)；
第二个参数是：源地址(源内存首地址)；
第三个参数是：拷贝多少内容，单位字节。

linux下示例代码如下：

#include <stdio.h>
#include <string.h>

int main()
{
    //把a的内容拷贝到b中去。
    int a[10] = { 1, 2, 3, 4 ,5 ,6 ,7 ,8 ,9, 10 };
    int b[10] = { 0 };

    memcpy(b, a, sizeof(a));

    int i;
    for (i = 0; i < 10; i++)
    {   
        printf("b[%d] = %d
", i, b[i]);
    }   

    return 0;
}
输出的结果是：
b[0] = 1
b[1] = 2
b[2] = 3
b[3] = 4
b[4] = 5
b[5] = 6
b[6] = 7
b[7] = 8
b[8] = 9
b[9] = 10

--------------------------------------
linux下示例代码如下：

#include <stdio.h>
#include <string.h>

int main()
{
    //把a的内容拷贝到b中去。将int改为short。
    short a[10] = { 1, 2, 3, 4 ,5 ,6 ,7 ,8 ,9, 10 };
    int b[10] = { 0 };

    memcpy(b, a, sizeof(a));

    int i;
    for (i = 0; i < 10; i++)
    {   
        printf("b[%d] = %d, %08x
", i, b[i], b[i]);
    }   

    return 0;
}
输出的结果是：
b[0] = 131073, 00020001
b[1] = 262147, 00040003
b[2] = 393221, 00060005
b[3] = 524295, 00080007
b[4] = 655369, 000a0009
b[5] = 0, 00000000
b[6] = 0, 00000000
b[7] = 0, 00000000
b[8] = 0, 00000000
b[9] = 0, 00000000

内存拷贝说明画图如下：

-----------------------------------------------------------------------------
memmove功能是：内存移动，参数与memcpy一致。

void *memmove(void *dest, const void *src, size_t n);
第一个参数是：目标地址(目标内存首地址)；
第二个参数是：源地址(源内存首地址)；
第三个参数是：拷贝多少内容，单位字节。

内存重叠区域说明如下图所示：

=============================================================================

指针小结

定义 　　　　        说明
int i; 　　　　    定义个一个int类型的变量
int *p; 　　　　  定义一个指向int类型的指针变量
int a[10]; 　　    定义一个int类型的数组
int *p[10]; 　　   定义一个指针数组，其中每一个数组元素指向一个int类型变量的地址
int func(); 　　   定义一个函数，返回值类型为int类型
int *func(); 　　  定义一个函数，返回值类型为int*类型
int **p; 　　　　 定义一个指向int类型的指针的指针，二级指针

=============================================================================
字符指针 与 字符串

在c语言中，大多数的字符串操作其实就是指针操作。
--------------------------------------
1、通过指针访问字符串数组

linux下示例代码如下：

#include <stdio.h>

int main()
{
    char a[100] = "hello world";
    char *p = a;

    *p = 'a';   //注意：*p = p[0]
    p[3] = 'b';
    printf("%s
", a); //aelbo world

    return 0;
}

-----------------------------------------------------------------------------
通过指针使得字符串逆置

法一：使用一个指针
linux下示例代码如下：

#include <stdio.h>
#include <string.h>

int main()
{
    char a[100] = "hello world";
    char *p = a;

    int len = strlen(a);
    int min = 0;
    int max = len - 1;

    while (min < max)
    {   
        //char tmp = *p;//等价于tmp = p[0];
        char tmp = *(p + min);
        *(p + min) = *(p + max);
        *(p + max) = tmp;
        max--;
        min++;
    }   

    printf("%s
", a); //dlrow olleh

    return 0;
}

--------------------------------------
法二：使用二个指针
linux下示例代码如下：

#include <stdio.h>
#include <string.h>

int main()
{
    char a[100] = "hello world";
    char *p = a;    //等价于 char *p; p = a;//p指向了数组的首元素的地址。
    char *p1 = a;   //等价于 char *p1 = p;
    
    int len = strlen(a);

    p1 += len - 1;//p1指向了数组的最后一个元素的地址。
    
    while (p < p1) 
    {   
        char tmp = *p; 
        *p = *p1;
        *p1 = tmp;
        p++;
        p1--;
    }   

    printf("%s
", a); //dlrow olleh

    return 0;
}

=============================================================================
函数的参数为char *（即char *作为函数的参数）

linux下示例代码如下：

#include <stdio.h>

//三者形式等价，钟爱第三种！
//void test(char a[10])
//void test(char a[])
void test(char *a)    //数组作为函数的形参时，相当于一级指针。
{
    printf("%s
", a); 
    a[3] = '4';
}

int main()
{
    char a[] = "abcd";
    test(a);
    printf("%s
", a); 

    return 0;
}
输出结果是：
abcd
abc4

如果将一个数组作为函数的形参进行传递，那么数组的内容可以在被调用函数的内部进行修改，
有时候不希望这样的事情发生，所以要对形参采用const进行修饰。代码如下：

void test(const char *a) 
{
    printf("%s
", a); 
    //a[3] = '4';
}

-----------------------------------------------------------------------------
自定义函数实现求字符串长度和字符串拷贝

linux下示例代码如下：

#include <stdio.h>

int mystrlen(const char *s) 
{
    int len = 0;
    while (s[len])
    {   
        len++;
    }   
    return len;
}

void mystrcpy(char *s1, const char *s2)
{
    int len = 0;
    while (s2[len])
    {   
        s1[len] = s2[len];
        len++;
    }   
}

int main()
{
    char a[10] = "abc";
    char b[10] = { 0 };

    int i = 0;
    i = mystrlen(a);
    mystrcpy(b, a); 
    
    printf("%d
", i); 
    printf("%s
", b); 
    return 0;
}
输出的结果是：
3
abc

-----------------------------------------------------------------------------
如果一个数组作为函数的参数，那么数组的成员数量在函数内部是不可见的。
解决方法：在传递一个数组的时候，需要同时提供另外一个参数，标明这个数组有几个成员变量。

例外：如果函数的参数是一个字符串时，那么并不需要再传递一个参数说明这个字符串有多长。

linux下示例代码如下：

#include <stdio.h>

int printf_array(int n, int *a) 
{
    int i;
    for (i = 0; i < n; i++)
    {   
        printf("%d
", a[i]);
    }   
}

int main()
{
    int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    printf_array(sizeof(a) / sizeof(a[0]), a); 
    
    return 0;
}

注意：size_t 单位是1个字节。

=============================================================================
指针数组作为main函数的形参

先来看一个指针数组作为函数的参数（此时把指针数组解释为二级指针）

linux下示例代码如下：

#include <stdio.h>

//int print(char *p[10])
//int print(char *p[])
int print(int n, char **p)  //指针数组作为函数的形参时，相当于二级指针。
{
    int i;
    for (i = 0; i < n; i++)
    {   
        printf("%s
", p[i]);    //p[0]、p[1]、p[1]等的类型是char *。
        printf("%c
", *p[i]);    //*p[0]、*p[1]等的类型是char。
    }   
}

int main()
{
    char *a[4];    //a[0]、a[1]、a[2]、a[3]分别指向一个char *类型的数组。

    char a1[] = "hello";
    char a2[] = "abc";
    char a3[] = "world";
    char a4[] = "haha";

    a[0] = a1; 
    a[1] = a2; 
    a[2] = a3; 
    a[3] = a4; 
        
    printf("%lu, %lu
", sizeof(a), sizeof(a[0]));

    print(sizeof(a) / sizeof(a[0]), a); 

    return 0;

}
输出结果是：
32, 8
hello
h
abc
a
world
w
haha
h

-----------------------------------------------------------------------------
linux下示例代码如下：

#include <stdio.h>

int main(int argc, char **args)//argc代表这个数组有多少成员，args是一个指针数组，args这个数组的每个成员类型是char *,
{
    int i;
    for (i = 0; i < argc; i++)
    {   
        printf("%s
", args[i]);
    }   

    return 0;
}

args是命令行参数的字符串数组，argc代表命令行参数的数量，程序名字本身就算一个参数。

main函数是由系统调用的，所以main函数的参数功能是：得到命令行的参数。

-----------------------------------------------------------------------------
举个小例子：用到main函数的参数，实现计算两个数的和

例如：

程序名 数1 数2
一回车结果就出来了。
a 15 45
60

linux下示例代码如下：

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

int main(int argc, char **args)    //注意：main函数的参数的类型、和顺序是不能修改的。
{
    if (argc <= 2)
    {   
        printf("参数不足，使用方法：%s 整数1 整数2
", args[0]);
        return 0;
    }   
    else
    {   
        int a = atoi(args[1]);
        int b = atoi(args[2]);
        printf("%d
", a + b); 
    }   

    return 0;
}

-----------------------------------------------------------------------------
课后作业
写一个程序，需要用到main函数的参数

例如：

程序名 整数1 运算符 整数2，程序运行的结果是计算结果。
a 5 + 6 　　 注意：中间的加号是字符串。
11

a 5 * 6
30

......

+ - * / 都要实现

linux下示例代码如下：

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

int main(int argc, char **args) //等价于 char *args[]
{
    //因为星号在linux下是一个通配符，代表在当前目录下的所有文件。

    /*
    //验证星号是什么？
    int i;
    for (i = 0; i < argc; i++)
    {
        printf("%s
", argc[i]);
    }
    return 0;
    */

    if (argc < 4)
    {
        return 0;
    }

    //因为 char **args，是指针数组，args是二级指针，分别是 args[0]、args[1]等，类型是char *。
    int a = atoi(args[1]);  //把第一个参数转化为int。
    int b = atoi(args[3]);  //把第三个参数转化为int。

    //“+” 中间的加号是一个字符串。该字符串是一个字符数组，且对于该字符串的加号是第一个元素。
    char *s = args[2];  //得到第二个参数，因为每个参数的类型都是char *。
    char c = s[0];
    //char c = args[2][0];  //该句话与上面两句话等价。

    switch (c)
    {
        case '+':
            printf("%d
", a + b);
            break;
        case '-':
            printf("%d
", a - b);
            break;
        case '*':
            printf("%d
", a * b);
            break;
        case '/':
            printf("%d
", a / b);
            break;
        default:
            printf("error
");
    }

    return 0;
}
执行结果为：
"p35.c" 51L, 1226C written                                                                                                                                              
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# gcc -o a p35.c 
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# a 6 + 5
11
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# a 6 - 5
1
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# a 6 * 5  （注意要有转义字符）
30
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# a 6 / 5
1
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# a
root@iZ2zeeailqvwws5dcuivdbZ:~/1/01/指针# 

=============================================================================