虚拟机0712笔记及作业

作业讲解：

1>使用递归实现 求 n 的 k 次方

2>使用递归实现 strlen 的功能

3>使用递归实现汉诺塔问题(君子作业)

4>定义一个函数将一个字符串从大到小排序

#include <stdio.h>
//定义函数
void sort(char str[])
{
    int len = strlen(str);       //求出字符串实际长度
    for(int i=1; i<len; i++)
    {
        for(int j=0; j<len-i; j++)
        {
            if(str[j] < str[j+1])
            {
                //交换三部曲
                char temp = str[j];
                str[j] = str[j+1];
                str[j+1] = temp;
            }
        }
    }
    printf("排序成功\n");
}

int main(int argc, const char *argv[])
{
    char s[20] = "";
    printf("请输入>>>");
    gets(s);                       //输入一个字符串
    sort(s);                   //调用排序函数
    printf("排序后的结果为：%s\n", s);
    return 0;
}

运行结果：

5>实现一个函数，用于检查一个字符串是否是回文字符串（正序和反序都相同）

6>使用指针完成判断自己的主机存储多字节整数时，是大端存储还是小端存储

大端存储：内存地址低位存储数据的高位称为大端存储

小端存储：内存地址低位存储数据的低位称为小端存储

#include <stdio.h>

void endian()
{
    int num = 0x12345678;        //定义变量存储多字节整数

    char *ptr = (char *)&num;   //&num是int *类型

    //对地址低位的一字节数据判断
    if(*ptr == 0x12)
    {
        printf("主机是大端存储\n");
    }else
    {
        printf("主机是小端存储\n");
    }
}

int main(int argc, const char *argv[])
{
    endian();           //调用函数
    return 0;
}

运行结果：

7>        注：中间标点符号后面有空格

#include <stdio.h> 
#include <string.h>

//定义功能函数
int words(char str[])     //参数为传过来的字符串，返回值为单词个数
{
    int len = strlen(str);      //求字符串实际长度
    int count= 0;                 //单词个数

    //循环遍历整个字符串
    for(int i=0; i<len; i++)
    {
        if(str[i] != ' ' && str[i+1]== ' ')
        {
            count++;        //表示有一个单词出现
        }
    }

    //遍历结束后，判断最后一个元素是否为空格
    if(str[ len-1 ] != ' ')
    {
        count++;
    }
    return count;         //将单词个数返回
}


int main(int argc, const char *argv[])
{
    char s[100] = "";
    printf("请输入一段文本：");
    gets(s); 
    printf("一共有%d个单词\n", words(s));       //调用函数并输出
    return 0;
}

运行结果：

指针指向数组

1.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]

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

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

示例：

#include <stdio.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 <stdio.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");
}


/***************************主程序**********************/
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;
}

运行结果：

示例：

#include <stdio.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])   //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 <stdio.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 max_1(const int *arr, int size) {
    int max = arr[0]; 
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max; 
}

// 定义完成数组的逆序函数
void nixu(int *arr, int size) {
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i]; 
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
}

/***********************主程序**********************/
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);

    // 调用函数求最大值
    int max = max_1(score, size);
    printf("数组中的最大值为: %d\n", max);

    // 调用函数完成数组的逆置
    printf("逆置后的数组为：");
    nixu(score, size);
    for(int i=0;i<size;i++)
    {
        printf("%d\t",score[i]);
    }
    puts("");
    return 0;
}

运行结果：

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

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

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

示例：

#include <stdio.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 <stdio.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 <stdio.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 <stdio.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函数的功能

#include <stdio.h> 

// 自定义函数，实现strlen的功能，计算字符串的长度
int my_strlen(const char *str) {
    int count = 0; // 初始化计数器为0

    // 遍历字符串，直到遇到空字符'\0'
    while (*str != '\0') {
        count++; 
        str++; // 移动到下一个字符
    }
    return count; 
}

int main(int argc, const char *argv[])
 {
    char str[100]="";
    printf("请输入一个字符串：");
    scanf("%s", str); 
    int len = my_strlen(str);
    printf("字符串的长度是: %d\n", len); // 打印字符串的长度
    return 0; 
}

运行结果：

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

#include <stdio.h> 

// 自定义函数，实现strcpy的功能，复制字符串
char my_strcpy(char *dest, const char *src) {
    char *arr = dest; 
    // 遍历源字符串，直到遇到空字符'\0'
    while (*src != '\0') {
        *arr = *src; 
        arr++; // 移动目标字符串指针到下一个位置
        src++; // 移动源字符串指针到下一个位置
    }
    *arr = '\0';
    return dest;
}

int main(int argc, const char *argv[])
{
    char src[50]; // 定义一个字符数组，用于存储源字符串
    char dest[50]; // 定义一个字符数组，用于存储复制的目标字符串

    printf("请输入源字符串："); 
    scanf("%s", src); 
    // 调用自定义的my_strcpy函数复制字符串
    my_strcpy(dest, src);
    printf("复制后的字符串是: %s\n", dest); 
    return 0; 
}

运行结果：

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

#include <stdio.h>  // 引入标准输入输出库

// 自定义函数，实现strcmp的功能，比较两个字符串
int my_strcmp(const char *str1, const char *str2) {
    // 遍历两个字符串的每个字符
    while (*str1 != '\0' && *str2 != '\0') {
        // 如果当前字符不相等，返回它们的ASCII值差
        if (*str1 != *str2) {
            return *str1 - *str2;
        }
        // 移动到下一个字符
        str1++;
        str2++;
    }
    // 如果遇到字符串结束，比较两个字符串的长度
    // 如果str1先结束，返回-1；如果str2先结束，返回1；如果都结束，返回0
    return (*str1 == '\0' ? 0 : 1) - (*str2 == '\0' ? 0 : 1);
}

int main(int argc, const char *argv[])
{
    char str1[100]=""; 
    char str2[100]=""; 
    printf("请输入第一个字符串："); 
    scanf("%s", str1); 
    printf("请输入第二个字符串："); 
    scanf("%s", str2); 

    // 调用自定义的my_strcmp函数比较字符串
    int result = my_strcmp(str1, str2);
    if (result == 0) {
        printf("两个字符串相同。\n");
    } else if (result < 0) {
        printf("第一个字符串小于第二个字符串。\n");
    } else {
        printf("第一个字符串大于第二个字符串。\n");
    }
    return 0; 
}

运行结果：

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

#include <stdio.h> 

// 自定义函数，实现strcat的功能，连接两个字符串
void my_strcat(char *dest, const char *src) {
    char *arr = dest; 
    while (*arr != '\0') {
        arr++;
    }
    // 复制源字符串到目标字符串的末尾
    while (*src != '\0') {
        *arr = *src;
        arr++;
        src++;
    }
    *arr = '\0';
}

int main(int argc, const char *argv[])
{
    char str1[100]=""; 
    char str2[100] = ""; // 定义一个字符串，用于连接

    printf("请输入一个字符串："); 
    scanf("%s", str1); 
    printf("请输入一个连接字符串："); 
    scanf("%s", str2); 
    // 调用自定义的my_strcat函数连接字符串
    my_strcat(str1, str2);
    printf("连接后的字符串是: %s\n", str1); 
    return 0; 
}

运行结果：

5>自定义函数（my_strstr）实现求src字符串中是否包含子串dest字符串

#include <stdio.h> 

// 自定义函数，实现strstr的功能，检查src字符串中是否包含子串dest
char *my_strstr(const char *src, const char *dest) {
    int src_len = strlen(src); // 获取源字符串的长度
    int dest_len = strlen(dest); // 获取子串的长度

    // 循环遍历源字符串
    for (int i = 0; i <= src_len - dest_len; i++) {
        int j;
        // 检查从位置i开始的子串是否与dest匹配
        for (j = 0; j < dest_len && src[i + j] == dest[j]; j++) {
            if (src[i + j] != dest[j]) break;
        }
        if (j == dest_len) {
            return 1; // 返回子串在源字符串中的起始位置
        }
    }
    return 0; 
}

int main(int argc, const char *argv[])
{
    char src[200]=""; // 定义一个字符数组，用于存储源字符串
    char dest[50]="";  // 定义一个字符数组，用于存储要搜索的子串
    printf("请输入源字符串：");
    scanf("%s", src); 
    printf("请输入要搜索的子串："); 
    scanf("%s", dest); 
    // 调用自定义的my_strstr函数检查子串是否存在
    char *result = my_strstr(src, dest);
    if (result != 0) {
        printf("子串 '%s' 存在于源字符串中\n", dest);
    } else {
        printf("子串 '%s' 不存在于源字符串中\n", dest);
    }
    return 0; 
}

运行结果：