linux学习day13

最新推荐文章于 2024-10-30 13:57:55 发布
最新推荐文章于 2024-10-30 13:57:55 发布
阅读量555 收藏 18
点赞数 25
文章标签： linux 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuziNO_1/article/details/140504012
版权

共用体

1.1 引入目的：

当需要多个变量共享一块内存时，可以使用共用体

1.2 定义及初始化

1.2.1 概念：

由相同数据类型或不同数据类型构成的集合，但是，该集合中的成员共享同一块内存空间

 1.2.2 定义格式

union 结构体名称

{

        成员类型1 成员变量1;

        成员类型2 成员变量2；

        。。。

        成员类型n 成员变量n;

};

1.2.3 共用体初始化 

1、共用体初始化方式跟结构体初始化方式一致

2、共用体变量初始化时，只给定一个值即可，就是第一个成员的值

4> 共用体访问成员跟结构体一致

5> 共用体成员中可以包含基本数据类型，也可以包含构造数据类型

6> 共用体变量的大小，是所有成员中占内存最大的成员的大小

7> 共用体变量一般不作为函数 参数传递

#include<myhead.h>

//定义共用体类型
union Info
{
    char value_a;
    int value_b;
    double value_c;
};



int main(int argc, const char *argv[])
{
    //测试共用体类型的大小
    printf("sizeof union Info = %ld\n", sizeof(union Info));  //8

    //定义共用体变量
    union Info temp = {30};   //只需要初始化一个值

    //访问成员
    temp.value_a = 100;
    //printf("value_a = %d\n", temp.value_a);    //100
    temp.value_b = 520;
    //printf("value_a = %d\n", temp.value_b);    //
    temp.value_c = 3.14;
    printf("value_c = %.2lf\n", temp.value_c);    //3.14
    printf("value_b = %d\n", temp.value_b);    //520?
    printf("value_a = %c\n", temp.value_a);    //100?

    return 0;
}

 

实战常用例子
#include<myhead.h>

//定义共用体类型
union Info
{
    char ch;        //字符数据
    int num;          //整形数据
} temp;



int main(int argc, const char *argv[])
{
    //使用共用体判断自己的主机的大小端问题
    temp.num = 0x12345678;

    //判断temp.ch的值即可
    if(temp.ch == 0x12)
    {
        printf("big edinan\n");
    }else if(temp.ch == 0x78)
    {
        printf("little endian\n");
    }
    

    return 0;
}

类型重定义

2.1 引入目的

当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，例如：unsigned long int ,struct Stu

为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字

2.2 使用方式

        2.2.1> 类型重定义，我们引入了关键字 typedef

        2.2.2> 使用方式： typedef 旧名字 新名字；

                                例如：typedef unsigned long int uint64;

2.3 目前所接触的数据类型

2.3.1 总结定义的变量

int a; //定义一个普通变量,变量名为 a

int arr[5]; //定义一个长度位5的整型数组，数组名位arr

int *ptr; //定义一个一级指针变量，变量名为ptr

int **pptr; //定义了一个二级指针变量，变量名为pptr

int *ptr_arr[5]; //定义一个长度为5的指针数组，数组名为ptr_arr

int (*arr_ptr)[5]; //定义了一个数组指针，指向长度为5的数组，变量名为arr_ptr

int (*fun_ptr)(void); //定义了一个函数指针变量，指向返回值为int参数为空的函数，变量名为fun_ptr

int (*fun_ptr_arr[5])(void); //定义了一个函数指针数组，数组名为fun_ptr_arr

struct Info {...} buf; //定义了一个结构体变量

2.3.2 提取类型

int ; //定义一个普通变量类型

int [5]; //定义一个长度位5的整型数组类型

int *; //定义一个一级指针变量类型

int **; //定义了一个二级指针变量类型

int *[5]; //定义一个长度为5的指针数组类型

int (*)[5]; //定义了一个数组指针类型

int (*)(void); //定义了一个函数指针变量类型

int (*[5])(void); //定义了一个函数指针数组类型

struct Info {...} ; //定义了一个结构体类型

2.3.3 将上面类型进行重定义

typedef int a; //定义一个普通变量,变量名为 a

typedef int arr[5]; //定义一个长度位5的整型数组，数组名位arr

typedef int *ptr; //定义一个一级指针变量，变量名为ptr

typedef int **pptr; //定义了一个二级指针变量，变量名为pptr

typedef int *ptr_arr[5]; //定义一个长度为5的指针数组，数组名为ptr_arr

typedef int (*arr_ptr)[5]; //定义了一个数组指针，指向长度为5的数组，变量名为arr_ptr

typedef int (*fun_ptr)(void); //定义了一个函数指针变量，指向返回值为int参数为空的函数，变量名为fun_ptr

typedef int (*fun_ptr_arr[5])(void); //定义了一个函数指针数组，数组名为fun_ptr_arr

typedef struct Info {...} buf; //定义了一个结构体类型

#include<myhead.h>

typedef int int32;        //给int类型重新起个名字
typedef int * ptr;       //给int *重新命名
typedef int arr[5];       //给int [5] 重新命名
typedef int (*arr_ptr)[5];   //给数组指针重命名
typedef struct  Stu
{
    char name[20];    //姓名
    int age;
    double score;
}Stu;                   //给结构体重新命名



int main(int argc, const char *argv[])
{
    int32 num = 520;    //使用重命名的类型定义变量
    printf("sizeof num = %ld\n", sizeof(num));    //4

    ptr p = &num;           //定义的p是一个指针变量
    printf("sizeof p = %ld\n", sizeof(p));    //8

    arr a = {1,2,3,4,5};                //此时a就是一个数组名，长度为5
    printf("sizeof a = %ld\n", sizeof(a));    //20

    arr_ptr ap;            //此时ap就是一个数组指针变量
    ap = &a;
    printf("sizeof ap = %ld\n", sizeof(ap));    //8

    Stu s = {"二狗", 20, 80};    //定义一个结构体变量
    printf("sizeof s = %ld\n", sizeof(s));    //32

    return 0;
}

2.3.4 #define 与 typedef的区别

1、#define是宏定义，使用宏名取代字符串，typedef是进行类型重命名，要求必须给定的是数据类型

2、#define是预处理指令，在预处理时，进行替换，typedef时C语言语句，发生在程序执行阶段

3、在使用上面两种方式命名一个变量时，没有太大区别，但是，命名多个指针类型时，就有区别了

#include<myhead.h>
#define my_int int *            //宏定义
typedef int * My_int;            //类型重定义





int main(int argc, const char *argv[])
{
    my_int a,b;          //定义两个变量 int a,b;
    //int *a, b;

    My_int m,n;          //定义两个普通变量 int m,n;
    //int *a;   int *b;

    printf("sizeof a = %ld, sizeof b = %ld\n", sizeof(a), sizeof(b));
    printf("sizeof m = %ld, sizeof n = %ld\n", sizeof(m), sizeof(n));



    return 0;
}

2.3.5 类型重定义，也可以连续定义

#include<myhead.h>

typedef int my_int, *my_ptr;     //表示 my_int 是int类型， my_ptr 是int *类型

typedef struct Node
{
    int data;          //数据域
    struct Node *next;    //指针域
}Node, * Node_ptr;        //类型重定义两个名字

 
//此后，Node定义的变量是结构体普通变量
//Node_ptr定义的变量是结构体指针变量



int main(int argc, const char *argv[])
{
    my_int num = 520;
    my_ptr ptr = &num;

    printf("sizeof(num) = %ld, sizeof(ptr) = %ld\n", sizeof(num), sizeof(ptr));
    printf("sizeof(Node) = %ld, sizeof(Node_ptr) = %ld\n", \
            sizeof(Node), sizeof(Node_ptr));
    

    return 0;
}

内存划分

1> 一个进程一旦启动后，操作系统会为其分配 4G 的虚拟内存

2> 分为两部分：内核空间（1G高地址）、用户空间（3G低地址）

3> 多个进程独立拥有0--3G的用户空间，共享3--4G的内核空间

3> 用户空间又分为多个部分，具体如同所示

4> 通过指令：cat /proc/进程ID/maps 可以查看当前进程的内存分布 

564a73455000-564a73456000 r-xp 00000000 08:01 402924 /home/ubuntu/24061/数据结构/day2/a.out //对应 .text段

564a73655000-564a73656000 r--p 00000000 08:01 402924 /home/ubuntu/24061/数据结构/day2/a.out //对应 .ro段

564a73656000-564a73657000 rw-p 00001000 08:01 402924 /home/ubuntu/24061/数据结构/day2/a.out //对应 .bss 和 .data段

564a7451b000-564a7453c000 rw-p 00000000 00:00 0 [heap] //对应堆区 7f22cfd55000-7f22cff3c000 r-xp 00000000 08:01 924106 /lib/x86_64-linux-gnu/libc-2.27.so //动态库的空间

7f22cff3c000-7f22d013c000 ---p 001e7000 08:01 924106 /lib/x86_64-linux-gnu/libc-2.27.so

7f22d013c000-7f22d0140000 r--p 001e7000 08:01 924106 /lib/x86_64-linux-gnu/libc-2.27.so

7f22d0140000-7f22d0142000 rw-p 001eb000 08:01 924106 /lib/x86_64-linux-gnu/libc-2.27.so 7f22d0142000-7f22d0146000 rw-p 00000000 00:00 0

7f22d0146000-7f22d016d000 r-xp 00000000 08:01 924078 /lib/x86_64-linux-gnu/ld-2.27.so 7f22d0358000-7f22d035a000 rw-p 00000000 00:00 0

7f22d036d000-7f22d036e000 r--p 00027000 08:01 924078 /lib/x86_64-linux-gnu/ld-2.27.so

7f22d036e000-7f22d036f000 rw-p 00028000 08:01 924078 /lib/x86_64-linux-gnu/ld-2.27.so

7f22d036f000-7f22d0370000 rw-p 00000000 00:00 0

7ffe04466000-7ffe04487000 rw-p 00000000 00:00 0 [stack] //栈区

7ffe04595000-7ffe04598000 r--p 00000000 00:00 0 [vvar]

7ffe04598000-7ffe04599000 r-xp 00000000 00:00 0 [vdso] ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0 [vsyscall] //内核空间

 

#include<myhead.h>

int num;                //在全局区的 .bss
static int key;         //在全局区的 .bss
int num_1 = 520;         //在全局区的 .data， 520在.ro段
char *ptr = "hello";     //ptr在全局区的.data段，"hello"在.ro段




int main(int argc, const char *argv[])
{
    int value;           //栈区，随机值
    static int value_1;        //在全局区的 .bss段
    static int value_2 = 1314;   //value_2在全局区的.data段， 1314在.ro段

    return 0;
}

动态内存分配和回收

1> 对于堆区空间的数据，我们也可以利用起来，对于栈区的内存空间，会随着所在的函数空间的结束而结束

2> 可以在堆区由程序员手动申请一片内存来使用，其生命周期到程序员手动释放该空间为止，或者整个程序结束

 3> 对堆区空间的使用函数

#include <stdlib.h>

        void *malloc(size_t size);

        功能：在堆区申请出给定字节大小的空间，并返回该空间的内存起始地址

        参数：要申请的空间大小，以字节为单位

        返回值：成功分配空间后，返回该空间的起始地址，失败返回NULL

        注意：由于返回结果是一个万能指针，想要使用该内存中的内容时，需要转换为具体的指针

        void free(void *ptr);

        功能：释放给定的堆区空间

        参数：堆区空间的起始地址

        返回值：无

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //申请1字节空间
    char *ptr = (char *)malloc(1);            //在堆区申请1字节大小的空间
    //ptr占8字节，在栈区
    //malloc(1) 申请的是堆区空间
    
    printf("*ptr = %d\n", *ptr);       //0
    *ptr = 100;                  //给堆区空间进行赋值
    printf("*ptr = %d\n", *ptr);       //100

    //申请4字节空间大小
    int *qtr = (int *)malloc(sizeof(int));    //单个数据申请
    printf("*qtr = %d\n", *qtr);       //0


    //连续数据的申请
    int *dtr = (int *)malloc(sizeof(int) * 5);
    for(int i=0; i<5; i++)
    {
        printf("%d\t", dtr[i]);
    }
    printf("\n");

    //释放空间
    free(ptr);
    free(qtr);
    free(dtr);
    ptr = NULL;
    qtr = NULL;
    dtr = NULL;


    return 0;
}

练习：

在堆区申请5个int类型的内存空间，用于存储5个学生的成绩

定义函数实现：

完成学生成绩的录入、输出、排序

#include<myhead.h>

//定义申请空间的函数
int *create()
{
    //在堆区申请5个int类型的空间大小
    int *ptr = (int *)malloc(sizeof(int) * 5);
    if(NULL == ptr)
    {
        printf("申请失败\n");
        return NULL;
    }
    
    //程序执行至此，表示内存申请成功
    //给内存空间进行初始化
    memset(ptr, 0, sizeof(int)*5);

    //将内存地址返回
    return ptr;
}

//成绩的录入
void input(int *ptr)
{
    //完成录入
    if(NULL == ptr)
    {
        printf("录入失败\n");
        return ;
    }
    //正常录入工作
    for(int i=0; i<5; i++)
    {
        printf("请输入第%d个学生的成绩:", i+1);
        scanf("%d", &ptr[i]);
    }
    printf("录入成功\n");
}

//输出成绩
void output(int *ptr)
{
    //判断逻辑
    if(NULL == ptr)
    {
        printf("error\n");
        return ;
    }

    //正常输出
    printf("学生分数分别是：");
    for(int i=0; i<5; i++)
    {
        printf("%d\t", ptr[i]);
    }
    printf("输出结束\n");
}

//定义排序函数
void sort(int *ptr)
{
    //判断逻辑
    if(NULL == ptr)
    {
        printf("error\n");
        return ;
    }

    //排序
    for(int i=1; i<5; i++)
    {
        for(int j=0; j<5-i; j++)
        {
            if(ptr[j] < ptr[j+1])
            {
                int temp = ptr[j];
                ptr[j] = ptr[j+1];
                ptr[j+1] = temp;

            }
        }
    }

    printf("排序成功\n");
}

//释放内存的函数
void destroy(int *ptr)
{
    //释放内存
    if(NULL != ptr)
    {
        free(ptr);       //释放空间
        ptr = NULL;
    }
}




/*********************主程序***********************/
int main(int argc, const char *argv[])
{
    //调用创建函数，创建一个成绩表
    int * P = create();
    if(NULL == P)
    {
        return -1;
    }

    //调用录入函数
    input(P);

    //调用输出函数
    output(P);

    //排序函数
    sort(P);

    //输出成绩
    output(P);

    //释放内存的函数
    destroy(P);
    P = NULL;

    //调用输出函数
    output(P);

    return 0;
}

预处理指令

1> 预处理指令，执行在分步编译的预处理阶段，所有的预处理指令都是以#开头，没有分号结束

2> 文件包含指令：相当于将引入的文件中的内容，在引入部分写了一份

        1、 #include<stdio.h> :直接使用的是系统提供的头文件 /usr/include #include"myhed.h" :从当前路径下，找该头文件，如果有，则直接使用，如果没有再向系统库中找

         2、头文件中：主要完成函数的声明、全局变量的定义、结构体类型的声明

3> 宏定义指令：就是定义一个常量，用宏名表示后面的字符串，使用中，只替换不计算不做正确性检测

        1、#define 宏名 字符串

        2、#define 宏名（参数） 含参字符串

        3、#undef 宏名 ：表示取消宏定义

#include<myhead.h>

#define MAX 40




int main(int argc, const char *argv[])
{
    printf("%d\n", MAX);          //使用宏   40

#undef MAX
#define MAX 100

    printf("%d\n", MAX);          //100
    

    return 0;
}

 条件编译

1、 #if 数据

        程序代码；

        #endif

判断数据是否为真，如果为真，则编译程序代码，否则不编译程序代码

2、#if 数据

        程序代码1;

        #elif 程序代码2；

        #endif

判断数据是否为真，如果为真，编译程序代码1，否则编译程序代码2

3、#ifdef 宏名

        程序代码；

        #endif

判断宏明是否被定义，如果有该宏名，则编译程序代码，否则不编译

4、#ifndef 宏名

        程序代码；

        #endif

判断宏明是否被定义，如果没有该宏名，则编译程序代码，否则不编译

//防止头文件重复包含
#ifndef TEST_H
#define TEST_H

int *create()  ;         //创建函数的声明


void input(int *ptr);     //录入函数的声明


void output(int *ptr) ;    //输出函数的声明

void sort(int *ptr);          //排序函数的声明

void destroy(int *ptr)   ;    //销毁函数的声明

int num = 520;          //定义一个全局变量

#endif

 分文件编译

作业

完成学生信息管理系统

要求：定义一个班级，包括多个学生，以及记录实际学生的个数

1> 完成班级的创建，创建时，需要传递班级实际人数

2> 完成班级学生的信息录入工作

3> 完成将班级学生按成绩进行降序排序工作

4> 输出班级中成绩最好和最差学生的信息

5> 完成信息的输出工作

6> 完成班级的销毁工作

要求：班级创建在堆区，尽量份文件编译wan'c

 #define MAX 100 //最大容量

//定义学生类型

struct Stu

{

char name[20];

int age;

double score;

};

//定义班级类型

struct Class

{

struct Stu student[MAX]; //存放学生的容器

int size; //实际人数

};

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

#define MAX 100

//定义学生数据
struct Stu
{
    char name[20];//姓名
    int age;//年龄
    double score;//成绩
};

//定义班级类型
struct Class
{
    struct Stu student[MAX];       //存放学生的容器
    int size;                      //实际人数
};

struct Class *create(){
    //开辟空间
    struct Class *class=(struct Class *)malloc(sizeof(struct Class *)*MAX);
    if(NULL==class){
        printf("申请失败\n");
        return NULL;
    }
    //初始化
    memset(class, 0, sizeof(struct Class *)*MAX);
    printf("申请成功\n");
    return class;
}

void menu(){
    printf("\t=====1.信息录入\n");
    printf("\t=====2.信息输出\n");
    printf("\t=====3.成绩排序\n");
    printf("\t=====4.分数最值查询\n");
    printf("\t=====5.成绩删除\n");
    printf("\t=====0.退出\n");
    printf("\t请输入选项\n");
}

void input(struct Class *class){
    if(NULL == class)
    {
        printf("录入失败\n");
        return;
    }
    printf("请输入学生人数");
    scanf("%d",&class->size);
    for(int i=0;i<(class->size);i++){
        printf("请输入第%d个学生的姓名:", i+1);
        scanf("%s", class->student[i].name);
        printf("请输入第%d个学生的年龄:", i+1);
        scanf("%d", &class->student[i].age);
        printf("请输入第%d个学生的成绩:", i+1);
        scanf("%lf",&class->student[i].score);
        printf("\n");
    }
    printf("信息录入成功\n");
}

void output(struct Class *class){
    printf("姓名\t\t年龄\t成绩\t\n");
    for(int i=0;i<(class->size);i++){
        printf("%s\t\t%d\t%lf\t\n",class->student[i].name,class->student[i].age,class->student[i].score);
    }
}

void xu(struct Class *class){
    for(int i=1;i<(class->size);i++){
        for(int j=0;j<(class->size)-i;j++){
            if((class->student[j].score) < (class->student[j+1].score)){
                struct Stu temp=class->student[j];
                class->student[j]=class->student[j+1];
                class->student[j+1]=temp;
            }
        }
    }
    printf("排序成功\n");
}

void max1(struct Class *class){
    int max=class->student[0].score;
    int maxi=0;
    int min=class->student[0].score;
    int mini=0;
    for(int i=1;i<(class->size);i++){
        if(max<class->student[i].score){
            max=class->student[i].score;maxi=i;
        }
        if(min>class->student[i].score){
            min=class->student[i].score;mini=i;
        }
    }
    printf("成绩最好的是%s,成绩为%d\n",class->student[maxi].name,max);
    printf("成绩最差的是%s,成绩为%d\n",class->student[mini].name,min);   
}

void destroy(struct Class *class)
{
    //释放内存
    if(NULL != class)
    {
        free(class);       //释放空间
        class = NULL;
    }
    printf("释放空间成功\n");
}

int main(){
    struct Class *class = create();
    while(1){
        menu();
        int n=-1;
        scanf("%d",&n);
        switch(n){
            case 1:
                input(class);
                break;
            case 2:
                output(class);
                break;
            case 3:
                xu(class);
                break;
            case 4:
                max1(class);
                break;
            case 5:
                destroy(class);
                break;
            case 0:
                return 0;
            default:
                printf("输入错误\n");
        }
    }
}

wuziNO_1
关注
Linux学习笔记day01
Wynb1020的博客
01-07 1392
Linux文件与目录结构 Linux一切皆文件 目录结构 目录名 释义 /bin (/usr/bin、/usr\local\bin) 是Binary的缩写, 这个目录存放着最经常使用的命令 /home 存放普通用户的主目录，在Linux中每个用户都有一个自己的目录，一般该目录名是以用户的账号命名的。 /root 该目录为系统管理员，也称作超级权限者的用户主目录。 /etc 所有的系统管理所需要的配置文件和子目录 /usr 这是一个非常重要的目录，用户的很多应用程序和文件都放
Linux学习手册大全
热门推荐
小龙博客
07-17 3万+
、 Linux大全1、虚拟机安装2、虚拟机网络连接方式3、安装vmtools4、虚拟机目录4.1、目录含义4.2、Linux颜色含义5、远程登录软件6、编辑命令7、用户管理8、CentOS7找回root密码9、文件目录指令pwd指令ls指令cd指令mkdir指令rmdir指令touch指令cp指令rm指令mv指令cat指令more指令less指令echo指令head指令tail指令指令>和指令>>ln指令history指令10、日期指令11、查找指令1、find指令2、locate指令3、
Linux学习-day2
qq_41784433的博客
04-08 1324
文章目录1、远程登录和文件传输2、vi和vim编辑器2.1、三种模式2.2、快捷键3、Linux开机、重启、用户登录、注销3.1、关机、重启3.2、用户登陆、注销 1、远程登录和文件传输 查看虚拟机的IP：ifconfig，但是首先要保证虚拟机是联网了的。 2、vi和vim编辑器 2.1、三种模式 2.2、快捷键 复制某一行直接找到对应那一行输入yy p即可，复制多行先找到起始行，然后输入(第几行的数字) yy，然后光标下移到想复制的行位置，再输入一个p即可。 删除同理。 查找是先进入了之后，
Day3：学习Linux
Loki_HQ的博客
01-17 454
总结：今天把Linux整体过了一遍，明天开始学GIt，然后开始正式学习 Redis。
嵌入式学习 -- linux day01
2302_76588584的博客
09-21 2337
嵌入式学习之 linux 第一天
Linux操作系统学习：day01
qq_45545681的博客
06-10 1318
POSIX 标准是对 UNIX 操作系统的经验和实践的总结，每启动一个可执行程序都会得到一个进程，进程的运行需要CPU的加持，而CPU的资源有限，如果要同时执行多个可执行程序（即，同时处理多个进程），需要分时复用CPU的时间片，时间的长短由内核决定。进程之间需要进行数据的交流才能完成控制、协同工作等功能，Linux 的进程间通信是从 UNIX 系统继承过来的。Linux 是 UNIX 操作系统的一个克隆系统, 但是Linux是开源的。进程调度指的是系统对进程的多种状态之间转换的策略。的版本，进行安装使用。
Linux学习-day1
qq_41784433的博客
04-04 1353
文章目录 学习地址：韩顺平Linux 学习目标：工作中可以做到灵活使用。
Linux学习-day3
qq_41784433的博客
04-09 1328
文章目录1、Linux组1.1、基本介绍1.2、所有者1.3、组的创建、文件/目录所在组1.3.1、组的创建1.3.2、文件/目录所在组1.4、其他组2、权限2.1、基本介绍 1、Linux组 1.1、基本介绍 一般谁创建了这个文件，这个文件的所有者就是那个人，当然也是可以更改的。 文件属于哪个组，这个组里所有用户对文件有一定的权限。 其他组：比如a.txt属于组1的，组2、组3就属于其他组，其他组里所有用户对文件有一定的权限。 1.2、所有者 1.3、组的创建、文件/目录所在组 1.3.1、组的创
Linux学习day01_Linux安装
谢知行
05-20 241
Linux学习day01_Linux安装
Linux 指令学习之crontab
zhouzhiwengang的专栏
12-17 3515
crontab可以在指定的时间执行一个shell脚本以及执行一系列Linux命令.
Linux课程Day2
02-17
在“Linux课程Day2”中，我们将会深入探讨Linux操作系统的核心概念和常用命令，这是学习Linux系统管理和自动化工作流程的基础。Linux是一种免费且开源的操作系统，它的灵活性和稳定性使其成为服务器、开发环境以及...
linux学习资料（全）
02-22
本学习资料包含"Unix-day01"和"Unix-day02"两个部分，旨在全面覆盖Linux的基础知识和进阶技能，帮助学习者从零开始掌握Linux运维技术。 在"Unix-day02.pdf"中，可能涵盖以下知识点： 1. **Linux历史与哲学**：了解...
Linux入门 day1
01-20
太原理工大学机器人团队20天学习打卡 DAY 1 笔者不喜欢啰嗦，力求看得少学得多并且好理解，那么还是直入主题，开门见山吧！ 本次我们先学习Linux的常用命令。 有人肯定会想为什么不先学习Linux操作系统？ 笔者认为...
Linux-Day01.pdf
08-14
学习 Linux 操作系统的重要性体现在以下几个方面： 1. 企业用人要求：许多招聘网站上的岗位要求都提到了 Linux 操作系统的经验。作为 JavaEE 开发工程师，企业需要我们具备 Linux 操作系统的相关知识，因为 Linux ...
Linux学习DAY6-认识与学习BASH
2302_81664454的博客
06-19 1754
硬件：整个系统的实体工作者，包含了硬盘、cpu等核心：控制硬件工作shell：使用者界面。
【Linux】操作系统初步理解与Linux指令入门
2303_80828380的博客
10-27 689
Ubuntu 22.04 server 64bit环境
【ShuQiHere】Linux 桌面环境：选择与定制指南 ️✨
ShuQIHere的博客
10-26 1238
Linux 桌面环境（Desktop Environment，简称 DE）是用户与操作系统交互的图形界面。它不仅决定了系统的外观和感觉，还影响着用户的工作效率和使用体验。无论你是新手还是资深用户，选择和定制适合自己的桌面环境都是提升 Linux 使用体验的重要一步。本文将带你全面了解 Linux 桌面环境的基本概念、常见类型、选择技巧以及定制方法。🚀
‌Linux tac命令‌
最新发布
weixin_37788102的博客
10-30 249
tac命令实际上是cat命令的一个变体，尽管它的功能相对简单，但在某些情况下非常有用。例如，当需要查看文件的最后一行（通常是标题或总结）时，使用tac命令可以避免滚动查看整个文件。此外，tac命令对于处理大型文件或需要快速定位文件末尾内容的情况非常有用‌。‌Linux tac命令‌是一个用于逆序显示文件内容的工具，其名称来源于“cat”的反向拼写。tac命令的基本功能是将文件的内容从最后一行开始输出，直到第一行结束，这与cat命令的功能相反，cat命令是从第一行开始输出直到最后一行。tac命令的基本用法。
VMware各版本下载的镜像站(含windows和linux)
王佐儿z的博客
10-27 338
转载地址。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值