C语言学习分享/指针进阶

最新推荐文章于 2024-10-10 15:27:46 发布
最新推荐文章于 2024-10-10 15:27:46 发布
阅读量485 收藏
点赞数
文章标签： c语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Blemshining/article/details/123805481
版权

#define _CRT_SECURE_NO_WARNINGS 1

指针大小固定4/8个字节（32位/64位）
指针类型决定了指针+-的步长

#include <stdio.h>
int main()
{
    const char* p = "asdf";//"asdf"是常量字符串，要加const
    printf("%s\n", p);     //p存的是首元素地址，但%s会通过首元素打印字符串直到\0
    printf("%c", *p);      //*p存的是首元素
    return 0;
}
#include <stdio.h>
int main()
{
    char arr[] = "abcd";
    char brr[] = "abcd";
    const char* pa = "abcd";
    const char* pb = "abcd";
    if (arr == brr)
    {
        printf("哈哈\n");
    }
    else 
    {
        printf("呵呵\n");//虽然两个字符串一样，但其分别存在不同的空间，地址不同
    }

    if(pa==pb)
    {
        printf("哈哈\n");//因为是常量字符串不能被修改而且又一样，于是为了节省空间两个指针指向同一个空间
    }
    else
    {
        printf("呵呵\n");
    }
    return 0;
}//结果为呵呵 哈哈

**指针数组**

int main()
{
    int arr[10] = { 0 };//整形数组
    char brr[5] = { 0 };//字符数组
    int* parr[5];       //存放指针整形的数组--指针数组
    char* pbrr[6];      //存放指针整形的数组--指针数组

}
#include <stdio.h>
int main()
{
    int arr1[] = { 1,2,3,4,5,6 };
    int arr2[] = { 2,3,4,5,6,7 };
    int arr3[] = { 3,4,5,6,7,8 };
    int* p[] = { arr1,arr2,arr3 };
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 6; j++)
        {
            printf(" %d" ,* (p[i] + j));
        }
        printf("\n");
    }
    return 0;
}

**数组指针**

#include <stdlib.h>
int main()
{
    int* p = NULL; //p是整形指针-指向整形的指针
    char* m = NULL;//m是字符指针-指向字符的指针
    int arr[] = { 1,2,3,4,5 };
    int(*n)[5] = &arr;      //n是数组指针
    int* q[5] = { arr };    //q[5]是指针数组
    return 0;
}
 
int main()
{
    int arr[5];
    int(*pa)[5] = &arr;
    int* brr[5];
    int*(*pb)[5] =&brr;   //brr是int*类型
    return 0;             
}
#include <stdio.h>
void print(int arr[3][5], int r, int c)
{
    int i, j;
    for (i = 0; i < r; i++)
    {
        for (j = 0; j < c; j++)
        {
            printf("%-2d ",arr[i][j]);
        }
        printf("\n");
    }
}
void print2(int (* p)[5], int r, int c)
{
    int i, j;
    for (i = 0; i < r; i++)
    {
        for (j = 0; j < c; j++)
        {
            printf("%-2d ", (*(p + i))[j]); //--*(p+i)==p[i]==arr[i]
            printf("%-2d ", *(*(p+i)+j));   //--*(p[i]+j) -- arr[i][j] 
        }
        printf("\n");     
    }
}
int main()
{
    int arr[3][5] = { {1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15} };
    print(arr, 3, 5);   //数组名为首元素地址--{1，2，3，4，5}的地址
    print2(arr, 3, 5);  //传首元素地址，int(*p)[5]==&{1,2,3,4,5}
    return 0;           //当p加1时地址加1，于是跳到下个数组元素
}

**数组的传参**

一维数组传参
#include <stdio.h>
void tset1(int arr)   //err
{}
void tset1(int arr[]) //正确
{}
void tset1(int arr[10])//正确
{}
void tset1(int* arr)   //正确
{}

void test2(int* arr[100]) //err
{}
void test2(int* arr[100]) //正确
{}
void test2(int** arr)     //正确
{}
int main()
{
    int arr1[10];
    int *arr2[100]; 
    test1(arr1);
    test2(arr2);
    return 0;
}二维数组的传参

#include <stdio.h>
void test(int arr[3][5]) {}//正确
void test(int arr[][5]) {} //正确
void test(int arr[3][]) {} //err
void test(int arr[][]) {}  //err

void test(int* arr) {}   //err，数组的地址不能用整形的指针存储
void test(int** arr) {}  //err，二级指针是用来存放整形地址的指针 的地址的指针
void test(int* arr[5]) {}//err
void test(int(*arr) [5]) {}  //正确

int main()
{
    int arr[3][5];
    test(arr);    //传过去时第一行的数组的地址,要用存放数组地址的指针
    return 0;
}

二级指针的传参

void test(char** p)
{}
 
int main()
{
    char a = 'a';
    char* pa = &a;
    char** pb = &pa;
    char* arr[10];
 
    test(&a); //err
    test(&pa);//ok 
    test(pb);//ok
    test(arr);//ok 首元素的地址是指针的地址
    return 0;
}

函数指针

#include <stdio.h>
int add(int x, int y)
{
    return x + y;
}
int main()
{
    int a = 10;
    int b = 12;
    int arr[5];

    printf("%d\n", add(a, b));
    printf("%p\n",add);
    printf("%p\n", &add); //函数名 与 &函数名 都是函数的地址

    int(*pa)[5] = &arr;
    int(*pb)(int x,int y) = &add; //函数的地址类似于数组的地址
    int(*pc)(int , int ) = add;   //下，y，&可以去掉

    printf("%d\n",(*pb)(a,b));//结果为5，对函数的地址解引用
    printf("%d\n",(**pb)(a,b));
    printf("%d\n",(***pb)(a,b));
    printf("%d\n",(pb)(a,b));   //都是一样的，这里的*是摆设，但有意义
    return 0;
}
  


两个“有趣”的代码

1.(*(void(*)()0)();
   void(*)()--函数指针类型   int a; char *p=(char*)&a;
   void(*)()0--把0强制类型转化为void(*)()函数指针类型，0是函数的地址
   *(void(*)()0--对地址解引用
   (*(void(*)()0)()；--调用0地址处内的 参数为无参，返回类型为void的一个函数
  
2.void (*signal(int,void(*)(int)))(int)；
   (int,void(*)(int))--两个函数参数，第二个参数类型为函数指针类型
   void (*.....)(int);--定义函数指针类型
   void (*signal(int,void(*)(int)))(int)；
     --signal是一个函数声明，有两个参数，第一个是int，第二个是函数指针，该函数指针指向的函数
                                                      有一个参数，是int类型，返回类型是void。
     --signal函数返回类型也是一个函数指针，该函数指针指向的函数的参数是int 返回类型是void


函数指针的数组

#include <stdio.h>
int add(int x, int y)
{
    return x + y;
}
int sub(int x, int y)
{
    return x - y;
}
int mul(int x, int y)
{
    return x * y;
}
int div(int x, int y)
{
    return x / y;
}
int main()
{
    int(*pa)(int, int) = add;
    int(*p[4])(int, int) = { add,sub,mul,div };//函数指针的数组
    int i;
    for (i=0;i<4;i++)
    {
        printf("%d\n",p[i](2,3));
    }
    return 0;
}

练习
写一个函数指针pf指向my-strcpy  char*my_strcpy(char*a,cahr*b);
写一个函数指针数组pfarr，能够存放4个my_strcpy函数的地址
char* my_strcpy(char* a, char * b)
{
    return 0;
}
int main()
{
    char* (*pf)(char*, char*) = my_strcpy;
    char* (*pfarr[4])(char*, char*) = {my_strcpy,my_strcpy,my_strcpy,my_strcpy};
    return 0;
}

使用函数指针数组设计计算机程序

#include <stdio.h>
void menu()
{
    printf("1.加 2.减 3.乘 4.除以 0.exit\n");
}
int add(int x,int y)
{
    return x + y;
}
int sub(int x, int y)
{
    return x - y;
}
int mul(int x, int y)
{
    return x * y;
}
int div(int x, int y)
{
    return x / y;
}
int main()
{
    menu();
    int input;
    do
    {
        printf("请选择：\n");
        scanf("%d", &input);
        int (*p[5])(int, int) = { 0, add,sub,mul,div };
        if (1 <= input && input <= 4)
        {
            printf("请输入操作数：\n");
            int x, y;
            scanf("%d%d", &x, &y);
            int a = (*p[input])(x, y); //(*p[1])(x, y)是add（第二个元素）
            printf("结果是：%d\n", a);
        }
        else if (input == 0)
        {
            printf("已退出\n");
        }
        else
            printf("输入错误，请重新输入：\n");
    } while (input);
}


指向函数指针数组的指针

#include <stdio.h>
int add(int x,int y)
{
    return x + y;
}
int main()
{
    int arr[10];
    int(*p)[10] = &arr;  //数组指针，指向数组

    int (*pa)(int, int) = &add;
    int (*pb[4])(int, int) = {&add,&add,&add,&add};//函数指针的数组
    int(*( (*pc)[4]) )(int, int) = &pb;//pc是数组指针，指向的类型是函数指针int(*)(int,int)
                                       //要把pb的地址存起来，要用数组指针，在pc前加*并括号
    return 0;

}

回调函数--是一个通过函数指针调用的函数。如果把函数的指针（地址）作为参数传递给另一个函数，
    当这个指针被用来调用其指向函数时，称其为回调函数

 #include <stdio.h>
void print1(char arr[])
{
    printf("speak:%s\n",arr);
}
void test1(void(*pt)(char brr[]))
{
    char a[] = "haha";
    printf("hello\n");
    pt(a);
}
void print2(const char *p)
{
    printf("speak:%s\n", p);
}
void test2(void(*pt)(const char*))
{

    printf("hello\n");
    pt("haha");             //指向常量字符串的指针要加const
}
int main()
{
    test1(print1);
    test2(print2);
    return 0;
}


 
 设计计算机程序

#include <stdio.h>
void menu()
{
    printf("1.加 2.减 3.乘 4.除以 0.exit \n");
}
int add(int x,int y)
{
    return x + y;
}
int sub(int x, int y)
{
    return x - y;
}
int mul(int x, int y)
{
    return x * y;
}
int div(int x, int y)
{
    return x / y;
}
void Back(int(*p)(int , int ))
{
    printf("请输入操作数：\n");
    int x, y;
    scanf("%d%d",&x,&y);
    printf("结果为：%d\n\n",p(x,y));
}
int main()
{
    menu();
    printf("\n");
    int input;
    do 
    {
        printf("请输入：\n");
        scanf("%d", &input);
        switch(input)
        {
           case 1:
              Back(add);
              break;
           case 2:
               Back(sub);
               break;
           case 3:
               Back(mul);
               break;
           case 4:
               Back(div);
               break;
           case 0:
               printf("已退出\n");
               break;
           default:
               printf("输入错误，请重新输入:\n");
               break;
        }
    } 
    while (input);
    return 0;
}

冒泡排序

#include <stdio.h>
int bubble_sort(int brr[],int s)
{
    int i;
    for (i = 0; i < s - 1; i++)   //给每一趟排序
    {
        int b;
        int h = 1;//假设这一趟完全有序
        for (b = 0; b < s - 1 - i; b++) //给每个元素进行交换
        {if (brr[b] > brr[b + 1])
            { 
                int c = brr[b];        
                brr[b] = brr[b + 1]; 
                brr[b + 1] = c; 
                h = 0;
            }
        }
        if (h == 1) 
            break; 
    }    
    return 0;
}
int main()
{
    int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
    int s = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr,s);
    int i;
    for (i = 0; i < s ; i++)
        printf("%d ",arr[i]);
    return 0;
}

上述方法是int类型的适用范围小，使用回调函数优化
qsort--库函数-快速排序quick sort
查c函数库,属于<stdlib.h>
void qsort(void* base, size_t num, size_t size, int (*compare)(const void*, const void*));
 第一个参数：待排序数组首元素地址
 第二个参数：待排序数组的元素个数
 第三个参数：待排序数组每个元素大小，单位是字节
 第四个参数：是函数指针
void*（无类型指针） 可以接受任意类型的地址（int*,char*,longlong*）
void* 类型的指针不可以进行解引用操作，可以强制类型转换后解引用
void* 类型的指针不可以进行加减操作
 

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int cmp_int(const void* a, const void* b)  //比较两个整形
{
    return *(int*)a - *(int*)b;//返回负数或0则把a放到b前，返正则a放b后，是小到大排序
}
int cmp_float(const void* a, const void* b)  //比较两个浮点型
{
    return *(float*)b - *(float*)a;  //返回负数就把b放a前，是大大到小排序
}

struct stu       
{
    char name[10];
    int age;
};
int cmp_str_age(const void* a, const void* b)
{
    return ((struct stu*)a)->age - ((struct stu*)b)->age ; //比较年龄
}
int cmp_str_name(const void* a, const void* b)
{
    return strcmp(((struct stu*)a)->name , ((struct stu*)b)->name); //比较字符串用strcmp
}                            //相同则返回0，不同则比较首个不同字符的大小，小于返回-1

//自定义可实现多类型的冒泡排序
void swap(char* a, char* b, int size)
{
    int i;
    for (i = 0; i < size; i++)
    {    //比如把int类型的(00 00 00 01)和（00 00 00 02）交换
         //就把转换的4个char类型的依次交换
        char  x = *a;
        *a = *b;
        *b = x;
        a++;
        b++;
    }
}
void bubble_sort(void* base, int num, int size, int (*cmp)(const void*,const void*))
{
    int i, j;
    for (i = 0; i < num - 1; i++)
    {
        for (j = 0; j < num - 1 - i; j++)
        {
            if (cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)
               //char*类型的指针加1移动1字节地址，加上j * size就移动了本来一个元素的地址
            {
                swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
            }
        }
    }
}

int main()
{
    int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
    float brr[] = { 11.2,3.32,3.5,2.3,21,4.32,3};
    struct stu crr[3] = { {"Alice",20},{"Fieona",16},{"Lucy",18} };

    int s1 = sizeof(arr) / sizeof(arr[0]);
    int s2 = sizeof(brr) / sizeof(brr[0]);
    int s3= sizeof(crr) / sizeof(crr[0]);

    qsort(arr ,s1, sizeof arr[0], cmp_int );
    qsort(brr, s2, sizeof brr[0], cmp_float);

    int i;
    for (i = 0; i < s1; i++)
        printf("%d ",arr[i]);
    printf("\n");
    int j;
    for (j = 0; j < s2; j++)
        printf("%f ", brr[j]);
    printf("\n");

    qsort(crr, s3, sizeof crr[0], cmp_str_age);
    int k;
    for (k = 0; k < s3; k++)
    {
        printf("%s %d ", crr[k].name ,crr[k].age);//根据年龄对整个数组排序后输出
    }                        
    printf("\n");

    qsort(crr, s3, sizeof crr[0], cmp_str_name);
    for (k = 0; k < s3; k++)
    {
        printf("%s %d ", crr[k].name, crr[k].age);
    }
    printf("\n");

    bubble_sort(crr, s3, sizeof crr[0], cmp_str_age);
    for (k = 0; k < s3; k++)
    {
        printf("%s %d ", crr[k].name, crr[k].age);
    }
    return 0;
}

Minoky
关注
C语言——指针（进阶版）
weixin_59796310的博客
02-01 1万+
C语言——指针（进阶版）
C语言头歌:指针进阶
weixin_65370416的博客
02-26 896
个学生的成绩，成绩都为整数，用指针函数求出若干个学生成绩的最高分。####相关知识（略） ####编程要求 请仔细阅读右侧代码，结合相关知识，在。个位置 ####相关知识（略） ####编程要求 请仔细阅读右侧代码，结合相关知识，在。题目描述:采用指针变量表示地址的方法输入输出数组中的个元素。输出最高分，占一行。用指针变量表示地址的方法输出数组中的各个元素。请仔细阅读右侧代码，结合相关知识，在。开始你的任务吧，祝你成功！开始你的任务吧，祝你成功！开始你的任务吧，祝你成功！区域内进行代码补充。
C语言—指针进阶（详解）
m0_63601181的博客
05-07 791
大家好，我是Abert，这篇文章跟大家分享指针的高阶内容。众所周知，指针堪称C语言的灵魂，掌握指针是学好C语言的关键。 这篇文章建立在上篇（初阶指针)文章的基础上进行的，建议大家配合上篇文章一起食用效果更佳。 文章目录 1.指针数组 1.1字符指针数组 1.2整形指针数组 2.数组指针 3.函数指针 4.函数指针数组 5.结构体指针 6.指针进阶题目 正文 1.指针数组 指针数组是数组，数组内存放的是指针 1.1字符指针数组 存放字符指针...
还在因为指针头大吗，6000字的白话让你掌握字符指针/指针数组/数组指针的用法【C语言/指针/进阶/程序员内功修炼】【上】
Man9o
03-07 6982
还在因为指针头大吗，6000字的白话让你掌握字符指针/指针数组/数组指针的用法，看不懂来打我！！
通过模拟实现计算器介绍函数指针数组和回调函数的用法【C语言/指针/进阶】
Man9o
03-12 1426
通过模拟实现计算器掌握函数指针数组的用法
C语言进阶——指针进阶试题讲解（万字长文详解）
北 海的博客
09-11 3157
指针，一块存储其他内存块地址的空间，不仅能监管别人的地址信息，还拥有属于自己的地址。在取地址操作符(&)与解引用操作符(*)的“双重折磨”下，很多人对指针望而生畏，常常会掉进不规范使用指针而引发错误的大坑中。本文旨在通过众多例子来带大家理解指针（主要包含sizeof、strlen和多道指针笔试题），本文篇幅可能较长，请系好安全带，跟我走！
C语言学习之指针进阶
linglingq07的博客
10-07 201
指针数组：int * p[10]，其中p先与[10]结合，是一个数组，数组中的每个元素的类型是int * （整型指针） 数组指针：int (*p)[10]，由于()比[]优先级高，p先与*结合，p为一个指针，指向指向一个int [10]的数组（即一个包含10个整型元素的数组） 函数指针：int (*p)(int, int)，首先p是一个指针，指针指向的是一个函数，函数类型为int (int, int)，即函数的两个参数为int型，返回值类型也为int型 函数指针数组：int (*p[4])(int, in.
C语言大步前进：指针进阶讲解
weidl001的博客
03-02 749
本文深入探讨了C语言中的指针概念，阐述了指针的定义、使用方法、与数组、函数的交互，以及如何通过指针进行动态内存管理。首先回顾了指针的基本概念，包括声明、初始化和解引用操作。随后，通过实例展示了指针在内存操作、函数参数传递、以及与数组的关系中的应用，突出了指针提高程序效率和灵活性的能力。特别地，介绍了动态内存分配和指向指针的指针，进一步加深了对复杂数据结构处理的理解。最后，通过具体的编程实例，如数组处理和函数参数传递，展示了如何在实际编程中应用指针知识。文章旨在通过理论与实践的结合，帮助读者更好地掌握C语言。
C语言---指针进阶
binhyun的博客
02-16 813
字符指针，指针数组，数组指针，二维数组传参
C语言进阶——指针进阶
07-09 984
C语言指针进阶一、字符指针 指针的初阶我们可以参看这篇博客C语言初阶——指针 ，这篇博客主要有四个重要结论，也是初阶指针的重要概念： 1. 指针是地址，指针变量是一个变量，用来存放内存单元的地址，通过指针能找到以它为地址的内存单元。 2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。 3. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。 4. 指针的运算。 下面我们将继续探讨指针的进阶部分 一、字符指针 在2.1指针的类型中我们知道有一种指针类型为字符指针 ch
c语言学习书籍介绍(进阶篇).doc
12-23
对于指针的理解是C语言进阶的重要部分，这本书深入讲解了指针的使用，包括指针与数组、函数、结构体的关系，以及多级指针和指向指针的指针等复杂概念。 5. **《C++ Primer Plus》** (尽管书名中有C++) - Stephen ...
C语言指针进阶第1课.pdf
06-16
C语言指针进阶 一、C语言中的对象概念 C语言中确实有对象（Object）这个概念。对象是指程序中可以被操作的实体，例如变量、数组、结构体等。理解对象是理解C语言的核心基础概念。 二、指针的概念 指针是C语言中...
【C语言-进阶】指针进阶
TPON的博客
03-04 6427
c进阶 - 指针进阶
C语言基本概念
ROBIN__dyc的博客
10-03 784
标识符：编写程序时，需要对变量、函数、宏和其他实体进行命名，这些名字称为标识符。函数是C语言中构建程序的构建块，事实上，C语言是函数的集合。函数分为两大类，一类是程序员编写的函数，一类是作为C语言实现的一部分提供的函数，即库函数。所有指令都是以字符#开始的，默认只占一行，每条指令的结尾没有分号或其他特殊标记。int 型变量取值的范围是有限的，通常为-2³¹～2³¹-1，但某些计算机上最大整数可能只有32767。语句是程序运行时执行的命令，C语言规定每条语句都要以分号结尾（复合语句是例外）。
C 共用体
lly202406的博客
10-10 338
在C语言中，共用体使用union关键字定义。共用体的所有成员共享同一块内存空间，这意味着在任何时刻，共用体只能存储其中一个成员的数据。// ...其中，union_name是共用体的名称，type是成员的数据类型，member1member2等是共用体的成员。
关于通信方式的一些自我学习（uart、i2c、spi的一些最底层的逻辑以及运用方式）STM32F407上的一些实际日常应用
weixin_60991529的博客
10-08 1188
首先其工作原理是将数据以串行方式进行发的，接收的时候将数据转换为并行数据。利用异步通信所以不需要时钟线适用于不同芯片、芯片对模块之间的控制。因此需要设置好波特率（115200、9500）数据位、停止位、奇偶效验位。
深度学习每周学习总结J1（ResNet-50算法实战与解析 - 鸟类识别）
qq_33489955的博客
10-04 1317
数据导入及处理部分：本次数据导入没有使用torchvision自带的数据集，需要将原始数据进行处理包括数据导入，查看数据分类情况，定义transforms，进行数据类型转换等操作。划分数据集：划定训练集测试集后，再使用torch.utils.data中的DataLoader()分别加载上一步处理好的训练及测试数据，查看批处理维度.模型构建部分：resnet-50。
从零开始学习PX4源码7(hello world)
最新发布
陌城烟雨
10-10 223
本节主要记录如何在PX4中创建一个应用程序hello world 的过程，具体可以参考官网hello sky的过程hello sky。
jmeter学习（7）beanshell
daxiashangxian的博客
10-06 532
打开日志选项，beanshell的log可以在日志中查看log.info("deviceId"）举例：获取返回数据中的字段。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值