指针C语言基础代码总结

《charpointer》

字符指针

demo1.c
字符指针的初始化及赋值

#include 

int main(int argc, char *argv[])
{
        char ch = 'A';               //字符变量

        char * p;

        p = &ch;                       //指针等于变量取地址

        printf("%c %c\n", ch, *p);

        return 0;
}

上下两个程序联合想明白，指针 1. 直接指向字符串
2. 指针指向字符数组
两种赋值方法需要注意的问题

demo2.c

字符数组初始化字符指针

#include 
#include 

int main(int argc, char *argv[])
{
        char ch1[] = "hello World!";             //字符数组
        char ch2[] = "hello World!";             // 两个字符串在内存中的不同位置
                                     //同一个指针可以指向两个不同的字符串数组，且可以通过指针对字符串数组中的内容进行修改
        char * p;

        p = ch1;
        //ch1[0]---*(ch1+0)----p[0], *p
        if(isalpha(*p)) {                            // 判断字母
                if (isupper(*p))                     // 大写
                        *p = tolower(*p);            // 转小写
                else
                        *p = toupper(*p);            //转大写
        }
        printf("%p %s\n", p, p);                     

        p = ch2;
        printf("%p %s\n",p, p);

        return 0;
}

demo3.c

重要

#include 
#include 

int main(int argc, char *argv[])
{
        char * p1 = "hello World!";         // 字符指针指向一个字符串常量，指针存储了字符串常量的起始地址，那么就不能通过指针去修改字符串中的内容，因为字符串的地址确定后不能改变（字符串实际放到了一个固定的区域，静态存储区，这个地方的值不能修改）
        char * p2 = "hello World!";             

        *p1 -= 32;           //不能这样使用，会出现段错误

        printf("&p1=%p %p %s\n", &p1, p1, p1);   // 不同的指针有自己的地址，但指向的是同一个地址   p1、p2是局部变量，存放在栈中，“全局变量，static修饰的局部变量，字符串常量”，三种情况数据存放在静态区，这个区域是程序结束时才释放内存，一旦分配后永远占据内存

        printf("&p2=%p %p %s\n", &p2, p2, p2);    

        return 0;
}

demo4.c
解释的依然是上面程序中遇到的问题

#include 
#include 

int main(int argc, char *argv[])
{
        char ch[50] = "welcome";
        char * p1 = "hello World!";
        
        strcpy(ch, p1);
       // strcpy(p1, ch);          // 错误  p1指针指向的是一个字符串，不能被改变 

        puts(ch);
        puts(p1);

        return 0;
}

demo5.c

不利用任何字符串函数，编程实现字符串连接函数功能 ( 重要 )

#include 
//#include 

int main(int argc, char *argv[])
{
        char ch[100] = "welcome";
        char * p = "hello World!", * q;
        int i = 0;

        q = p;

        while (*(ch+i) != '\0') 
                i++;

        while (*p != '\0') {
                *(ch+i) = *p;
                i++;
                p++;
        }
        *(ch+i) = *p;

        p = q;
        puts(ch);
        puts(p);

        return 0;
}

先学习

《pointer》
指针的基本使用和理解
d1.c

#include 

int main(int argc, char *argv[])
{
        int a = 10;
        int * p;
        int * q;

        p = &a;                                  //指针存放的是变量的地址
        //q = &a;   
        q = p;                                   //指针之间可以相互赋值

        printf("&p:%p %d\n", &p, sizeof(p));     //指针所存放的字节数
        printf("%p %p\n", p, &a);
        printf("%d %d\n", a, *p);                //*p 即变量 a 所指代的内容

        printf("\n\n&q:%p %d\n", &q, sizeof(q));  // 变量 变量的地址 指针存储变量的地址 指针的地址           p 和 q 的地址不同，原因是变量不同，其分配的内存空间也不同，但p和q存储的数据相同--a地址
        printf("%p %d\n", q, *q);

        return 0;
}

d2.c

#include 

int main(int argc, char *argv[])
{
        double a;
        double * p;

        p = &a;

        printf("%d %d %p\n", sizeof(double), sizeof(p), p);     // 指针所占字节数和电脑系统是32位还是64位有关系，32位，每个指针占4个字节

        return 0;
}

d3.c

指针的运算

#include 

int main(int argc, char *argv[])
{
        int a = 10, * p;
        double b = 3, * q;

        p = &a;
        q = &b;

        printf("%p %p\n", p, p+2);             // +2越过2个数据，每个数据4个字节，那就是在首地址的基础上+8
        printf("%p %p\n", q, q+2);

        return 0;
} 

d4.c

#include 

int main(int argc, char *argv[])
{
        int a[5] = {4, 8, 1, 2, 7};
        int *p, * q;

        p = a; //&a[0];
        q = &a[3];
        
        printf("%p %p\n", p, q);
        printf("%d %d\n", *p, *q);
        printf("%d\n", q-p);                     //两个指针相减表示两指针之间相隔的数据的个数

        return 0;
}

d5.c
指针++

#include 

int main(int argc, char *argv[])
{
        int a[5] = {4, 8, 1, 2, 7};
        int *p = NULL, *q;              // 指针和 0 进行等于或不等于的关系运算，判断指针是否为空

        printf("%d %p\n", p, p);        // 0（nil）
        p = a; //&a[0];
        
        printf("%p %d\n", p, *p);

        q = p++;

        printf("%p %d\n",p, *p);               //到这p已+1
        printf("%p %d\n",q, *q);


        return 0;
}

结果：

d6.c

第一次循环通过指针给数组赋值，给最后一个元素赋完值后，指针变量指到数组后的内存单元，此时已经超出了数组的大小限制，所以在第二次循环打印出的时候，需要重新 修正p = a;

#include 

#define N 5
int main(int argc, char *argv[])
{
        int a[N];
        int *p, i;
        
        p = a;//int *p = a;
        for (i = 0; i < N; i++) 
                scanf("%d", p++);//&a[i]

        p = a;
        for (i = 0; i < N; i++)  {
                printf("%d ", *p);    //可以写为*p++    （++的优先级高于 * 的优先级）
                p++;
        }
        puts("");


        return 0;
}

d7.c

#include 

#define N 5
int main(int argc, char *argv[])
{
        int a[N];
        int *p, i;
        
        p = a;//int *p = a;
        for (i = 0; i < N; i++) 
                scanf("%d", p++);//&a[i]

        p = a;
        for (i = 0; i < N; i++)  {
                printf("%d ", *p++);
        }
        puts("");


        return 0;
}

d8.c

数组和指针结合
指针指向数组的起始地址，数组是一串连续的空间，指针++就可以访问数组中每个元素的值

#include 

int main(int argc, char *argv[])
{
        int a[] = {1, 6, 9, 12, 61, 12, 21};
        int *p, i, n;
        
        p = a;
        n = sizeof(a) / sizeof(int);

        printf("%p %p %p\n", a, a+1, a+2);

        for (i = 0; i < n; i++)
                printf("%d %d %d %d\n", a[i], *(p+i), *(a+i), p[i]);   //四种等价方式的运用
        puts("");              //输出换行符的方式

        p++;

        printf("%d\n", p[1]);//*(p+1)

        return 0;
}

上面四种等价方式的直观图解
数组名也是一个地址，只不过是地址常量，其+1也可以实现地址移动

d9.c
将整形数组中n个数按反序存放

#include 

int main(int argc, char *argv[])
{
        int a[] = {1, 6, 9, 12, 61, 12, 21};
        int *p, *q, n, t;

        n = sizeof(a) / sizeof(int);

        p = a;
        q = &a[n-1];

        while (p < q) {
                t = *p;
                *p = *q;
                *q = t;
                p++;
                q--;
        }
        
        for (t = 0; t < n; t++)
                printf("%d ", a[t]);
        puts("");


        return 0;
}

d10.c

指针与二维数组
使用一级指针遍历二维数组

#include 

int main(int argc, char *argv[])
{
        int a[3][2] = {{1, 6}, {9, 12}, {61, 12}};
        int * p, i, n;

        n = sizeof(a) / sizeof(int);

        p = a[0]; //&a[0][0];
        printf("%p %p\n", p, p+1);                   // 指针p+1 一次只加一个数据，但是（a+1）数组名+1，一次加的是一行的数据
        printf("%p %p\n", a, a+1);

        for (i = 0; i < n; i++)
                printf("%d ", *(p+i));         // 二维数组遍历要使用两层循环，但使用指针，只需要一层  printf("%d\n",a[i][j]); 相同，注意四种通用的方法，即用数组的遍历方法，根据其和指针之间等价的表达关系，利用指针去遍历
        puts("");
        
        return 0;
}

d11.c

#include 

int main(int argc, char *argv[])
{
        int a[3][2] = {{1, 6}, {9, 12}, {61, 12}};
        int * p, i, n;

        n = sizeof(a) / sizeof(int);

        //a[1]++;                                 数组名是常量，不能做算数运算
        //printf("%d\n", sizeof(a[1]));           a[1]也代表的是数组名

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

        for (i = 0; i < n; i++)
                printf("%d ", *(p+i));
        puts("");


        return 0;
}

d12.c

#include 

int main(int argc, char *argv[])
{
        int a[3][2] = {{1, 6}, {9, 12}, {61, 12}};
        int * p, i, n;

        n = sizeof(a) / sizeof(int);

        printf("%p %p\n", a, a+1);
        //printf("%p %p\n", a[0], a[0]+1);   a[0]指二维数组中第一个一维数组名，a[0]+1 指一维数组a[0]中的下一个数据，这个地方可以解释上面一个程序图片中的内容，
       // a[0] + 1 = *(a + 0) + 1;
        printf("%p %p\n", *a, *a+1);  // 等价 printf("%p %p\n", a[0], a[0]+1);


        return 0;
}

d13.c

行指针

#include 

int main(int argc, char *argv[])
{
        int a[3][2] = {{1, 6}, {9, 12}, {61, 12}};
        int (*p)[2], i, j;                 //定义方式

        p = a;

        printf("%p %p\n", a, a+1);
        printf("%p %p\n", p, p+1);         //定义行指针这样表示，p+1 和 a+1 所移动的地址就是相同的

        //printf("%d, %d, %d, %d\n", a[1][1], p[1][1], *(*(a + 1)+1), *(*(p + 1) + 1));
        for (i = 0; i < 3; i++) {
                for (j = 0; j < 2; j++)
                        printf("%d, %d, %d, %d ", a[i][j], p[i][j], *(*(a + i)+j), *(*(p + i) + j));                   //不是很理解真正的用处在哪，感觉差不多
                puts("");
        }


        return 0;
}

《指针二 parray》

指针数组

初始化
demo1.c

#include 

int main(int argc, char *argv[])
{
        int * p[3];//int *     --   p[0] p[1] p[2]
        int a[] = {3, 6, 1, 9, 10};

        p[0] = a;
        p[1] = a + 1;
        p[2] = a + 3;


        printf("%d %d %d\n", a[0], a[1], a[3]);
        printf("%d %d %d\n", *(p[0]), *(p[1]), *p[2]);


        return 0;
}

demo2.c

指针数组常和二维数组结合使用

#include 

int main(int argc, char *argv[])
{
        int a[2][3] = {{1, 4, 6}, {12, 9, 7}};//a----a[0]   a[1]

        int * p[2];


        p[0] = a[0];//&a[0][0] 
        p[1] = a[1];//&a[1][0]

        printf("%d\n", a[0][1]);
        printf("%d\n", *(a[0]+1));
        printf("%d\n", *(p[0]+1));     //上下两行是等价的表达方式

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



        return 0;
}

demo3.c

#include 

int main(int argc, char *argv[])
{
        int a[2][3] = {{1, 4, 6}, {12, 9, 7}};//a----a[0]   a[1]
        int * p[2] = {a[0], a[1]};
        int i, j;


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

        for (i = 0; i < 2; i++) {
                for (j = 0; j < 3; j++) 
                        //printf("%d %d ", *(a[i] + j), *(p[i]+j));
                        printf("%d %d ", *(*(a+i) + j), *(*(p +i)+j));   //这个地方和二维数组遍历是相同的，只不过使用了等价的表达方式
                puts("");
        }


        return 0;
}

demo4.c

利用指针数组处理二维数组，要求求出二维数组所有元素的和

#include 

int main(int argc, char *argv[])
{
        int a[2][3] = {{1, 4, 6}, {12, 9, 7}};//a----a[0]   a[1]
        int * p[2] = {a[0], a[1]};
        int i, j, sum = 0;

        int *  * q;

        q = p;//&p[0]                      //指针数组名是指针地址，一级指针取地址，相当于二级指针

        printf("total:%d\n", sizeof(p));                   //如何计算指针数组占用多少空间，指针的个数 * 指针占用的字节数
        //指针数组名加1，移动多少字节？           指针数组名 + 1就是移动了一个指针，即移动了一个指针所占用的字节数
        //
        //printf("%p %p\n", p[0], a[0]);
        //printf("%p %p\n", p[1], a[1]);

        for (i = 0; i < 2; i++) {
                for (j = 0; j < 3; j++) 
                        sum += *(p[i]+j);
                        //printf("%d %d ", *(a[i] + j), *(p[i]+j));
                     //   printf("%d %d ", *(*(a+i) + j), *(*(p +i)+j));
                //puts("");
        }

        printf("sum=%d\n", sum);

        return 0;
}

《 pp 》

多级指针
二级指针
demo1.c

#include 

int main(int argc, char *argv[])
{
        int m = 10;
        int * p;

        //....   * q;
        int* * q;

        p = &m;

        q = &p;

        printf("%p %p\n", p,&m);
        printf("%p %p\n", q,&p);
        printf("%d %d %d\n", m, *p, **q);

        printf("%p %p\n", q, q + 1);    //二级指针 + 1 就是移动一个一级指针，一个一级指针占4个字节

        return 0;
}

demo2.c
多级指针和指针数组和二维数组结合到一起

#include 

int main(int argc, char *argv[])
{
        int a[] = {3, 6, 9};
        int * p[2] = {&a[0], &a[1]};//int * ---  p[0]  p[1]

        int ** q;

        q = &p[0];//p
        q = p;

        printf("%d %d\n", a[0], a[1]);
        printf("%d %d\n", *p[0], *p[1]);

        printf("%d %d %d\n", a[0], *p[0], **q);
        printf("%d %d %d\n", a[1], *p[1], **(q+1));  //这个地方一级指针指向的是一维数组，所以指向它的二级指针 +1 移动的是一个元素，但如果其表示的是二维数组，那么+1 就代表经过了一行的元素





        return 0;
}

demo1.c
利用二级指针输出字符串数组

#include 

int main(int argc, char *argv[])
{
        //char * s1 = "apple";
        //char * s2 = "pear";
        char * s[] = {"apple", "pear", "potato"};
        char ** p;
        int i, n;

        i = 0;
        n = sizeof(s) / sizeof(char *);
        p = &s[0];//p = s;

        while (i < n){
                printf("%s %s\n", s[i], *(p + i));
                i++;
        }

        return 0;
}

《void_const》

const1.c

#include 

int main(int argc, char *argv[])
{
        const int m = 10;

        m++;                               // const 声明的变量值是常量的值，不能改变

        return 0;
}

const2.c
const 修饰的两个位置需要注意的点

1. 在 * 前，不能修改其目标的数值，但可以改变变量存储的地址值
2. 在 * 后，不能修改指针的初始化地址值，但可以改变指针指向变量的数据值

#include 

int main(int argc, char *argv[])
{
         int m = 10;
         const int * p;            // 使用const修饰指针，不能通过指针改目标的数值，但指针变量存储的地址值可以修改
         int * const q = &m;       //const 在 * 号后面，只能在定义时立即初始化，后续不可对该指针再次赋值
         const int * const r = &m;       //即地址值和数据值都不能改变
         
         p = &m;//right;                //地址可以改变

         //(*p)++; error;                //常量化指针目标是限制通过指针改变其目标的数值 ，但<指针变量>存储的地址值可以修改

         //q = &m; error;        使得<指针变量>存储的地址值不能修改。但可以通过 *<指针变量名称> 可以修改指针所指向变量的数值
         *q = 20;//right                     //指针指向变量的值可以改变

         r++;                  //地址值不能改变
         (*r)++                //数据值不能那个改变

        return 0;
}

demo1.c

void指针

#include 

int main(int argc, char *argv[])
{
        int m = 10;
        double n = 3.14;
        void * p, * q;

        p = &m;//(void *)&m;
        printf("%d %d\n", m, *(int *)p);    //直接使用printf("%d ",*p); 由于 *p 是 void 指针类型，编译器无法以void 指针类型去取 m 整型变量的值，所以需要在使用void指针类型的时候，需要使用强制类型转换
        printf("%p\n", p);
        p++;               // void指针在没有进行强制运算之前，不能进行运算
        printf("%p\n", p);

        q = &n;//(void *)&n;
        printf("%.2lf %.2lf\n", n, *(double *)q);
        printf("%p\n", p);
        q++;
        printf("%p\n", q);




        return 0;
}

demo2.c
void指针访问一维数组

#include 

int main(int argc, char *argv[])
{
        int a[] = {5, 9, 1, 6, 9, 10};
        int i, n;
        void * p;           //使用不确定数据类型的void指针和确定数据类型的普通指针来对比，用法差不多，只不过最后输出的时候或进行运算的时候，需要进行强制类型转换

        p = a;
        n = sizeof(a) / sizeof(int);
        for (i = 0; i < n; i++) 
                printf("%d ", *((int *)p + i));
        puts("");

        return 0;
}

demo3.c

#include 

int main(int argc, char *argv[])
{
        int a[] = {5, 9, 1, 6, 9, 10};
        int i, n;
        void * q;
        int * p;

        q = a;
        p = (int *)q;             //void指针转换成普通指针的使用方法
        n = sizeof(a) / sizeof(int);
        for (i = 0; i < n; i++) 
                printf("%d ", *(p + i));
        puts("");

        return 0;
}

main.c

#include 

int main(int argc, const char * argv[]) {
        //const char * argv[] = {"./a.out", "192.168.1.5", "9999"};
        int i;

        printf("argc=%d\n", argc);

        for (i = 0; i < argc; i++) {
                printf("%s\n", argv[i]);
        }

        return 0;
}