六、C_base——指针

指针基本概念：

【1】指针

        1---指针变量：专用于存放地址的变量
        2---地址常量：内存地址

【2】定义

        int a = 10;
        int *p = &a;               
                                //  p指向a的地址
                                //  变量名：p
                                //  类型：int *       
                                //  int *p; p = &a; 

【3】运算符

        1--- *
                1、类型的一部分
                2、指针解引用（钥匙）--取值
                3、指针降级
        2--- & 
                取地址符
        3--- +-
                1、指针的加减：加减的是单位长度
                2、单位长度：指针所指向数据类型所占的字节数
        4--- []
                []：指针加单位长度后，取内容运算
                int a[5];
                int *p = a;

                a[i] <==> *(a+i)
                p[i] <==> *(p+i)

【4】指针大小

        占4个字节（32位操作系统，ubuntu）
        占8个字节（64位操作系统）

【5】atoi

        函数：int atoi(char *a)
        功能：将数值型的字符串转换成整形
        参数：数值型字符串的首地址
        注意：遇到非数值形式的字符停止转化
        例：a[] = "123a456";
               printf("%d",atoi(a));
        注意：这里打印的是%d。

函数的实现：

#include <stdio.h>
#include <strlib.h>
int main()
{
    char a[] = "1256a69b";
    char *p  = a;       //定义指针：p  类型：char *  a是数组的首地址
    int sum = 0;        //定义一个整形，承接数值型字符串的整形
    while('0'<=*p && *p<='9')  //判断是否在'0'~'9'之间,此时*p是a[0]
    {
        sum = sum*10+*p-'0';    //每次循环检测出的值给位输出
        p++;                    // a[0]、a[1]、a[2]...地址
    }
    printf("sum = %d",sum);     //注意：a地址是地址常量，p是指针变量
    return 0;
}

【6】指针数组

        指针数组：数组是本质，元素的类型是指针
        int a = 10;
        int b = 30;
        int* p[2];    //声明指针数组，有指针p[0]、p[1]、p[2]个元素
        p[0] = &a;    //p[0]是指针，类型是int *。指针是地址，所以需要&a
        p[1] = &b;

【7】二维数组

        int a[3][4] = {0};
         //[]是运算符，a[2] <==> *(a+2)     a代表整个数组的首地址
        a[1][2] <==> *(a[1]+2) <==> *(*(a+1)+2)    
        a是行指针，a+1跳一行，到下一行的首地址;
        a[0]是列指针，a[0]+1跳一列，到下一列的首地址;

【8】数组指针

        int (*p)[4];
        本质：指针,专用于指向数组
        [4]   ：指向的数组是4列，必须有并且一致与数组的列
        数组指针：指向一个数组的指针，多数用于指向二维数组

        int a[3][4] = {{0,1,2,3},{4,5,6,7},{8,9,10,11}};
        int (*p)[4];   //int (*p)[4] = a;
        p = a; 
//与上面注释两种赋值方式,a是整个数组的首地址,p = a是把指针p指向数组的首地址

【9】 四个常用函数 头文件 string.h，程序测试在最下面。

        1、strcpy
                函数原型：char *strcpy(char *dest,const char *src)

                功能：字符串拷贝
                参数：src为原串的起始地址，dest为目标串的起始地址
                返回值：目标串的起始地址
                说明：字符数组1必须足够大，拷贝时'\0'一起拷贝
        2、strcat
                函数原型：char *strcat(char *dest,const char *src)
                功能：把字符串src链接到字符串dest的后面
                参数：src为源串的起始地址，dest为目标串的起始地址
                说明：字符数组1必须足够大；连接后，串1的'\0'取消
        3、strcmp
                函数原型:int strcmp(const char *s1,const char *s2)
                功能：按照ASCII码顺序比较字符串s1和字符串s2的大小
                参数：s1、s2为字符串起始地址
                返回值：比较结果
                        字符串1 = 字符串2，返回值 = 0
                        字符串1 > 字符串2，返回值 > 0
                        字符串1 < 字符串2，返回值 < 0 

        4、strlen
                函数原型：size_t strlen(const char *s)
                功能：求字符串的长度（不含字符串结束标志'\0'）
                参数：s为字符串
                返回值：字符串的长度（不含字符串结束标志'\0'）       

实例：源码及注释

1、1_p.c 指针的声明

#include <stdio.h>
int main()
{
    int a = 10;
    float b = 12.34;
    char c = 'p';

    int *p = &a;    //类型：int *  变量名：p （p指向a：p存放a的地址）
    float *w = &b;  //类型：float *w   变量名：w
    char *q = &c;   //类型：char *q   变量名：q

    printf("a    = %d\n",a);   //a为int型常量 10
    printf("*p   = %d\n",*p);  //指针p为a的地址，*p是a地址的值

    printf("b    = %f\n",b);
    printf( "*w   = %f\n",*w);

    printf("c     = %c\n",c);
    printf("*q    = %c\n",*q);

    return 0;
}

2、 2_P.c

#include <stdio.h>
int main(int argc, const char *argv[])
{
    short a = 10;
    float b = 12.34;
    char c = 'P';

    short *p = &a;  //类型： int*   变量名：p （p指向a：p存放a的地址）
    float *w = &b;
    char *q = &c;

    printf("p     = %p\n",p);    //指针的加减：加减的是单位长度
                     //单位长度：指针所指向的数据类型所占的字节数
    printf("p+1   = %p\n",p+1);
    printf("p+2   = %p\n",p+2);
    printf("p+3   = %p\n",p+3);

    return 0;
}

3、 3_array_P.c

#include <stdio.h>
//
//利用 * 的第二个性质  钥匙，即使对地址然后取值
int main(int argc, const char *argv[])
{
    int a[4] = {0,1,8,9};
    int i;
    for(i=0; i<4;i++)     //遍历循环打印a[0]~a[4]地址
    {
        printf("&a[%d] = %p\n",i,&a[i]);
    }

    printf("a    = %p\n",a);      //利用数组名就是数组首地址性质
    printf("a+1  = %p\n",a+1);
    printf("a+2  = %p\n",a+2);
    printf("a+3  = %p\n",a+3);

    printf("*(a+0) = %d\n",*a);  //对地址取星是打印数据，*第二性质
    printf("*(a+1) = %d\n",*(a+1));
    printf("*(a+2) = %d\n",*(a+2));
    printf("*(a+3) = %d\n",*(a+3));

    return 0;
}

4、4_arry_P.c

#include <stdio.h>
int main(int argc, const char *argv[])
{
    char a[10] = "hello";
    char *p = a;    //类型：char *    变量名：p    

    printf("a[4]    = %c\n",a[4]);  // 打印a[4]的字符
    printf("*(a+4)  = %c\n",*(a+4));

    printf("p[4]    = %c\n",p[4]);
    printf("*(p+4)  = %c\n",*(p+4));

                                    //对上面进行取地址操作
    printf("a[4]    = %p\n",&a[4]);  
    printf("*(a+4)  = %p\n",&*(a+4));   //*&互为逆运算 抵消 &*(a+4) = (a+4)
    printf("a+4     = %p\n",a+4);

    printf("p[4]    = %p\n",&p[4]);
    printf("*(p+4)  = %p\n",&*(p+4));

    return 0;
}

5、5_atoi.c

#include <stdio.h>
#include <strlib.h>
int main()
{
    char a[] = "1256a69b";
    char *p  = a;       //定义指针：p  类型：char *  a是数组的首地址
    int sum = 0;        //定义一个整形，承接数值型字符串的整形
    while('0'<=*p && *p<='9')  //判断是否在'0'~'9'之间,此时*p是a[0]
    {
        sum = sum*10+*p-'0';    //每次循环检测出的值给位输出
        p++;                    // a[0]、a[1]、a[2]...地址
    }
    printf("sum = %d",sum);     //注意：a地址是地址常量，p是指针变量
    return 0;
}

6、6_PA.c

#include <stdio.h>
//
//指针数组：本质是数组，元素的类型是指针
int main(int argc, const char *argv[])
{
    int a = 10;
    int b = 30;

    int c[5] = {0,1,2,3,4};
    int* p[3];
    p[0] = &a;
    p[1] = &b;
    p[2] = c;   //c是数组c[5]的首地址

    //*p[0]~*p[2] 是 p[0]~p[2]地址的值
    printf("*p[0]    = %d\n",*p[0]);  
    printf("*p[1]    = %d\n",*p[1]);
    printf("*p[2]    = %d\n",*p[2]);

    printf(" c[3]    = %d\n",c[3]);
    printf("*(p[2]+3) = %d\n",*(p[2]+3));
    return 0;
}

7、 7_two_array.c

#include <stdio.h>
//
//验证a+1 与  a[0]+1区别
int main(int argc, const char *argv[])
{
    int a[3][4] = {{0,1,2,3},{4,5,6,7},{8,9,10,11}};
    int i,j;
    for(i=0; i<3; i++)
    {
        for(j=0; j<4; j++)
        {
            printf("%p  ",&a[i][j]);
        }
        putchar(10);
    }
    //指针加单位长度后，取内容算
    printf("a[1][2]     = %d\n", a[1][2]);  
    printf("*(a[1]+2)   = %d\n", *(a[1]+2));
    printf("*(*(a+1)+2) = %d\n", *(*(a+1)+2));

/*
    printf("a    = %p\n",a);        //a：行指针，加一移动一行
    printf("a+1  = %p\n",a+1);
    printf("a+2  = %p\n",a+2);

    //a[0] a[1] a[2]：列指针，加一移动一列
    printf("a[0]   = %p\n",a[0]);   
    printf("a[0]+1 = %p\n",a[0]+1);
    printf("a[0]+2 = %p\n",a[0]+2);
    printf("a[0]+3 = %p\n",a[0]+3);
*/

//  printf("a[1] = %p\n",a[1]);
//  printf("a[2] = %p\n",a[2]);

    return 0;
}

8、 8_PA.c

#include <stdio.h>

//指针数组：本质是数组，元素是指针
//int *p[3];   [3]必须与数组列保持一致

//数组指针：本质是指针，专用于指向数组（多数用于指向二维数组）
//定义：  类型（*p）[列数]；   int (*p)[3];

int main(int argc, const char *argv[])
{
    int a[3][4] = {{0,1,2,3},{4,5,6,7},{8,9,10,11}};
    int (*p)[4];
    p = a;              //p == a

    printf("a[1][2]     = %d\n", a[1][2]);  
    printf("*(a[1]+2)   = %d\n", *(a[1]+2));
    printf("*(*(a+1)+2) = %d\n", *(*(a+1)+2));

    //p：是指针变量  a：地址常量
    printf("p[1][2]     = %d\n", p[1][2]);      
    printf("*(p[1]+2)   = %d\n", *(p[1]+2));
    printf("*(*(p+1)+2) = %d\n", *(*(p+1)+2));

//  printf("size = %d\n",sizeof(p));

    return 0;
}

9、 9_const.c

#include <stdio.h>

//const int *p = &a; 或 int * const w = &a;
int main(int argc, const char *argv[])
{
    int a = 10;
    const int *p = &a;      //*p：只读    p可以操作 例：p = &a；
//  *p = 20;
    printf("*p = %d\n",*p);


    int x = 40;
    int y = 30;
    int * const w = &x;     //w：只读    *w可以操作 例：*w = 80；
//  w = &y;
    printf("*w = %d\n",*w);

    return 0;
}

10、10_str.c

#include <stdio.h>
#include <string.h>
#define N 50             //宏定义
int main(int argc, const char *argv[])
{
    char dest[N];  
    char src[] = "welcome";

    strcpy(dest,src);   //stc的字符串复制到dest
    printf("dest:%s ,src:%s\n",dest,src);

    char dest1[N] = "welcome";
    char src1[] = "beijing";

    strcat(dest1,src1);  //strcat：src1接到dest1
    printf("dest:%s,src:%s\n",dest1,src1);

    char dest2[N] = "welcome";
    char src2[] = "beijing";

    int i;
    i = strcmp(dest2,src2);
    printf("%d\n",i);

    char dest3[N] = "welcome";
    int j;
    j = strlen(dest3);
    printf("%d\n",j);

    return 0;
}