高级c语言（三）

m0_631270402024-09-17 23:18

指针的进步值与指针的运算：

指针变量里面存储的是整数，代表内存的编号（每个整数都对应一字节的内存）。

指针的进步值：

指针变量中存储的其实是一个内存块的首地址，内存块的具体大小由指针变量的类型决定，当使用指针变量解引用访问内存时，实际访问的内存字节数叫做指针变量的进步值，也就是指针变量+1后的内存地址的变化。

复制代码 
#include <stdio.h>
​
int main(int argc,const char* argv[])
{
    char* p1 = NULL;
    short* p2 = NULL;
    int* p3 = NULL;
    long long* p4 = NULL;
    long double* p5 = NULL;
​
    printf("%p %p %p %p %p\n",p1,p2,p3,p4,p5);
    printf("%p %p %p %p %p\n",p1+1,p2+1,p3+1,p4+1,p5+1);      
    
    int* p6 = p3+8;
    printf("%p\n",p3);
    printf("%d\n",p3-p6);   
}
​
指针的运算：

指针变量存储就是是整数，理论上整数能使用的运算符，指针变量都可以使用，但只有以下运算才有意义：

复制代码 
指针+n = 指针所代表的整数+进步值*n       
指针-n = 指针所代表的整数-进步值*n
指针1-指针2 = (指针1所代表的整数-指针2所代表的整数)/进步值

指针加减整数，就相当于以指针变量的进步值为单位前后移动，指针-指针可以计算出两个指针变量之间相隔多少个元素。

注意：

指针-指针运算，它们的类型必须相同，否则编译器会报错。

数组名与指针：
数组名就是指针：
复制代码 
#include <stdio.h>
​
int main(int argc,const char* argv[])
{
    int arr[10] = {}; 
​
    printf("%p %p %p\n",&arr[0],arr,&arr);                        
}
​

1、数组名就是数组内存块的首地址，它是个常量地址（特殊的指针），所以它作函数的参数时，才能蜕变成指针变量，因此需要额外传递数组的长度。

2、指针变量可以使用[]解引用，数组名也可以*遍历，它们是等价的。建议：当指针变量指向数组时，把指针当做数组使用较为方便

复制代码 
#include <stdio.h>
​
void show_arr(int* arr,int len)
{
    printf("show:%p\n",arr);
    for(int i=0; i<len; i++)
    {
        printf("%d ",arr[i]);
        //printf("%d ",*(arr+i));                                      
    }
}
​
int main(int argc,const char* argv[])
{
    int arr[10] = {1,2,3,4,5};
​
    printf("%d\n",*(arr+1));    //  *(arr+1) == arr[1]
​
    printf("%p %p %p\n",&arr[0],arr,&arr);
    show_arr(arr,10);
    //arr = NULL;
}

**注意：**如果定义<TYPE> arr[n]数组，数组名arr 就是 TYPE*类型的地址。

数组名与指针的相同点：

1、它们都是地址

2、它们都使用[],*去访问一块连续的内存

数组名与指针的不同点：

1、数组名是常量，而指针是变量

2、指针变量有它自己的存储空间，而数组名就是地址，它没有存储地址的内存。

3、指针变量与它的目标内存是指向关系，而数组名与它的目标内存是映射关系。

通用指针：（万能指针）

一些具备通用性的操作函数，它们的参数可能是任意类型的指针，但编译器规定不同类型的指针不能进行赋值，为了兼容各种类型的指针，C语言中设计了void类型的指针，它能与任意类型的指针互相转换，它能解决不同类型的指针参数的兼容性问题。

复制代码 
void* p1 = NULL;
// void* 可以给任意类型的指针变量赋值
int* p2 = p1;
// 任意类型的指针可以给void*类型的指针赋值
void* p3 = p2;

通用操作的函数：

复制代码 
void bzero(void *s, size_t n);
功能：把内存块s的n个字节，赋值为0。
    
void *memset(void *s, int c, size_t n);
功能：把内存块s的n个字节，赋值为c(0~255)
返回值：返回处理完的内存段的首地址，也就是s，为了链式调用
    memcpy(dest,memset(s,10,20),20);
    
void *memcpy(void *dest, const void *src, size_t n);
功能：从src内存块拷贝n个字节的内容到dest内存块
返回值：返回dest的，链式调用
​
int memcmp(const void *s1, const void *s2, size_t n);
功能：比较s1和s2内存块的n个字节
    s1 > s2 返回1
    s1 < s2 返回-1
    s1 == s2 返回0
复制代码 
#include <strings.h>
#include <string.h>
​
int main(int argc,const char* argv[])
{
    void* p = NULL;
    char* p1 = p;
    int* p2 = p;
    int num = 10;
    char ch = 20;
    p = &num;                                                                                           
    p = &ch;
​
    char arr[10] = {1,2,3,4,5,6,7,8,9,0};
    char arr1[10] = {1,2,3,4,5,6,7,8,9,0};
    int ret = memcmp(arr,arr1,10);
    printf("ret=%d\n",ret);
    //memcpy(arr1,arr,4);
    //bzero(arr,10);
    //memset(arr,10,10);
    for(int i=0; i<10; i++)
    {
        printf("%hhd ",arr1[i]);
    }
}
注意：
void类型的指针变量的进步值是1。
void类型的指针变量不能解引用 ，必须转换成其它类型的指针才能解引用。
复制代码 
void* p = NULL;
int num = 10;
p = &num;   //  p依然是void*
*p = 10;    //  报错不允许
*(int*)p = 10;  //  允许

**练习1：**实现一个 交换任意类型的两个变量的 函数。

复制代码 
void swap(void* p1,void* p2,int len)
    //	len是要交换的变量的类型字节数
    //	借助mem系列函数 memcpy memcmp memmove
复制代码 
#include <stdio.h>
#include <string.h>

void swap(void* p1,void* p2,int len)
{
    if(NULL == p1 || NULL == p2 || len <= 0)
        return;
    char temp[len];
    memcpy(temp,p1,len);
    memcpy(p1,p2,len);                            
    memcpy(p2,temp,len);
}

int main(int argc,const char* argv[])
{
    double n1 = 10,n2 = 20;
    swap(&n1,&n2,sizeof(n1));
    swap(NULL,NULL,10);
    printf("%lf %lf\n",n1,n2);
}

**练习2：**实现自定义的bzero、memset、memcpy、memcmp函数。注意：不能使用原函数进行辅助

复制代码 
#include <stdio.h>                         

void my_bzero(void* s,size_t n)
{
    if(NULL == s || 0 == n)
        return;

    for(int i=0; i<n; i++)
    {   
        //*(char*)(s+i) = 0;
        ((char*)s)[i] = 0;
    }   
}

void* my_memset(void* s,int c,int n)
{
    if(NULL == s || 0 == n)
        return NULL;

    for(int i=0; i<n; i++)
    {
        *(char*)(s+i) = c;
    }
    return s;
}

void* my_memcpy(void* dest,const void* src,size_t n)
{
    if(NULL == dest || NULL == src || 0 == n)
        return NULL;

    for(int i=0; i<n; i++)
    {
         *(char*)(dest+i) = *(char*)(src+i);
    }
    return dest;
}

int my_memcmp(const void* s1,const void* s2,size_t n)
{
    if(NULL == s1 || NULL == s2 || 0 == n)
        return 0xffffffff;

    const char* p1 = s1;
    const char* p2 = s2;

    for(int i=0; i<n; i++)
    {
        if(p1[i] > p2[i])
            return 1;
        if(p1[i] < p2[i])
            return -1;
    }
    return 0;
}


int main(int argc,const char* argv[])
{
    int arr[10] = {1,1,1,1,1,1,1,1,13};
    my_bzero(arr,40);
    for(int i=0; i<10; i++)
    {   
        printf("%d ",arr[i]);
    }   
    
    
    char arr[10] = {};
    char arr1[10] = {1,10};
    printf("first:%hhd\n",*(char*)my_memset(arr,1,10));

    my_memcpy(arr1,arr,0);
    for(int i=0; i<10; i++)
    {
        printf("%hhd ",arr1[i]);
    }

    printf("cmp:%d\n",my_memcmp(arr,arr1,10));

}
const与指针:

遵循：就近原则：看const右边是* 还是指针变量名

复制代码 
const int* p;
功能：保护指针变量所指向的内存不被修改
	也就是说 不通过通过*p 访问内存了，*p变成只读

int const *p;
功能：同上

注意：int* p1 = p;	//	此时类型不匹配会有警告，
		//需要强转 int* p1=(int*)p;
复制代码 
int* const p;
功能：保护指针变量的值不被修改
	也就是说 指针的指向不能修改 p不能再赋其它地址，变成只读
复制代码 
const int* const p;
功能：保护指针所指向的内存以及指针的指向都不能修改

int const* const p;
功能：同上

当使用指针变量作为函数的参数传递时，此时是函数之间共享内存，但是有些情况下不希望函数中修改该共享内存中的数据，可以通过const与指针变量配合，防止内存被修改

复制代码 
#include <stdio.h>

void func(const double* f)
{
    //*f = 0;    //	double*提高了传参效率，但是内存有被修改的风险                                                      
}

int main(int argc,const char* argv[])
{
    double f = 10; 
    for(double i=0; i<100000000; i++)
    {   
        func(&i);
    }   
}

当希望与堆内存配合使用的指针变量的指向是从一而终的，可以通过 类型* const 指针变量名 的方式保护指针的指向不被修改

复制代码 
int num = 10;
int* const p = malloc(4);	
*p = 100;
//p = &num;	p就无法改变指向
free(p)
二级指针：
什么是二级指针：

一级指针存储的是普通变量的内存地址，二级指针存储的是指针变量内存地址。

定义二级指针：

类型* 一级指针;

类型** 二级指针;

注意：二级指针在使用方法上与一级指针有不同，所以一般以pp结尾，让使用者从变量名上就能区别一级指针与二级指针。

二级指针的赋值：

二级指针 = &一级指针;

注意：给二级指针赋值的一级指针，它们的类型必须相同，否则编译时就会报错。

二级指针解引用：

二级指针 = &一级指针;

*二级指针 此时它等价于一级指针

**二级指针 此时它等价于 *一级指针 等价于一级指针指向的内存

复制代码 
#include <stdio.h>

int main(int argc,const char* argv[])
{
    int num = 100;

    int* p = &num;

    int** pp = &p; 

    //  *p == num
    printf("%p %p\n",*pp,p);
    printf("%d %d %d\n",num,*p,**pp);
}
二级指针的用处：

只有一个情况适合使用二级指针，那就是跨函数共享一级指针变量。

任务：实现一个函数，交换两个int类型指针变量的指向
复制代码 
#include <stdio.h>                                                                               
void swap(int** pp1,int** pp2)
{
    int* temp = *pp1;
    *pp1 = *pp2;
    *pp2 = temp;
}

int main(int argc,const char* argv[])
{
    int n1 = 10, n2 = 20;
    int *p1 = &n1, *p2 = &n2;
    printf("n1=%d n2=%d &n1=%p &n2=%p p1=%p p2=%p\n",n1,n2,&n1,&n2,p1,p2);

    swap(&p1,&p2);
    printf("n1=%d n2=%d &n1=%p &n2=%p p1=%p p2=%p\n",n1,n2,&n1,&n2,p1,p2);

}

指针数组与数组指针：

什么是指针数组：

由指针变量构成的数组，也可以说它的身份是数组，成员是指针变量。

定义指针数组：

类型* 数组名[n];

就相当于定义了n个类型相同的指针变量。

复制代码 
int* arr[10]; // 相当于定义了10个int*的指针变量
//	10个野指针
int* arr[10] = {};	//	全部初始化为NULL
指针数组的用处：

1、构建不规则二维数组。

复制代码 
#include <stdio.h>

int main(int argc,const char* argv[])
{
    int arr1[] = {5,2,3,5,6,1};
    int arr2[] = {2,2,3};
    int arr3[] = {9,2,3,5,6,1,4,5,5,2};
    int arr4[] = {4,2,3,5,1};
    int arr5[] = {7,2,3,5,6,1,3,4};

    int* arr[] = {arr1,arr2,arr3,arr4,arr5};

    for(int i=0; i<sizeof(arr)/sizeof(arr[0]); i++)
    {
        for(int j=1; j<=arr[i][0]; j++)                                                          
        {
            printf("%d ",arr[i][j]);
        }
        printf("\n");
    }

}

2、构建字符串数组。

复制代码 
char* str[] = {"hehehahaxixi","xixihha",...};
什么是数组指针：

专门指向数组的指针变量，它的进步值是整个数组的字节数。

定义数组指针：

类型 (*指针变量名) [n];

类型和n决定了 数组指针 指向的是什么样的数组。

复制代码 
int (*arrp)[5];	//	arrp是一个指向 长度为5，类型为int的数组的指针
复制代码 
int main(int argc,const char* argv[])
{
    int arr[5] = {188,2,3,4,50};                             

    int (*p)[5] = &arr;

    //printf("%p %p %p \n",&arr[0],arr,&arr);
    //  *p <=> arr 
    //  arr[i] <=> *(arr+i)
    //printf("%d %d %d\n",arr[1],*p[0],*(*p+1));
    //printf("%d\n",**(p+1));
    int* p1 = (int*)(p+1);	//p+1 指向数组的末尾 往后移动20字节
    printf("%d\n",*(p1-1));	//	p1是int* p1-1往前移动4字节
}
数组指针的用处：
复制代码 
#include <stdio.h>
// 使用数组指针可以把一块连续的内存当作二维数组使用，特别是与堆内存配合效果更佳
int main()
{
    int arr[20] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
    int (*p)[5] = (void*)arr;  //void* 是为了不产生警告                                                 
    for(int j=0; j<4; j++)
    {
        for(int i=0; i<5; i++)
        {
            //printf("%d ",*(*(p+j)+i));
            printf("%d ",p[j][i]);
        }
        printf("\n");
    }
}
数组指针可以用于函数之间传递二维数组：
复制代码 
函数之间传递二维数组的方式：
1、void func(int arr[行数][列数])		
    //行列数要固定
2、void func(int arr[][列数],int x)	    
    //列数不能省略
3、void func(int (*arr)[列数],int x)	
    //一样缺乏泛用性
4、void func(int* arr,int x,int y)
{
    printf(“%d ”,*(arr+i*y+j));	//使用麻烦
	int arr[3][5];
	func((int*)arr,3,5);
}	
5、void func(int x,int y,int arr[x][y])	//
数组名、指针、数组指针
复制代码 
int arr[n];		//	数组
arr			是 int* 类型
*arr 		是 int  类型
&arr[0] 	是 int* 类型
&arr  		是 int (*)[n] 类型
	int (*p)[n] <=> &arr
	*p <=> arr
	arr[i] <=> *(arr+i)

    
int arr2[row][col];
arr2 		是 int (*)[col] 类型
*arr2 		是 int* 类型		
**arr2 		是 int 类型	*(*(arr2+i)+j)  <=> arr2[i][j]
*(arr2[0]) 	是 int 类型
*arr2[0]	是 int 类型
&arr2[0] 	是 int (*)[col]\int** 类型
	&arr2[0] <=> int (*)[col]
&arr2[0][0] 是 int* 类型
函数指针：
函数名是什么：

函数就是一段具有某项功能的代码，它会被编译器编译成二进制指令存储在text内存段，函数名就是它在text内存段的首地址。编译器认为函数名就是一个地址(整数)

什么是函数指针：

专门存储函数地址的指针变量叫函数指针。

定义函数指针：

1、先确定指向的函数的格式(函数声明)。

2、照抄函数声明。

3、用小括号包含函数名。

4、在函数名前加*

5、在函数名末尾加_fp，防止命名冲突。

, 6、用函数名给函数指针赋值后，函数指针就可以当作函数调用了。

复制代码 
#include <stdio.h>

void func(void)
{
    printf("我是函数func,我被调用了...\n");
}

int main()
{
    void (*func_fp)(void) = func;
    func_fp();  
}
函数指针的用处：

函数指针可以让函数像数据一样在函数之间传递。

复制代码 
stu_cmp_socre(int socre1,int socre2){}	//孙子写的

void sort(void* arr,int len)	//爷爷写的
{
    stu_cmp_
}

当我们实现一个数组的排序函数时，那么排序函数内部需要调用数组元素的比较函数，由于我们不知道待排序的数组是什么类型，也就无法自己实现数组元素的比较函数，那么我们可以在排序函数的参数列表中预留一个函数指针，当有人调我们的排序函数时，他就需要提供一个数组元素比较函数供我们调用，排序函数就可以为它的数组进行排序。

函数的这种调用模式就叫回调模式。

复制代码 
void qsort(void *base, 
           size_t nmemb, 
           size_t size,
           int (*compar)(const void *, const void *));
功能：为数组进行快速排序
base：数组的首地址
nmemb：数组的长度
size：数组成员的字节数
compar：调用者需要提供的数组元素的比较函数 回调函数
复制代码 
#include <stdlib.h>

int cmp_int(const void * p1, const void * p2)                                                    
{
    if(*(int*)p1 > *(int*)p2)
        return 1;
    if(*(int*)p1 < *(int*)p2)
        return -1; 
    return 0;
}

int main(int argc,const char* argv[])
{
    double arr[10] = {5,7,21,3,4,54,65,78,1,3};

    qsort(arr,10,8,cmp_int);

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

**练习1、**定义一个长度为100的float类型的数组，并随机初始化，调用qsort函数对它进行排序。

**练习2、**参考qsort(快速排序的通用函数）实现一个通用的选择排序函数。

复制代码 
#include <stdio.h>                                                                                                                                                                                                                 
#include <string.h>
#include <time.h>
#include <stdlib.h>

//  通用选择排序
void select_sort(void* base,size_t nmemb,size_t size,
        int (*cmp)(const void*,const void*))
{
    //printf("select_sort\n");
    //printf("%s\n",__func__);
    if(NULL == base || NULL == cmp || 0 == nmemb || 0 == size)
        return;

    for(int i=0; i<nmemb-1; i++)
    {
        int min = i;
        for(int j=i+1; j<nmemb; j++)
        {
        //  if(arr[j] < arr[min])
            if(0 > cmp(base+j*size,base+min*size))
            {
                min = j;
            }
        }
        if(min != i)
        {
            char temp[size];
            memcpy(temp,base+min*size,size);
            memcpy(base+min*size,base+i*size,size);
            memcpy(base+i*size,temp,size);
        }
    }
}

//  以下是调用者写
//  提供数据比较函数

int cmp_int(const void* p1,const void* p2)
{
    return *(int*)p2 - *(int*)p1;
}

int cmp_double(const void* p1,const void* p2)
{
    return *(double*)p2 - *(double*)p1;
}

int main(int argc,const char* argv[])
{
    printf("%s\n",__func__);
    srand(time(NULL));
    int arr[10] = {};
    double arr2[10] = {};
    for(int i=0; i<10; i++)
    {
        arr[i] = rand()%100;
        arr2[i] = rand()%100 - 0.5;
    }
    select_sort(arr,sizeof(arr)/sizeof(arr[0]),
            sizeof(arr[0]),cmp_int);

    select_sort(arr2,10,8,cmp_double);
    for(int i=0; i<10; i++)
    {
        printf("%lf ",arr2[i]);
    }
}

i

相关推荐
pianmian11 小时前
python数据结构基础(7)
数据结构·算法
闲晨1 小时前
C++ 继承：代码传承的魔法棒，开启奇幻编程之旅
java·c语言·开发语言·c++·经验分享
好奇龙猫3 小时前
【学习AI-相关路程-mnist手写数字分类-win-硬件：windows-自我学习AI-实验步骤-全连接神经网络（BPnetwork）-操作流程（3） 】
人工智能·算法
sp_fyf_20244 小时前
计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01
人工智能·深度学习·神经网络·算法·机器学习·语言模型·数据挖掘
香菜大丸4 小时前
链表的归并排序
数据结构·算法·链表
jrrz08284 小时前
LeetCode 热题100（七）【链表】（1）
数据结构·c++·算法·leetcode·链表
oliveira-time4 小时前
golang学习2
算法
南宫生5 小时前
贪心算法习题其四【力扣】【算法学习day.21】
学习·算法·leetcode·链表·贪心算法
懒惰才能让科技进步6 小时前
从零学习大模型（十二）-----基于梯度的重要性剪枝（Gradient-based Pruning）
人工智能·深度学习·学习·算法·chatgpt·transformer·剪枝
DARLING Zero two♡6 小时前
关于我、重生到500年前凭借C语言改变世界科技vlog.16——万字详解指针概念及技巧
c语言·开发语言·科技
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07Macbook pro M1 安装Ubuntu教程08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10文件或文件夹名称中有空格如何批量去除