c语言指针-10

已于 2024-07-12 19:38:44 修改
阅读量351 收藏 8
点赞数 5
文章标签： 算法 排序算法 数据结构
于 2024-07-12 19:38:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46950007/article/details/140384168
版权

三、指针指向数组

3.1 指针与数组的关系

1> 一维数组的数组名，本质上是一个该数组的第一个元素的地址

int arr[5]; arr &arr[0]

2> 数组名是一个地址常量，不能被重新赋值，但是，数组名可以进行偏移

3> 二维数组的数组名，从数值上来说也是一个该数组第一个元素的地址

int arr[3][4]; arr &arr[0] arr[0] &arr[0][0] arr[1] &arr[1][0]

3.2 指针与一维数组关系实现

1> 指针与一维数组的关系

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //定义一个一维数组
    int arr[] = {3,8,3,2,4};
    int len = sizeof(arr)/sizeof(arr[0]);    //求数组长度

    //定义指针指向一维数组
    int *ptr = arr;             //int *ptr = &arr[0];

    //数据输出方式1，从值的角度
    printf("数据元素分别是：");
    for(int i=0; i<len; i++)
    {
        printf("%d\t", arr[i]);
    }
    printf("\n");

    //输出方式2：从数组名的角度
    printf("数据元素分别是：");
    for(int i=0; i<len; i++)
    {
        printf("%d\t", *(arr+i) );
    }
    printf("\n");

    //输出方式3：从指针变量的角度
    printf("数据元素分别是：");
    for(int i=0; i<len; i++)
    {
        printf("%d\t", *(ptr+i) );
    }
    printf("\n");

    //输出方式4：从指针的角度找值
    printf("数据元素分别是：");
    for(int i=0; i<len; i++)
    {
        printf("%d\t", ptr[i]);
    }
    printf("\n");

    //输出方式5：从指针变量的角度
    printf("数据元素分别是：");
    for(int i=0; i<len; i++)
    {
        printf("%d\t", *(ptr++));
        
    }
    printf("\n");

    return 0;
}

2> 指针指向一维整型数组作为函数参数传递

当实参使用的是数组名进行传递时，本质上传递的是数组首元素的地址

被调函数的形参可以是一个数组接收，也可以是一个指针变量接收

虽然使用的是数组接收，但是，本质上也还是使用的是指针接收



#include<myhead.h>

//使用数组接受
/*
void sort(int arr[], int n)
{
    for(int i=1; i<n; i++)
    {
        for(int j=0; j<n-i; j++)
        {
            if(arr[j] > arr[j+1])
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    printf("排序成功\n");
}
*/

//使用指针接受
void sort(int *arr, int n)
{
    for(int i=1; i<n; i++)
    {
        for(int j=0; j<n-i; j++)
        {
            if(arr[j] > arr[j+1])   //if(*(arr+j) > *(arr+j+1))
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    printf("排序成功\n");
}









/***************************主程序**********************/
int main(int argc, const char *argv[])
{
    int arr[5] = {3,9,2,7,6};

    //调用排序函数，将数组进行排序
    sort(arr, 5);     //sort(&arr[0], 5)

    printf("排序后的结果为：");
    for(int i=0; i<5; i++)
    {
        printf("%d\t", arr[i]);
    }
    printf("\n");

    return 0;
}

练习：

主函数中定义一个长度为8的数组，调用自定义函数完成输入、自定义函数完成输出、自定义函数求最大值、自定义函数完成数组的逆置。并对这些函数进行测试。要求，形参使用指针接收

#include<myhead.h>
#define MAX 100
//定义输入函数
void input_score(int *score_ptr,  int *size_ptr)
{
    printf("请输入班级人数：");
    scanf("%d", size_ptr);          //输入班级人数

    //输入学生成绩
    for(int i=0; i<*size_ptr; i++)
    {
        printf("请输入第%d个学生成绩：", i+1);
        scanf("%d", score_ptr+i);  //score_ptr[i] <==> *(score_ptr +i)
    }
    printf("录入成功\n");
}

//定义输出函数
void output_score(int *score_ptr, int size)
{
    printf("目前学生分数分别是：");
    for(int i=0; i<size; i++)
    {
        printf("%d\t", score_ptr[i]);
    }
    printf("\n");

    score_ptr[0] = 100;
}


/***********************主程序**********************/
int main(int argc, const char *argv[])
{
    int score[MAX] = {0};          //定义足够大的数组
    int size = 0;                  //数组的实际大小

    //调用函数完成输入工作
    input_score(score, &size);

    //调用函数完成输出工作
    output_score(score, size);

    output_score(score, size);

    

    return 0;
}

3> 指针指向一维字符数组作为函数参数传递

1、由于字符串有结束标识，所以接收字符串时，可以不用接收字符串长度

2、一般对传入的字符串如果不进行更改操作的话，需要加上关键字const修饰

#include<myhead.h>
#include<ctype.h>

//定义筛选函数
void fun(const char *src, char *dest)
{
    char temp = 0;

    //遍历所有src中的字符
    while(temp = *src++)
    {
        //判断该字符是否为字母字符
        if(isalpha(temp))
        {
            *dest++ = temp;
        }
    }
    *dest = '\0';          //给新串放入结束标志
}


/***************主程序*********************/
int main(int argc, const char *argv[])
{
    //功能：传入一个源字符串，调用函数实现，将该字符串中的
    //字母字符放入新数组中传递给主调函数
    char src[100] = "";
    char dest[100] = "aaaaaaaaaaaaaaa";

    printf("请输入一个字符串：");
    gets(src);

    //调用挑选数据的函数
    fun(src, dest);

    printf("新字符串为：%s\n", dest);


    return 0;
}

3、指针与字符串的关系

1、字符串本质上是一个指针常量，可以定义一个指针指向一个字符串 2、当一个指针指向一个字符串时，不能通过该指针改变字符串中的内容 

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //定义数组存储字符串、
    char str[100] = "hello world";

    //定义指针指向字符串常量
    char *ptr = "I love China";

    printf("str = %s, ptr = %s\n", str, ptr);

    str[0] = 'H';         //给数组元素进行重新赋值
    //ptr[0] = 'i';        //?

    printf("str = %s, ptr = %s\n", str, ptr);

    //请看案例
    char s[100] = "acb\x12ef";
    printf("strlen(s) = %ld\n", strlen(s)); //?

    char c = '\x12';
    printf("c = %d\n", c);

    return 0;
}

4> const 关键字

1、const 中文含义 常量，常属性

2、该关键字是一个变量的存储格式，修饰变量时，表示给该变量添加常属性

3、const修饰的变量，虽然有常属性，但是，还依然是一个变量

4、定义变量的格式 const 数据类型 变量名；

5、修饰变量时，包括修饰普通变量和指针变量，有所不同

#include<myhead.h>

int main(int argc, const char *argv[])
{
    int num = 520;       //定义的是普通变量
    const int key ;   //定义的是常变量

    //常变量跟普通变量一样，可以被访问
    printf("num = %d, key = %d\n", num, key);

    num = 999;
    //key = 666;   //不能直接通过key对key的值进行修改
    int *ptr = &key;
    *ptr = 666;
    printf("num = %d, key = %d\n", num, key);

    return 0;
}

6> const修饰指针变量（重要）

定义指针变量的格式： 数据类型 * 指针名；

#include<myhead.h>

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

    //定义指针变量指向普通变量
    const int *p1 = &num;    //p1保护的是指针指向内存空间中的值
    int const *p2 = &num;    //与p1一样
    int * const p3 = &num;   //p3保护的是指针中的值
    const int * const p4 = &num; //两个都保护

    //验证p1保护哪个内容
    //*p1 = 999;           //更改指针指向内存空间中的值,报错
    //p1 = &key;           //更改指针的值
    
    //验证p2保护哪个内容
    //*p2 = 999;           //更改指针指向内存空间中的值,报错
    // p2 = &key;           //更改指针的值

    //验证p3保护哪个内容
    //*p3 = 999;           //更改指针指向内存空间中的值,报错
    // p3 = &key;           //更改指针的值

    //验证p4保护哪个内容
    *p4 = 999;           //更改指针指向内存空间中的值,报错
    p4 = &key;           //更改指针的值


    return 0;
}

作业 

1> 自定义函数（my_strlen）实现strlen函数的功能

2> 自定义函数（my_strcpy）实现strcpy函数的功能

3> 自定义函数（my_strcmp）实现strcmo函数的功能

4> 自定义函数（my_strcat）实现strcat函数的功能

5> （my_strstr）实现求src字符串中是否包含子串dest字符串

#include <stdio.h>

// 实现 strlen 功能
int my_strlen(const char *str) {
    int count = 0;
    while (*str != '\0') {
        count++;
        str++;
    }
    return count;
}

// 实现 strcpy 功能
char* my_strcpy(char *dest, const char *src) {
    char *original_dest = dest; // 保存dest的初始地址
    while (*src != '\0') {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = '\0'; // 在dest字符串末尾添加终止符
    return original_dest;
}

// 实现 strcmp 功能
int my_strcmp(const char *str1, const char *str2) {
    while (*str1 && *str2 && *str1 == *str2) {
        str1++;
        str2++;
    }
    return *(const unsigned char *)str1 - *(const unsigned char *)str2;
}

// 实现 strcat 功能
char* my_strcat(char *dest, const char *src) {
    char *original_dest = dest; // 保存dest的初始地址
    while (*dest) {
        dest++; // 寻找dest字符串的结尾
    }
    while (*src != '\0') {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = '\0'; // 在新字符串末尾添加终止符
    return original_dest;
}

// 实现 strstr 功能
const char* my_strstr(const char *haystack, const char *needle) {
    size_t len = my_strlen(needle);
    if (len == 0)
        return haystack;

    for (; *haystack; haystack++) {
        if (my_strcmp(haystack, needle) == 0)
            return haystack;
    }
    return NULL;
}

int main() {
    const char *str1 = "Hello, world!";
    char str2[50];

    // 测试 my_strlen
    printf("Length of '%s': %d\n", str1, my_strlen(str1));

    // 测试 my_strcpy
    my_strcpy(str2, str1);
    printf("Copied string: %s\n", str2);

    // 测试 my_strcmp
    const char *str3 = "Hello, world!";
    if (my_strcmp(str1, str3) == 0)
        printf("Strings '%s' and '%s' are equal.\n", str1, str3);
    else
        printf("Strings '%s' and '%s' are not equal.\n", str1, str3);

    // 测试 my_strcat
    char str4[] = "Hello, ";
    my_strcat(str4, str3);
    printf("Concatenated string: %s\n", str4);

    // 测试 my_strstr
    const char *str5 = "world";
    const char *result = my_strstr(str1, str5);
    if (result != NULL)
        printf("Substring found at position %lu\n", result - str1);
    else
        printf("Substring not found.\n");

    return 0;
}

c语言指针-C-Test-10-14.rar
08-24
c语言指针-C-Test-10-14.rar
c语言指针-C-Test-10-13.rar
08-24
c语言指针-C-Test-10-13.rar
C语言--指针详解
01-27
C语言中的指针是其核心特性之一，它在编程中起着至关重要的作用，尤其是在处理内存管理和高级数据结构时。本文将深入解析C语言的指针概念及其应用。 首先，理解指针的本质是关键。在C语言中，每个变量都有一个唯一...
C语言教程---第六章指针 - PCVC_NET.zip_C语言教程_c语言指针
09-19
在C语言中，指针是其核心特性之一，它提供了对内存地址的直接操作，使得程序可以高效地处理数据和实现复杂的数据结构。本教程的第六章深入探讨了C语言中的指针概念及其使用方法。 首先，我们了解什么是指针。在...
C语言指针-从底层原理到熟练应用（含源码）
05-29
二、变量与指针的本质 1. 内存地址 2. 32位与64位系统 3. 变量 4. 指针变量 5. 操作指针变量 三、指针的几个相关概念 1. const属性 2. void型指针 3. 空指针和野指针 四、指向不同数据类型的指针 1. 数值...
【搜索回溯算法篇】：搜索无界，回溯有方--算法练习题精选解析
2301_82347435的博客
01-21 1071
在学习搜索和回溯算法之前一定要学会递归的使用，下面的几道题都是使用递归来实现，如果对于递归有不理解的可以看我上一篇的文章，有关于递归的简单题讲解。接下来就是开始讲解搜索和回溯的练习题。
202012 青少年软件编程等级考试C/C++ 二级真题答案及解析（电子学会）
白昼的技术专栏
01-23 65
中国电子学会 202012 青少年软件编程等级考试C/C++ 二级真题答案及解析
【第四天】零基础入门刷题Python-算法篇-数据结构与算法的介绍-两种常见的递归算法（持续更新）
2301_78806917的博客
01-22 258
第一天Python数据结构与算法的详细介绍第二天五种常见的排序算法提示：以下是本篇文章正文内容，下面案例可供参考提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文简单介绍两种常见的递归算法。
差分进化算法 (Differential Evolution) 算法详解及案例分析
qq_42568323的博客
01-22 1339
差分进化算法是一种高效的全局优化算法，适用于单目标、多目标和约束优化问题。本文通过三个案例展示了差分进化算法在不同问题中的应用，并提供了完整的代码实现和优化曲线。在实际应用中，差分进化算法的性能依赖于参数设置，需要通过实验进行调整。
Leetcode - 148双周赛
m0_74859835的博客
01-24 539
Leetcode - 148双周赛，主要知识点：贪心，树上滑窗，贡献法+排列组合
25/1/22 算法笔记＜ROS2＞ TF变换
yyyy2711的博客
01-22 489
是 ROS（Robot Operating System）中的一个核心功能，用于管理和发布坐标系之间的变换关系。TF 的主要作用是描述机器人系统中各个部分（如传感器、执行器、底盘等）之间的位置和姿态关系，从而实现数据的统一和模块化。是 ROS（Robot Operating System）中用于描述两个坐标系之间固定不变的变换关系的一种机制。静态 TF 适用于那些在机器人系统中不会随时间变化的坐标系关系，例如传感器相对于机器人底盘的位置和姿态。以下是使用 C++ 编写的发布静态 TF 变换的完整代码。
梯度下降法 (Gradient Descent) 算法详解及案例分析
qq_42568323的博客
01-22 1476
梯度下降法是一种简单而强大的优化算法，广泛应用于机器学习和深度学习中。本文通过三个案例展示了梯度下降法在线性回归、逻辑回归和神经网络训练中的应用，并提供了完整的代码实现和优化曲线。在实际应用中，梯度下降法的性能依赖于学习率和迭代次数的选择，需要通过实验进行调整。
代码随想录算法训练营第 16 天（树4）| 513.找树左下角的值、112. 路径总和i ii、106.从中序与后序遍历序列构造二叉树
YOLO的博客
01-23 190
offer()是 Queue 接口的一个方法，用于将一个元素插入到队列的尾部。此题用前序后序中序都可以，因为没有对根节点有操作，只要保证先是左再是右就行。关键思路：逐步递减，最后总和是0，且是叶子节点，就是有。关键思路：这个题使用层序遍历（迭代法）更容易一些。先求出深度最大的一层，然后找这一层最左边的节点。然后在中序中切割前半（左子树）和后半（右子树）根据前或后序找根节点；
算法随笔_21:字符的最短距离
最新发布
m0_70494097的博客
01-24 433
字符的最短距离，算法题解，通俗易懂
c语言数组详解
2401_87734250的博客
01-24 563
主要介绍c语言数组方面的内容
代码随想录算法训练营day35
qq_38365428的博客
01-22 957
今天是算法营的第35天，希望自己能够坚持下来！今天开始是背包问题了，今日任务：● 01背包问题 二维● 01背包问题 一维● 416. 分割等和子集01背包：n个物品，w空间的背包，每个物品重量不同，价值不同，求背包装最多的价值是多少。需要初始化最上层和最左层先遍历背包还是物品都可以，因为两种方式都可以得到左上角的数据，先遍历物品比较好理解。就是二维中去掉i维度，理解成将i-1层的数据拷贝到i层。
【2024年华为OD机试】 (E卷,100分) - 转盘寿司（JavaScript&Java & Python&C/C++）
无
01-22 475
整个解题思路利用了栈这一数据结构来有效地跟踪和更新每个寿司盘的优惠价格，通过一次遍历来优化算法的时间复杂度。代码通过栈数据结构高效地解决了循环数组中每个元素右侧第一个更小值的问题。使用readline模块从控制台读取输入，适合 Node.js 环境。代码逻辑清晰，注释详细，易于理解和维护。代码通过栈数据结构高效地解决了循环数组中每个元素右侧第一个更小值的问题。使用Deque作为栈，方便操作。通过构建输出结果，避免频繁的字符串拼接操作，提高性能。代码逻辑清晰，注释详细，易于理解和维护。
牛客周赛 Round 77
MenghuanL的博客
01-20 339
Solution：手模发现，前面一定是每个数字都出现，且次数相同，最后后面再放一些数字只出现一次。故只要判断数字的最少次数和最多次数差距不大于1即可。Solution：考虑以u为目标lca的答案，num[i]记录以i为根的子树包含的目标节点的个数。Solution：按位进行运算，将这一位为1的账号使用并查集进行合并。，问能否经过排列，使其每个长度为9的连续子数组都包含。Description：给定n个数，每个数的范围为。Solution：上下和左右是独立的，根据裴蜀定理。tag：并查集 + 位运算。
算法随笔_13: 有效三角形的个数
m0_70494097的博客
01-20 712
有效的三角形个数，算法题解
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值