虚拟机0711课堂笔记及作业

已于 2024-07-12 11:09:59 修改
阅读量653 收藏 12
点赞数 12
文章标签： 笔记
于 2024-07-11 21:07:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68379095/article/details/140351616
版权

作业讲解：

完成学生管理系统

1>使用菜单完成

2>有学生的信息录入功能：输入学生个数，并将学生的姓名、分数录入

3>查看学生信息：输出所有学生姓名以及对应的分数

4>求出学习最好的学生信息：求最大值

5>按姓名将所有学生进行升序排序

6>按成绩将所有学生进行升序排序

要求每个功能使用函数完成

#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#define MAX 100         //能够容纳的总人数
int num = 0;        //实际使用的个数
//定义菜单函数
void printf_menu()
{
        printf("\t\t=====1、录入学生的信息=====\n");
        printf("\t\t=====2、查看学生信息=====\n");
        printf("\t\t=====3、求出学习最好的学生信息=====\n");
        printf("\t\t=====4、按姓名将所有学生进行升序排序=====\n");
        printf("\t\t=====5、按成绩将所有学生进行升序排序=====\n");
        printf("\t\t=====0、退出=====\n");
}


//定义录入学生信息函数
void lulu(char  student[][20],int score[])
{
    //实际学生人数的录入
    printf("请输入学生个数：");
    scanf("%d", &num);
    getchar();
    //循环录入学生信息
    for (int i = 0; i < num; i++) {
        printf("请输入%d个学生的姓名：", i + 1);
        scanf("%s", student[i]);
        printf("请输入%d个学生的分数：", i + 1);
        scanf("%d",& score[i]);
        printf("\n");
    } 
    printf("学生的信息录入成功\n");
}


//定义查看学生信息函数
void chakan(char  student[][20],int score[])
{
    printf("学生信息如下：\n");
    printf("\t姓名\t成绩\n");
    for (int i = 0; i < num; i++) {
        printf("\t%s\t%d\n", student[i], score[i]);
    }
}


//求出学习最好的学生信息
int max_1(char  student[][20],int score[])
{
    int max=score[0];
    int maxi=0;
    for(int i=1;i<num;i++)
    {
        if(score[i]>max)
        {
            max=score[i];
            maxi=i;
        }
        }
        printf("学习最好的学生为：%s,分数为:%d\n",student[maxi],score[maxi]);
}


//按姓名将所有学生进行升序排序
int xmshx(char  student[][20],int score[])
{
    printf("按姓名升序排后:\n");
    char temp[20]="";        //名字
    int maxj=0;         //成绩
    //排序
    for(int i=1;i<num;i++)
    {
        for(int j=0;j<num-i;j++)
        {
            if(strcmp(student[j],student[j+1])>0)
            {
                 //交换姓名
                strcpy(temp,student[j]); 
                strcpy(student[j],student[j+1]);
                strcpy(student[j+1],temp);
                // 交换成绩
                maxj=score[j]; 
                score[j]=score[j+1];
                score[j+1]=maxj;
            }
        }
    }
    //输出排序后学生的信息
    printf("\t姓名\t成绩\n");
    for(int i=0;i<num;i++)
    {
        printf("\t%s\t%d\n",student[i],score[i]);
    }
}


//按成绩将所有学生进行升序排序
int chjjx(char  student[][20],int score[])
{
    printf("按成绩升序排后:\n");
    char temp[20]="";
    int maxj=0;
    for(int i=1;i<num;i++)
    {
        for(int j=0;j<num-i;j++)
        {
            if(score[j]>score[j+1])
            {
                 //交换姓名
                strcpy(temp,student[j]);
                strcpy(student[j],student[j+1]);
                strcpy(student[j+1],temp);
                // 交换成绩
                maxj=score[j];
                score[j]=score[j+1];
                score[j+1]=maxj;
            }
        }
    }
    //输出排序后学生表信息
    printf("\t姓名\t成绩\n");
    for(int i=0;i<num;i++)
    {
        printf("\t%s\t%d\n",student[i],score[i]);
    }
}

/****************主程序****************/
int main(int argc, const char *argv[])
{
    //定义学生姓名数组
    char student[MAX][20]={""};         //姓名数组
    int score[MAX]={0};         //分数数组
    //做个菜单
    int menu=0;
    while(1)
    {
        printf_menu();      //调用菜单函数
        printf("请输入>>>");
        scanf("%d",&menu);
        getchar();   //吸收回车
        //多分支选择
        switch(menu)
        {
            case 1:
                {
                    //完成录入功能
                    lulu(student,score);
                }
                break;
            case 2:
                {
                    //完成查看功能
                    chakan(student,score);
                }
                break;
            case 3:
                {
                    //完成查看学习最好的功能
                    max_1(student,score);
                }
                break;
            case 4:
                {
                    //完成姓名排序功能
                    xmshx(student,score);
                }
                break;
            case 5:
                {
                    //完成成绩排序功能
                    chjjx(student,score);
                }
                break;              
            case 0: exit(0);         //退出程序
            default:printf("您输入的功能有误，请重新输入\n");
        }
    }
}

运行结果：

值传递与地址传递（非常重要）

1.1值传递

1>值传递的原理

2>说明：

值传递过程中，形参与实参操作的是不同的内存空间

当普通变量作为函数参数传递时，是单向的值传递，仅仅只是将实参的值，复制一份给形参使用，形参的改变不会影响到实参的值

3>代码实现

#include<stdio.h>
//定义交换函数
void swap_1(int m, int n)
{
    //完成两个数的交换
    int temp = m;
    m = n;
    n = temp;
    printf("交换后，swap_1:: m = %d, n = %d\n", m, n);
}

/*********************主程序*********************/
int main(int argc, const char *argv[])
{
    //定义两个变量
    int num = 520;
    int key = 1314;
    //调用交换函数
    swap_1(num, key);
    printf("交换后，main:: num = %d, key = %d\n", num, key);
    return 0;
}

运行结果：

1.2地址传递

1>地址传递原理图

2>说明：

当实参传递的是数组名、指针或变量的地址（&num）时，可以理解成是地址传递

地址传递过程中，形参与实参操作的是同一块内存空间

形参对内存空间进行改变时，实参也跟着一起改变

3>程序实现

#include<stdio.h>
//定义冒泡排序函数
void sort_up(int brr[], int n)
{
    printf("sizeof(brr) = %ld\n", sizeof(brr));   //
    //进行冒泡排序
    for(int i=1; i<n; i++)
    {
        for(int j=0; j<n-i; j++)
        {
            if(brr[j] > brr[j+1])
            {
                int temp = brr[j];
                brr[j] = brr[j+1];
                brr[j+1] = temp;
            }
        }
    }
    printf("排序结束\n");
}


/****************主程序********************/
int main(int argc, const char *argv[])
{
    //定义一个一位数组并初始化
    int arr[5] = {1,6,9,2,4};
    printf("sizeof(arr) = %ld\n", sizeof(arr));     //20

    //调用冒泡排序函数，完成升序排序
    sort_up(arr, 5);

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

运行结果：

递归函数

1.1递归的概念

所谓递归，就是一个函数直接或间接的形式调用自身，这样的函数调用，我们称为递归调用

示例：

#include<stdio.h>

//定义一个讲故事函数
void say_story()
{
    printf("从前有座山，山里有个庙，庙里有个老和尚给小和尚讲故事，故事里说：");
    say_story();
}


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

运行结果：

1.2递归条件

1>递归出口：用于终止递归进行进行的条件

2>递归表达式：能够让递归继续进行的函数调用

1.3递归思想

当直接解决规模比较大的问题不能进行时，需要先解决规模较小的原理一致的问题后，大的问题得以解决时，可以考虑使用递归        逐层分解，逐层合并

案例解析

1>求n！结果

分析：

代码：

//递归函数求阶乘
#include<stdio.h>
//定义一个递归函数
int jiecheng(int n)
{
	if(n==0)        //递归出口
	{
	       return 1;
	}
	else
	{
	      return n*jiecheng(n-1);       //递归表达式
	}
}
int main(int argc, const char *argv[])
{
	int n=0;
	scanf("%d",&n);
	int sum = jiecheng(n);      //求n!
	printf("%d\n",sum);
	return 0;
}

运行结果：

2>求斐波那契数列第n项的值

        1        1        2        3        5        8        13        21        。。。

代码：

//斐波那契
#include<stdio.h>
int fbnq(int n)
{
    if(n==1|| n==2)
    {
        return 1;
    }
    else
    {
        return fbnq(n-1)+fbnq(n-2);
    }
}
int main(int argc, const char *argv[])
{
	int n=0;
    printf("请输入斐波那契数列的项数：");
	scanf("%d",&n);
	int sum = fbnq(n);     
	printf("斐波那契数列第%d项的值为%d\n",n,sum);
	return 0;
}

运行结果：

3>使用递归函数实现，输入一个数，输出该数据的每一位

#include<stdio.h>
void print_num(int n)
{
    if(n<10)
    {
        printf("%d\t",n);
    } 
    else
    {
        //逆序输出
        printf("%d\t",n%10);        //按顺序输出    n/10
        print_num(n/10);                //按顺序输出    n%10
    }
}
int main(int argc, const char *argv[])
{
	int n=0;
	scanf("%d",&n);
    print_num(n);
    printf("\n");
	return 0;
}

运行结果：

指针概述

1.1指针相关概念

1>引入目的：能够从地址的角度，找到内存中的数据，而不是以变量的角度去找，效率较高

2>指针：就是内存地址编号

3>指针变量：由于指针这个地址编号很难记忆，我们引入指针变量存储指针

        存储地址的变量称为指针变量

4>指针变量中，指针存储地址，作为一个特殊的数据类型，其大小是固定的 8 字节

1.2指针变量的定义

1>定义格式：数据类型 * 指针名；

        例如：int * ptr;

2>指针变量的初始化

1、使用一个相同数据类型的变量的地址为其进行初始化

         int num = 520;

        int * ptr = &num; //将num的地址赋值个指针变量 ptr //定义一个指针变量ptr，指向num 2、使用一个已经初始化了的指针变量给一个新的指针变量进行初始化

        int * qtr = ptr; //此时表示两个指针变量同时存储了num的地址 int *qtr = &num;

3、使用地址的0 就是 NULL为其初始化

        int *wtr = NULL;

4、注意：没有初始化的指针变量不能直接使用，因为该指针变量中存储了一个随机地址，如果对其进行更改，可能会导致系统瘫痪

5、野指针：指向非法内存的指针称为野指针

产生情况：

        1）定义指针时，没有为其进行初始化

        2) 指向了一个内存空间，但是随着程序的进行，该内存空间被回收了，那么该指针也是野指针（悬空指针）

        3) 数组下标越界时，访问的地址也是野指针

3>指针变量的使用：使用运算符 ‘ * ’来取得指针变量中的值，我们也称该运算为 取值运算

1、指针变量在定义时，*号只是身份的象征，表示该语句定义的是指针变量

2、指针变量使用是，*号表示一个运算，取值运算，就是取得该指针变量指向的内存空间中的值

3、总结一下 * 号在C语言中的用途

        1) 表示乘号，是一个双目运算符

        2) 定义指针时，是身份的象征，表示定义的是指针变量

        3) 使用指针时，是取值运算符，表示取得指针变量指向的内存空间中的值

4、总结一下 & 在C语言中的用途

        1) 一个&表示双目运算符 按位 与运算

        2) 两个&&表示双目运算符 逻辑 与运算

        3) 一个&表示单目运算符 取址运算

5、&与*在指针的方面，互为逆运算

                int num = 520;

                int *ptr = &num;

        1) *&num ==> *（&num） ==> *(ptr) ==> num

        2) &*ptr ==> &(*ptr) ==> &(num) ==> ptr

        3) *&ptr ==>*(&ptr) ==> *(ptr的二级地址) ==> ptr

        4) &*num ==>报错

示例：

#include<stdio.h>
int main(int argc, const char *argv[])
{
    int num = 520;

    printf("num = %d\n", num);    //num的值
    printf("&num = %p\n", &num);   //输出变量的地址

    //定义指针变量指向num
    int *ptr = &num;        //该语句执行后：num <==> *ptr

    printf("ptr = %p\n", ptr);    //得到的是num的地址

    //通过ptr获取num的值
    printf("*ptr = %d\n", *ptr);         //输出的是num的值

    //解释解释什么叫等价
    num = 1314;
    printf("*ptr = %d\n", *ptr);         //输出的是num的值

    *ptr = 999;
    printf("num = %d\n", num);    //num的值
    return 0;
}

运行结果：

4>指针的大小与指针的类型之间的关系

        不同数据类型的指针所占内存空间都是一样的，都是指针的大小，32位系统下为4字节，64位系统下为 8字节

        指针的数据类型存在的意义，不是为了给指针分配内存空间的，而是为了指针偏移使用的

        不同类型的指针，在进行指针偏移时，偏移的大小跟指针的数据类型有关

        指针每偏移一个单位，内存空间就会偏移一个数据类型大小的字节数

        指针指向普通变量时，指针的偏移是没有意义的，但是，指针指向数组时，指针的偏移就有了现实的意义，表示指向上一个元素或者下一个元素的地址

示例：

#include<stdio.h>
int main(int argc, const char *argv[])
{
    char value_1 = 'H';      //定义字符数据
    short value_2 = 520;     //定义短整形数据
    int value_3 = 1314;       //定义整形数据
    double value_4 = 3.14;    //定义双精度浮点型数据

    //定义指针指向普通变量
    char *ptr1 = &value_1;
    short *ptr2 = &value_2;
    int * ptr3 = &value_3;
    double *ptr4 = &value_4;

    printf("ptr1 = %p\n", ptr1);
    printf("ptr2 = %p\n", ptr2);
    printf("ptr3 = %p\n", ptr3);
    printf("ptr4 = %p\n", ptr4);

    printf("*************************************\n");
    printf("ptr1+1 = %p\n", ptr1+1);
    printf("ptr2+1 = %p\n", ptr2+1);
    printf("ptr3+1 = %p\n", ptr3+1);
    printf("ptr4+1 = %p\n", ptr4+1);
    return 0;
}

运行结果：

5>指针可以使用的运算

        关系运算： == 判断两个指针是否指向同一个内存地址，ptr==NULL，判空指针

        数加运算：表示对指针进行偏移

        取值运算（*）、取址运算（&）

指针指向普通变量作为函数参数

1>指针作为函数的参数进行数据传递时，不一定是地址传递

作业

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

#include<stdio.h>
// 定义阶乘函数，参数n为底数，k为指数
int cifang(int n,int k)
{
    // 如果指数k为0或者底数n为0，返回1
    if(k==0 || n==0)
    {
        return 1;
    } 
    else        // 如果不是0，执行递归调用
    {
        // 计算n的k次幂
        return n*cifang(n,k-1);
    }
}
int main(int argc, const char *argv[])
{
    // 定义两个整数变量n和k，用于存储用户输入的底数和指数
	int n=0,k=0;
    // 提示用户输入两个数
    printf("请输入两个数：");
	scanf("%d%d",&n,&k);
    int s=cifang(n,k);   // 调用cifang函数计算n的k次幂，结果存储在变量s中
    printf("%d ^ %d= %d\n",n,k,s);
	return 0;
}

运行结果：

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

#include <stdio.h> 

// 定义计算字符串长度函数
int strlen_1( char *str) {
    // 如果到达字符串末尾（'\0'），返回0
    if (*str == '\0') {
        return 0;
    } 
    else
     {
        // 否则，返回当前字符的1加上剩余字符串的长度
        return 1 + strlen_1(str + 1);
    }
}

int main(int argc, const char *argv[])
 {
    char str[100]="";      // 定义一个字符数组，用于存储输入的字符串
    printf("请输入一个字符串："); 
    scanf("%s", str); 

    // 调用递归函数计算字符串长度，并打印结果
    int len = strlen_1(str);
    printf("字符串的长度是: %d\n", len);
    return 0;  
}

运行结果：

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

#include <stdio.h>

// 定义hannuota函数，用于解决汉诺塔问题
int hannuota(int n)
{
    //当只有一个盘子时，直接移动到目标
    if(n==1)
    {
        return 1;
    }else
    {
        //2层汉诺塔=1层*2+1，n层=n-1层的*2+1
        return (hannuota(n-1)*2+1);
    }
}

int main(int argc, char const *argv[])
{
    int n=0;
    printf("请输入汉诺塔盘子的个数：");
    scanf("%d",&n);
    printf("需要%d次\n",hannuota(n));
    return 0;
}

运行结果：

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

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

// 定义paixu函数，使用冒泡排序对字符串进行从大到小排序
void paixu(char *str) {
    int len = strlen(str); // 获取字符串长度
    int i, j;
    char temp; // 用于交换字符的临时变量

    // 外层循环控制比较的轮数
    for (i = 1; i < len; i++) {
        // 内层循环进行相邻字符的比较和交换
        for (j = 0; j < len - i; j++) {
            // 如果当前字符小于下一个字符，则交换它们
            if (str[j] < str[j + 1]) {
                //交换三部曲
                temp = str[j];
                str[j] = str[j + 1];
                str[j + 1] = temp;
            }
        }
    }
}

int main(int argc, const char *argv[])
{
    // 定义一个字符数组，用于存储输入的字符串
    char str[100]=""; 
    printf("请输入一个字符串：");
    scanf("%s", str);

    // 调用paixu函数对字符串进行从大到小排序
    paixu(str);
    printf("排序后的字符串: %s\n", str);
    return 0; 
}

运行结果：

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

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

// 定义huiwen函数，检查传入的字符串是否是回文
int huiwen(char *str) {
    int left = 0; // 初始化左指针
    int right = strlen(str) - 1; // 初始化右指针

    // 循环比较左右两端的字符，直到它们相遇或交错
    while (left < right) {
        // 如果左右两端的字符不相等，则不是回文
        if (str[left] != str[right]) {
            return 0; // 返回0，表示不是回文
        }
        left++; // 移动左指针向右
        right--; // 移动右指针向左
    }

    return 1; // 如果所有对应的字符都相等，则返回1，表示是回文
}

int main(int argc, const char *argv[])
 {
    // 定义一个字符数组，用于存储输入的字符串
    char str[100]=""; 
    printf("请输入一个字符串："); 
    scanf("%s", str);

    // 调用huiwen函数检查字符串是否是回文
    if (huiwen(str)) {
        printf("'%s' 是回文字符串\n", str);
    } else {
        printf("'%s' 不是回文字符串\n", str);
    }
    return 0; 
}

运行结果：

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

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int a = 0x12345678;         //定义变量存储多字节整数
    char *p = (char *)&a;
    if(*p == 0x12)
    {
        printf("主机是大端存储\n");
    }
    else
    {
        printf("主机是小端存储\n");
    }
    return 0;
}

运行结果：

7>

代码有问题（中间的标点符号后面需要加空格）

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

// 定义countWords函数，使用指针遍历字符串并统计单词数
int countWords(char *str)
 {
     // 单词计数器初始化为0
    int count = 0; 
    char *word = str; // word指针用于定位单词的开始

    while (*str != '\0') {
        // 检查空格
        while (*str==32) {
            str++;
        }
        // 检查是否到达字符串末尾或遇到空格，以确定单词的边界
        if (*str != '\0' && *str!=32 ) {
            // 找到单词的开始
            word = str;
            // 移动指针到单词的末尾
            while (*str != '\0' && *str!=32) {
                str++;
            }
            // 单词结束，计数加1
            count++;
        }
    }
    return count; // 返回单词计数
}

int main(int argc, const char *argv[])
 {
     // 定义一个字符数组，用于存储输入的文本
    char text[1000]="";
    printf("请输入一段文本："); 
    gets(text, sizeof(text));

    // 调用countWords函数统计单词数
    int wordCount = countWords(text);
    printf("文本中的单词数为: %d\n", wordCount); // 打印单词数
    return 0; 
}

运行结果：

m0_68379095
关注
  • 12
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
虚拟机0709课堂笔记及作业
m0_68379095的博客
07-09 569
1、需要进行首尾交换的次数是MAX/2(MAX表示数组的长度)2、交换双方：3、交换三部曲数据类型 数组名[常量1][常量2]；常量1：表示定义数组时数组的行数，也可以理解成一维数组的个数常量2：表示定义数组时的列数，也可以理解成每个一维数组的长度。
虚拟机0710课堂笔记及作业
m0_68379095的博客
07-10 531
1>函数：执行特定功能的一段代码块2>定义格式： 返回值类型 函数名(参数列表) { 函数体代码 }1、返回值类型：函数执行后，向外界返回的一个结果值，可以有结果(非void)，也可以没有结果（void）定义函数时：有返无返看主调，主调函数想要数据，就定义有返回值函数，主调函数要什么类型的结果，就定义什么数据类型主调函数不要数据，就定义void类型2、函数名：是一个标识符，要符合命名规则3、（）：小括号是函数的标识，即使是没有参数的函数调用时也要将括号加上。
虚拟机第三次作业
Pwg123456的博客
01-19 335
1、新建几个普通用户wukong, wuneng，wujing，他们都属于xiyouji组的成员，其中wujing没有 和系统交互的shell (没有和系统交互的shell就是无法登陆系统)。 2、wukong和wuneng的密码都为redhat。 3、设置wukong可以新建用户，设置wuneng可以删除和修改用户信息。 1、复制/var/log/message 文件到当前用户的家目录 2、vim编辑家目录的 message 文件，显示出行号， 将全文中的关键字root替换为r
虚拟机第二课
Pwg123456的博客
01-16 1923
1.使用一条命令行 *** 命令 Mkdir /mnt/{boot/grub,sysroot/{proc,sys,bin,sbin,lib/modules,usr/{bin,sbin,lib},var/{run,log,lock},etc/init.d,dev,home,root,tmp}} -p 在/mnt下创建boot和sysroot目录 在/mnt/boot下创建grub目录 在/mnt/sysroot下创建proc,sys,bin,sbin,lib,usr,var,etc,dev,home,r.
linux课堂笔记和作业
10-31
根据提供的“Linux课堂笔记和作业”内容，我们可以总结并扩展以下关键知识点： ### Linux 基础命令操作 1. **虚拟机管理命令**： - `rht-vmctl start desktop`：启动桌面虚拟机。 - `rht-vmctl view desktop`：...
Linux作业课堂笔记
10-31
根据提供的“Linux作业课堂笔记”内容，我们可以提炼并扩展出以下关键知识点： ### Linux 基础命令操作 1. **虚拟机管理命令** - `rht-vmctl start desktop`：启动桌面虚拟机。 - `rht-vmctl view desktop`：...
linux作业和课堂笔记
10-31
以上是Linux作业和课堂笔记的一部分内容，涵盖了RHEL的虚拟机管理、Shell命令的基本使用、Gnome桌面环境的操作以及密码管理等关键知识点。理解并熟练运用这些基础知识，对于Linux用户和管理员来说至关重要。
Java学习资料 学习资料、课堂作业、笔记
06-29
12. **JVM原理**: 学习Java虚拟机的工作原理，包括类加载机制、内存管理、垃圾收集，有助于优化程序性能。 13. **单元测试**: 使用JUnit或TestNG进行单元测试，确保代码的质量和可靠性。 14. **Maven项目管理**: ...
java课堂笔记
04-16
总结来说，"java课堂笔记"涵盖了从基础的Java语法到高级的Web开发和企业级应用的知识，同时融入了Unix/Linux操作系统的使用技巧，对于Java开发者来说是一份全面的学习资料。通过深入学习和实践这些知识点，开发者...
Freertos学习笔记
qq_45031559的博客
08-21 585
Freertos学习笔记
树莓派开发笔记02-树莓派的GPIO口输出控制
wan1234512的博客
08-18 912
本文详细描述了树莓派GPIO编程的3种方式，wiringPi库、BCM2835库、Python库，以及分别使用这几种库进行GPIO的输出控制。
通信原理学习笔记
X131644的博客
08-18 348
一个手机通话需要经过下面三个网络 类别 接入网（Access Network） 承载网（Transport Network） 核心网（Core Network） 定义 连接终端用户与电信网络的部分。 在接入网和核心网之间传输数据的网络。 处理、交换和管理通过承载网传输的数据。 主要功能 - 用户接入- 信号传输- 覆盖局部区域 - 高效传输- 汇聚与分发- 资源管理 - 呼叫控制- 数据交换- 计费与用户管理- 服务提供 常见技术 - 有线接入（DSL, FTTH）- 无线接入（2G
树链剖分学习笔记
mikeshizi1234的博客
08-19 666
首先，因为后面在讲解的时候会涉及到一些名词，我们来解释一下。重子：对于每一个非叶子节点，它的儿子中以那个儿子为根的子树节点数最大的儿子为该节点的重子。轻子：跟重子相反，一个点不是重子就是轻子（叶子节点除外），对于每一个非叶子节点，它的子中非重儿子的剩下所有儿子即为轻子。重边：一个父亲连接他的重子的边称为重边。轻边：跟重边相反，每一条边不是重边就是轻边。重链：重链的要求非常难，一点是相邻的重边连起来一个重子的链就是重链。如果有还不理解的同学，我们来画一张图来找一找这些东西在哪里。
全栈笔记_浏览器工作原理篇（浏览器架构）
wwv的博客
08-20 85
浏览器是用于访问互联网资源的软件，其工作原理涉及多个组件的协同工作，包括用户界面、浏览器引擎、渲染引擎、JavaScript解释器和网络模块。
qt笔记之纯qml项目详解
小勇博客
08-17 982
在 Qt 中，确实可以创建纯 QML 项目。纯 QML 项目主要用于构建基于 QML 的 UI，而无需 C++ 代码。点击“运行”按钮，Qt Creator 将会启动应用程序，并显示一个窗口，上面写着“Hello, QML!文件是用于 Qt Quick 应用程序的用户界面文件，通常使用 Qt Creator 来编辑和设计。这些文件是为 Qt Widgets 应用程序设计的用户界面文件，使用 XML 格式。如果使用自定义模块，可以在这个文件中指定模块路径。但对于简单项目，这个文件可以是空的。
24/8/18算法笔记 目标导向强化学习
yyyy2711的博客
08-18 493
初始化DDPG模型data = {'over':[],#Data采样函数#采样结果sample = {'over':[],#采样N个数据#随机一局游戏#随机游戏中的一步，这里除了最后一步#提取数据#设置fake goal#随机选择step后面的某一步#以后面某个步的状态为一个伪的终点，也就是希望先走到这里再说#求二范数mod = [#再自己重新计算reward和over#以伪终点构建新的state#计算最后10个数据reward_sum的值。
React学习笔记，从入门到砸门
留白声的博客
08-20 1011
react详细自我学习笔记，内容包括JSX、Redux、Router等
谷粒商城实战笔记-236~238-商城业务-购物车-环境搭建
最新发布
epitomizelu的专栏
08-22 606
这一节的内容主要分析购物的业务逻辑和设计存储购物车的选型及数据结构。①把整个购物车封装为一个对象CartVo。
Java并发编程与虚拟机深度解析笔记
笔记详细介绍了垃圾收集（GC）的基本原理，各种GC算法，HotSpot虚拟机的实现，以及如何解读GC日志。通过内存分配演示和GC总结，读者可以深入理解Java程序的内存管理。 此外，笔记还包含了一些参考资料，方便读者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值