嵌入式第三天：（C语言入门）

news2025/5/22 21:59:53

目录

一、跳转关键字

break：

continue：

goto：

二、函数

概述：

函数的使用：

无参无返回值：

有参无返回值：

有参有返回值：

返回值注意点：

函数的声明：

函数的案例：

局部和全局变量：

局部变量：

全局变量：

总结：

多文件编程：

​编辑 防止头文件重复包含：

命令行编译程序：

头文件包含的区别：

extern关键字：

三、指针

指针基本语法：

指针变量的定义和使用：

通过指针简介修改变量的值：

指针与常量：

指针大小：

指针步长：

野指针和空指针：

多级指针：

指针和函数：

函数参数传值：

函数参数传址：

函数指针：

函数名：

函数指针：

 回调函数：

一、跳转关键字

  • 循环和switch专属的跳转：break
  • 循环专属的跳转：continue
  • 无条件跳转：goto

break：

  • 循环的break说明
    • 某一条件满足时，不再执行循环体中后续重复的代码，并退出循环
  • 需求：一共吃5碗饭, 吃到第3碗吃饱了, 结束吃饭动作
  • 示例代码：
#include <stdio.h>

int main() {
    // 需求: 一共吃5碗饭, 吃到第3碗吃饱了, 结束吃饭动作
    // 1. 定义条件变量，为了查看方便, 计数器从 1 开始
    int i = 1;
    while (i <= 5) { // 2. 控制条件
        if (i == 3) {
            printf("吃饱了，不吃了\n");
            break; // 结束循环，退出循环
        }
        
        printf("吃第 %d 碗饭\n", i);
        // 3. 条件变量改变
        i++;
    }

    return 0;
}

continue：

  • 某一条件满足时，不再执行本次循环体中后续重复的代码，但进入下一次循环判断
    • while循环，continue 之前一定要修改计数器(条件变量)，否则，导致死循环
  • 需求：一共吃5个苹果，吃到第3个遇到虫子，这个跳过不吃，下一个继续
  • 示例代码：
#include <stdio.h>

int main() {
    // 需求: 一共吃5个苹果，吃到第3个遇到虫子，这个跳过不吃，下一个继续
    // 1. 定义条件变量，为了查看方便, 计数器从 1 开始
    int i = 1;
    while (i <= 5) { // 2. 控制条件
        if (i == 3) {
            printf("这个有虫子，不吃了\n");
            i++;    // continue 之前一定要修改计数器(条件变量)，否则，导致死循环
            continue;; // 跳过本次循环，下次继续
        }
        
        printf("吃第 %d 个苹果\n", i);
        // 3. 条件变量改变
        i++;
    }

    return 0;
}

goto：

  • goto用于无条件跳转
    • 在一种情况下可以使用goto语句：从一组嵌套的循环中跳出
  • goto语句可以导致代码不易理解和维护，并且容易引入不必要的错误。因此，除非必要，最好不要使用goto语句
  • 示例代码：
#include <stdio.h>

int main() {

    int i = 0;
    while (i < 3) {
        if(i == 1) {
            goto End;	// 跳转到End标签
        }
        printf("i = %d\n", i);
        i++;
    }
    
    End:
        printf("this is ending!\n");

    return 0;
}

二、函数

概述：

  • 函数是一种可重用的代码块，用于执行特定任务或完成特定功能
  • 函数作用：对具备相同逻辑的代码进行封装，提高代码的编写效率，实现对代码的重用
  • 函数使用步骤
    • 定义函数
      • 理解为制作工具，工具只需要制作1次即可
    • 调用函数
      • 理解为使用工具
  • 函数分类
    • 系统函数，即库函数：这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用它们，如我们常用的打印函数printf()。
    • 自定义函数：用以解决用户的专门需要。
  • 【注意】： main主函数要放到要调用的方法之后。
函数的使用：
无参无返回值：

语法格式：

// 函数定义
void 函数名() {
    函数体
}

// 函数调用
函数名();
    • 函数名是标识符的一种，需要遵循规则
    • 函数只需要定义一次，反复调用
    • 只定义函数, 不调用函数, 函数永远不会被执行
  • 案例需求： 
    // 函数定义
void 函数名(形参列表) {
    函数体
}

// 函数调用
函数名(实参列表);

    • 编写一个函数，里面实现2个数字相加，并打印相加后的结果
  • 示例代码：
#include <stdio.h>

// 函数定义
void my_add() {
    // 实现2个数字相加，并打印相加后的结果
    int res = 1 + 2;
    printf("res = %d\n", res);
}

int main() {
    // 函数调用
    my_add();

    return 0;
}
有参无返回值：

语法格式：

// 函数定义
void 函数名(形参列表) {
    函数体
}

// 函数调用
函数名(实参列表);
  • 函数参数的作用：增加函数的灵活性
    • 可以根据需求在调用函数时, 通过参数传入不同的数据
    • 实参和形参的关系：从左往右，一一对应
  • 案例需求：
    • 编写一个函数，实现2个数相加，2个数通过参数传递
  • 示例代码：
#include <stdio.h>

// 函数定义
void my_add(int a, int b) {
    // 实现2个形参相加，并打印相加后的结果
    int res = a + b;
    printf("%d + %d = %d\n", a, b, res);
}

int main() {
    // 函数调用
    my_add(10, 20);

    return 0;
}
有参有返回值：

语法格式：

// 函数定义
返回类型 函数名(形参列表) {
    函数体

    return 和返回类型一致的数据(或变量);
}

// 函数调用
和返回类型一致的变量 = 函数名(实参列表);
  • 函数返回值的作用：函数外部想使用函数内部的数据
    • eturn是函数的专属关键字，只能用在函数内容
  • 案例需求：
    • 编写一个函数，实现2个数相加，2个数通过参数传递，返回累加结果给外部使用
  • 示例代码：
#include <stdio.h>

// 函数定义
int my_add(int a, int b) {
    // 实现2个形参相加，并返回累加的结果
    int res = a + b;
    
    return res;
}

int main() {
    // 函数调用
    int temp = my_add(10, 20);
    printf("temp  = %d\n", temp);

    return 0;
}
返回值注意点：
  • return的作用是结束函数
    • 函数内，return后面的代码不会执行
函数的声明：
  • 如果函数定义代码没有放在函数调用的前面，这时候需要先做函数的声明
  • 所谓函数声明，相当于告诉编译器，函数是有定义的，再别的地方定义，以便使编译能正常进行
  • 注意：一个函数只能被定义一次，但可以声明多次
  • 示例代码：
#include <stdio.h>

// 函数的声明，分号不能省略
// 函数声明的前面可以加extern关键字，也可以不加
// extern int my_add(int a, int b);
int my_add(int a, int b);
// 另一种方式，形参名可以不写
// int my_add(int, int );

int main() {
    // 函数调用
    int temp = my_add(10, 20);
    printf("temp  = %d\n", temp);

    return 0;
}

// 函数定义
int my_add(int a, int b) {
    // 实现2个形参相加，并返回累加的结果
    int res = a + b;

    return res;
}
函数的案例：
  • 需求：自定义一个函数，返回2个整数的最大值
  • 示例代码：
#include <stdio.h>

// 函数定义
int my_max(int a, int b) {
    if (a > b) {
        return a;
    } else {
        return b;
    }
}

int main() {
    // 函数调用
    int res = my_max(100, 200);
    printf("res = %d\n", res);

    return 0;
}
局部和全局变量：
局部变量：
  • 定义在代码块{}里面的变量称为局部变量（Local Variable）
  • 局部变量的作用域(作用范围)仅限于代码块{}， 离开该代码块{}是无效的
    • 离开代码块{}后，局部变量自动释放
  • 示例代码：
#include <stdio.h>

// 函数定义
void my_add(int a, int b) {
    // a, b, res是局部变量，只能在my_add内部使用
    int res = a + b;
}

int main() {
    // 函数调用
    my_add(10, 20);
    // 函数外部无法使用函数内的局部变量，下面代码是错误的
    printf("%d, %d, %d\n", a, b, res);

    return 0;
}
全局变量：
  • 在所有函数外部定义的变量称为全局变量（Global Variable），它的作用域默认是整个程序，也就是所有的源文件
  • 示例代码：
#include <stdio.h>

// 函数外定义的变量为全局变量，定义完，所有地方都能使用
int a = 10;

int main() {
    // 使用全局变量
    printf("a = %d\n", a);

    return 0;
}
总结：

多文件编程：

  • 把函数声明放在头文件xxx.h中，在主函数中包含相应头文件
  • 在头文件对应的xxx.c中实现xxx.h声明的函数
 防止头文件重复包含：
  • 当一个项目比较大时，往往都是分文件，这时候有可能不小心把同一个头文件 include 多次，或者头文件嵌套包含。
  • 为了避免同一个文件被include多次，C/C++中有两种方式。
  • 方法一：
#ifndef __SOMEFILE_H__
#define __SOMEFILE_H__

// 声明语句

#endif
  • 方法二：
#pragma once

// 声明语句
命令行编译程序：

gcc -g main.c func.c -o main.exe

  • -g 指定编译的文件，多个文件用空格隔开。注意：只需要编译c文件，h文件不需要加入进去；
  • -o 指定生成可执行文件的名字；

ps：命令行显示中文乱码，修改命令：chcp 65001

头文件包含的区别：
  • <> 表示系统直接按系统指定的目录检索
  • "" 表示系统先在 "" 指定的路径(没写路径代表当前路径)查找头文件，如果找不到，再按系统指定的目录检索
extern关键字：

extern主要用于声明外部变量或函数，当我们将一个变量或函数声明为extern时，那么就表示该变量或函数是在其他地方定义的，我们只是在当前文件中引用它。

示例代码：

main.c

#include <stdio.h>

extern int global_val;
extern void printf_val();

int main() {

    global_val = 100;
    printf_val();

    return 0;
}

 other.c

#include <stdio.h>

int global_val;

void printf_val() {
    printf("other->global_val: %d\n", global_val);
}

三、指针

指针基本语法：

  • 内存地址

    • 在计算机内存中，每个存储单元都有一个唯一的地址(内存编号)。
      • 通俗理解，内存就是房间，地址就是门牌号

  • 指针和指针变量

    • 指针（Pointer）是一种特殊的变量类型，它用于存储内存地址。
      • 指针的实质就是内存“地址”
    • 指针变量就是存储这个地址的变量。

  • 指针作用

    • 可间接修改变量的值
指针变量的定义和使用：
  • 指针也是一种数据类型，指针变量也是一种变量
  • 指针变量指向谁，就把谁的地址赋值给指针变量
  • 语法格式：

类型 变量;
类型 * 指针变量 = &变量;

    • & 叫取地址，返回操作数的内存地址
    • * 叫解引用，指操作指针所指向的变量的值
    • 在定义变量时，* 号表示所声明的变量为指针类型
      • 指针变量要保存某个变量的地址，指针变量的类型比这个变量的类型多一个*
    • 在指针使用时，* 号表示操作指针所指向的内存空间
#include <stdio.h>

int main() {

    // 定义一个int类型的变量，同时赋值为10
    int a = 10;
    // 打印变量的地址
    printf("&a = %p\n", &a);
    // 定义一个指针变量，int *保存int的地址
    // int *代表是一种数据类型，int *指针类型，p才是变量名
    int* p;
    // 指针指向谁，就把谁的地址赋值给这个指针变量
    p = &a;
    // 打印p, *p, p指向了a的地址，*p就是a的值
    printf("p = %p, *p = %d\n", p, *p);

    return 0;
}

通过指针简介修改变量的值：
  • 指针变量指向谁，就把谁的地址赋值给指针变量
  • 通过 *指针变量 间接修改变量的值
  • 示例代码：
#include <stdio.h>

int main() {
    // 定义一个int类型变量a，同时赋值为0
    int a = 0;
    // 定义int *指针变量，同时赋值a的地址
    int *p = &a;
    // 通过指针间接修改a的值
    *p = 123;
    printf("a = %d\n", a);
    // 定义一个int类型变量b，同时赋值为5
    int b = 5;
    // p 保存 b的地址
    p = &b;
    // 通过指针间接修改b的值
    *p = 250;
    printf("b = %d\n", b);

    return 0;
}
指针与常量：

语法格式：

int a = 1;
const int *p1 = &a;	// 等价于 int const *p1 = &a;
int * const p2 = &a;
const int * const p3 = &a;
    • 从左往右看，跳过类型，看修饰哪个字符
      • 如果是*， 说明指针指向的内存不能改变
      • 如果是指针变量，说明指针的指向不能改变，指针的值不能修改
  • 示例代码：
#include <stdio.h>

int main() {
    int a = 1;
    int b = 2;
    // p1 可以改，*p1不能改
    const int *p1 = &a; // 等价于 int const *p1 = &a;
    // p1 = &b;    // ok
    // *p1 = 555;  // err

    // p2 不能修改，*p2可以修改
    int *const p2 = &a;
    // p2 = &b;    //err
    // *p2 = 555;  // ok

    // p3 和 *p 都不能改
    const int *const p3 = &a;
    // p3 = &b;    // err
    // *p3 = 555;  // err

    return 0;
}
指针大小：
  • 使用sizeof()测量指针的大小，得到的总是：4或8
  • sizeof()测的是指针变量指向存储地址的大小
    • 在32位平台，所有的指针（地址）都是32位(4字节)
    • 在64位平台，所有的指针（地址）都是64位(8字节)
#include <stdio.h>

int main() {
    int *p1;
	int **p2;
	char *p3;
	char **p4;
	printf("sizeof(p1) = %llu\n", sizeof(p1));
	printf("sizeof(p2) = %llu\n", sizeof(p2));
	printf("sizeof(p3) = %llu\n", sizeof(p3));
	printf("sizeof(p4) = %llu\n", sizeof(p4));
	printf("sizeof(double *) = %llu\n", sizeof(double *));

    return 0;
}
指针步长：
  • 指针步长指的是通过指针进行递增或递减操作时，指针所指向的内存地址相对于当前地址的偏移量。
  • 指针的步长取决于所指向的数据类型。
    • 指针加n等于指针地址加上 n 个 sizeof(type) 的长度
    • 指针减n等于指针地址减去 n 个 sizeof(type) 的长度
#include <stdio.h>

int main() {
    char ch;
    char *p1 = &ch;
    printf("p1:%p, p1+1: %p\n", p1, p1 + 1); // 步长为1字节

    int a;
    int *p2 = &a;
    printf("p2:%p, p2+1: %p\n", p2, p2 + 1); // 步长为4字节

    double d;
    double *p3 = &d;
    printf("p3:%p, p3+1: %p\n", p3, p3 + 1); // 步长为8字节

    return 0;
}
野指针和空指针：
  • 指针变量也是变量，是变量就可以任意赋值
  • 任意数值赋值给指针变量没有意义，因为这样的指针就成了野指针
    • 此指针指向的区域是未知(操作系统不允许操作此指针指向的内存区域)
  • 野指针不会直接引发错误，操作野指针指向的内存区域才会出问题
  • 为了标志某个指针变量没有任何指向，可赋值为NULL
    • NULL是一个值为0的宏常量
#include <stdio.h>

int main() {
    int *p;
    p = 0x12345678; // 给指针变量p赋值，p为野指针， ok，不会有问题，但没有意义
    // *p = 1000;      // 操作野指针指向未知区域，内存出问题，err
    printf("111111111111111111\n");

    int *q = NULL;  // 空指针

    return 0;
}
多级指针：
  • C语言允许有多级指针存在，在实际的程序中一级指针最常用，其次是二级指针。
  • 二级指针就是指向一个一级指针变量地址的指针。
#include <stdio.h>

int main() {

    int a = 100;

    // 一级指针
    int* p1 = &a;
    printf("&a=%p\n", &a);
    printf("p1=%p\n", p1);
    printf("&p1=%p\n", &p1);

    // 二级指针，可以存储一级指针变量的地址
    int** p2 = &p1;
    printf("p2=%p\n", p2);
    printf("&p2=%p\n", &p2);

    // 三级指针，可以存储二级指针变量的地址
    int*** p3 = &p2;
    printf("p3=%p\n", p3);
    printf("&p3=%p\n", &p3);

    printf("---------------------\n");

    // 通过一级指针访问100，打印出来
    printf("*p1=%d\n", *p1);
    
    // 通过二级指针访问100，打印出来
    printf("**p2=%d\n", **p2);
    
    // 通过三级指针访问100，打印出来
    printf("***p3=%d\n", ***p3);
    
    return 0;
}

指针和函数：

函数参数传值：
  • 传值是指将参数的值拷贝一份传递给函数，函数内部对该参数的修改不会影响到原来的变量
  • 示例代码：
// 函数参数传值，函数内部交换2个变量的值，验证函数外部的变量有没有改变
#include <stdio.h>

// 函数定义
void func(int m, int n) {
    // 函数内部交换2个变量的值
    int temp = m;
    m = n;
    n = temp;
    printf("函数内部 m = %d, n = %d\n", m, n);
}

int main() {
    int a = 10;
    int b = 20;
    // 调用函数，值传递
    func(a, b);
    printf("函数外部 a = %d, b = %d\n", a, b);

    return 0;
}

运行结果：

函数内部 m = 20, n = 10
函数外部 a = 10, b = 20 

函数参数传址：
  • 传址是指将参数的地址传递给函数，函数内部可以通过该地址来访问原变量，并对其进行修改。
  • 示例代码：
// 函数参数传地址，函数内部交换2个指针指向内存的值，验证函数外部的变量有没有改变
#include <stdio.h>

// 函数定义
void func(int *m, int *n) {
    // 函数内部交换2个指针指向内存的值
    int temp = *m;
    *m = *n;
    *n = temp;
    printf("函数内部 *m = %d, *n = %d\n", *m, *n);
}

int main() {
    int a = 10;
    int b = 20;
    // 调用函数，地址传递
    func(&a, &b);
    printf("函数外部 a = %d, b = %d\n", a, b);

    return 0;
}

运行结果：

函数内部 *m = 20, *n = 10
函数外部 a = 20, b = 10

函数指针：
函数名：
  • 一个函数在编译时被分配一个入口地址，这个地址就称为函数的指针，函数名代表函数的入口地址
#include <stdio.h>

void func(int a) {
    printf("func a = %d\n", a);
}


int main() {
    // 函数名字，就是代表函数的入口地址，函数地址
    printf("%p, %p, %p\n", func, &func, *func);

    // 3种调用方法都可以
    func(1); // 最简便，最常用
    (&func)(2);
    (*func)(3);

    return 0;
}
函数指针：
  • 函数指针：它是指针，指向函数的指针
  • 语法格式：

返回值 (*函数指针变量)(形参列表);

    • 函数指针变量的定义，其中返回值、形参列表需要和指向的函数匹配
#include <stdio.h>

void func(int a) {
    printf("a = %d\n", a);
}

int main() {
    // 函数指针变量的定义，同时初始化
    void (*p1)(int a) = func;
    // 通过函数指针变量调用函数
    p1(10);

    // 先定义函数指针变量，后面再赋值
    void (*p2)(int);
    p2 = func;
    // 通过函数指针变量调用函数
    p2(20);

    return 0;
}
 回调函数：
  • 函数指针变量做函数参数，这个函数指针变量指向的函数就是回调函数
  • 回调函数可以增加函数的通用性
    • 在不改变原函数的前提下，增加新功能
#include <stdio.h>

// 定义函数，函数指针做形参
int calc(int a, int b, int (*p)(int, int)){
    // 通过函数指针变量调用函数，获取返回值
    int res = p(a, b);
    
    return res;
}

// 定义加法函数
int add(int x, int y) {
    return x + y;
}

// 定义减法函数
int sub(int x, int y) {
    return x - y;
}

int main() {
    int result;

    // 回调加法函数
    result = calc(1, 2, add);
    printf("result = %d\n", result);

    // 回调减法函数
    result = calc(10, 5, sub);
    printf("result = %d\n", result);

    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1593714.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

微信跳转页面时发生报错

微信跳转页面时发生报错

报错如下图所示&#xff1a; 解决方法&#xff1a;&#xff08;从下面四种跳转方式中任选一种&#xff0c;哪种能实现效果就用哪个&#xff09; 带历史回退 wx.navigateTo() //不能跳转到tabbar页面 不带历史回退 wx.redirectTo() //跳转到另一个页面wx.switchTab() //只能…
阅读更多...
Linux: softirq 简介

Linux: softirq 简介

文章目录 1. 前言2. softirq 实现2.1 softirq 初始化2.1.1 注册各类 softirq 处理接口2.1.2 创建 softirq 处理线程 2.2 softirq 的 触发 和 处理2.1.1 softirq 触发2.1.2 softirq 处理2.1.2.1 在 中断上下文 处理 softirq2.1.2.2 在 ksoftirqd 内核线程上下文 处理 softirq 3.…
阅读更多...
[lesson26]类的静态成员函数

[lesson26]类的静态成员函数

类的静态成员函数 静态成员函数 在C中可以定义静态成员函数 静态成员函数是类中特殊的成员函数静态成员函数属于整个类所有可以通过类名直接访问公有静态成员函数可以通过对象名访问公有静态成员函数 静态成员函数的定义 直接通过static关键字修饰成员函数 静态成员函数 vs…
阅读更多...
4.Godot图片素材的获取和编辑

4.Godot图片素材的获取和编辑

游戏开发中经常遇到图片素材的需求 1. 图片素材的准备 术语&#xff1a;Sprite 精灵&#xff0c;游戏开发中指一张图片来源不明的图片&#xff0c;切勿在商业用途使用&#xff0c;以免引起版权风险。 1. 在学习阶段&#xff0c;可以百度或者从一些资源网站获取&#xff0c;这…
阅读更多...
Unity类银河恶魔城学习记录12-13 p135 Merge Skill Tree with Dogge skill源代码

Unity类银河恶魔城学习记录12-13 p135 Merge Skill Tree with Dogge skill源代码

Alex教程每一P的教程原代码加上我自己的理解初步理解写的注释&#xff0c;可供学习Alex教程的人参考 此代码仅为较上一P有所改变的代码 【Unity教程】从0编程制作类银河恶魔城游戏_哔哩哔哩_bilibili​​​​​​​ Inventory.cs using System.Collections.Generic; using Un…
阅读更多...
分布式结构化数据表Bigtable

分布式结构化数据表Bigtable

文章目录 设计动机与目标数据模型行列时间戳 系统架构主服务器Chubby作用子表服务器SSTable结构子表实际组成子表地址组成子表数据存储及读/写操作数据压缩 性能优化局部性群组&#xff08;Locality groups&#xff09;压缩布隆过滤器 Bigtable是Google开发的基于GFS和Chubby的…
阅读更多...
Apple：叠加提示 - 高效的 RAG 优化方式

Apple：叠加提示 - 高效的 RAG 优化方式

发表机构&#xff1a;Apple 本文介绍了一种新的检索增强生成&#xff08;RAG&#xff09;提示方法——叠加提示&#xff08;superposition prompting&#xff09;&#xff0c;该方法可以直接应用于预训练的基于变换器的大模型&#xff08;LLMs&#xff09;&#xff0c;无需微调…
阅读更多...
cmake制作并链接动静态库

cmake制作并链接动静态库

cmake制作并链接动静态库 制作静态库add_library(库名称 STATIC 源文件1 [源文件2] ...)LIBRARY_OUTPUT_PATH指定库的生成路径 制作动态库add_library(库名称 SHARED 源文件1 [源文件2] ...) 连接动静态库link_libraries连接静态库link_directories到哪个路径去找库target_link…
阅读更多...
ssh爆破服务器的ip-疑似肉鸡

ssh爆破服务器的ip-疑似肉鸡

最近发现自己的ssh一直有一些人企图使用ssh暴力破解的方式进行密码破解.就查看了一下,真是网络安全太可怕了. 大家自己的服务器密码还是要设置好,管好,做好最基本的安全措施,不然最后只能沦为肉鸡. ssh登陆日志可以在/var/log下看到,ubuntu的话为auth.log,centos为secure文件 查…
阅读更多...
ubuntu 应用程序设置 开机自启动

ubuntu 应用程序设置 开机自启动

1. 通过.desktop方式 autostart 中.desktop 配置文件 1.1 用户级自启动 登录后才可以启动服务。 可视化配置&#xff1a;在ubuntu自带的可视化程序来配置&#xff0c;就是StartupApplications&#xff0c;它在启动台中可以找到。 在ubuntu下目录是 ~/.config/autostart 添…
阅读更多...
kotlin项目引用

kotlin项目引用

概要&#xff1a; 记录项目引用kotlin具体事项 1 object下build.gradle buildscript {//声明引用版本ext.kotlin_version "1.4.20"repositories {google()mavenCentral()}dependencies {classpath "com.android.tools.build:gradle:4.2.0"//引用kotlinc…
阅读更多...
DataX案例，MongoDB数据导入HDFS与MySQL

DataX案例，MongoDB数据导入HDFS与MySQL

【尚硅谷】Alibaba开源数据同步工具DataX技术教程_哔哩哔哩_bilibili 目录 1、MongoDB 1.1、MongoDB介绍 1.2、MongoDB基本概念解析 1.3、MongoDB中的数据存储结构 1.4、MongoDB启动服务 1.5、MongoDB小案例 2、DataX导入导出案例 2.1、读取MongoDB的数据导入到HDFS 2…
阅读更多...
Ubuntu去除烦人的顶部【活动】按钮

Ubuntu去除烦人的顶部【活动】按钮

文章目录 一、需求说明二、打开 extensions 网站三、安装 GNOME Shell 插件四、安装本地连接器五、安装 Hide Activities Button 插件六、最终效果七、卸载本地连接器命令参考 本文所使用的 Ubuntu 系统版本是 Ubuntu 22.04 ! 一、需求说明 使用 Ubuntu 的过程中&#xff0c;屏…
阅读更多...
【网络编程】高性能并发服务器源码剖析

【网络编程】高性能并发服务器源码剖析

hello &#xff01;大家好呀&#xff01; 欢迎大家来到我的网络编程系列之洪水网络攻击&#xff0c;在这篇文章中&#xff0c;你将会学习到在网络编程中如何搭建一个高性能的并发服务器&#xff0c;并且我会给出源码进行剖析&#xff0c;以及手绘UML图来帮助大家来理解&#xf…
阅读更多...
机器学习—特征工程（三）

机器学习—特征工程（三）

什么是特征工程 特征工程是使用专业背景知识和技巧处理数据&#xff0c;使得特征能在机器学习算法上发挥更好的作用的过程。 意义︰会直接影响机器学习的效果 特征工程的位置与数据处理的比较 pandas:—个数据读取非常方便以及基本的处理格式的工具sklearn:对于特征的处理提…
阅读更多...
鹏哥C语言复习——数据存储

鹏哥C语言复习——数据存储

目录 版本差异&#xff1a; 数据类型&#xff1a; 进制表示&#xff1a; 大小端储存&#xff1a; 数据运算&#xff1a; 浮点型在内存中的存储&#xff1a; 版本差异&#xff1a; debug和release的区别&#xff1a; 在栈区开辟地址一般是先从高地址开辟 debug创建数组和单…
阅读更多...
深度学习图像处理基础工具——opencv 实战2 文档扫描OCR

深度学习图像处理基础工具——opencv 实战2 文档扫描OCR

输入一个文档&#xff0c;怎么进行文档扫描&#xff0c;输出扫描后的图片呢&#xff1f; 今天学习了 opencv实战项目 文档扫描OCR 问题重构&#xff1a;输入图像 是一个含有文档的图像——> 目标是将其转化为 规则的扫描图片 那么怎么实现呢&#xff1f; 问题分解&#…
阅读更多...
leetcode.45题：跳跃游戏II

leetcode.45题：跳跃游戏II

Leetcode.45题&#xff1a;跳跃游戏II /* 题意的理解&#xff1a; nums[0] 只能跳 1 ~ nums[0]步 依次类推&#xff1a;从nums[0] - nums[n - 1] 最少需要多少步数 nums 2 3 1 1 4 nums[0] 2,初始只能跳 1/2步&#xff0c;如跳1步&#xff0c;达到nums[1] 而nums[1] 3,顾第二…
阅读更多...
Python学习笔记22 - 文件操作

Python学习笔记22 - 文件操作

文件读写的原理 文件读写的操作 常用的文件打开模式 文件对象的常用方法 with语句&#xff08;上下文管理器&#xff09;
阅读更多...
kubekey 离线安装harbor、k8s、kubesphere

kubekey 离线安装harbor、k8s、kubesphere

目录 参考文献 了解kubekey 英文和中文 前提条件 部署准备 下载kubukey 离线包配置和制作 配置离线包 制作离线包 离线安装集群 复制KubeKey 和制品 artifact到离线机器 创建初始换、安装配置文件 安装镜像仓库harbor 初始化harbor 项目 修改配置文件 安装k8s集…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023