【C++基础知识学习笔记】精华版（复习专用）

news2024/11/27 0:37:05

常用语法

函数重载(Overload)

规则：

  • 函数名相同

  • 参数个数不同、参数类型不同、参数顺序不同

注意：

  • 返回值类型与函数重载无关

  • 调用函数时，实参的隐式类型转换可能会产生二义性

默认参数

C++ 允许函数设置默认参数，在调用时可以根据情况省略实参。规则如下：

  • 默认参数只能按照从右到左的顺序
  • 如果函数同时有声明、实现，默认参数只能放在函数声明中
  • 默认参数的值可以是常量、全局符号（全局变量、函数名）

如果函数的实参经常是同一个值，可以考虑使用默认参数。

int age = 33;

void test() {
   
    cout << "test()" << endl;
}

void display(int a = 11, int b = 22, int c = age, void (*func)() = test) {
   
    cout << "a is " << a << endl;
    cout << "b is "<< b << endl;
    cout << "c is " << c << endl;
    func();
}

int main() {
   
    display();
}

函数重载、默认参数可能会产生冲突、二义性（建议优先选择使用默认参数）

void display(int a, int b = 20) {
   
    cout << "a is " << a << endl;
}

void display(int a) {
        
    cout << "a is " << a << endl; 
}

int main() {
   
    display(10); // 编译失败，存在二义性
}

extern "C"

被 extern "C" 修饰的代码会按照 C 语言的方式去编译

extern "C" void func() {
    
    cout << "func()" << endl; 
}

extern "C" void func1(int age) {
   
    cout << "func(int age) " << age << endl; 
}

如果函数同时有声明和实现，要让函数声明被 extern “C” 修饰，函数实现可以不修饰

extern "C" void func();
extern "C" void func1(int age);

void func() {
   
    cout << "func()" << endl;
}

void func1(int age) {
   
    cout << "func(int age) " << age << endl;
}

extern "C" {
   
    void func();
    void func1(int age);
}

void func() {
   
    cout << "func()" << endl;
}

void func1(int age) {
   
    cout << "func(int age) " << age << endl;
}

由于C、C++ 编译规则的不同，在C、C++ 混合开发时，可能会经常出现以下操作：

  • C++ 在调用 C 语言 API 时，需要使用 extern "C" 修饰 C 语言的函数声明
    在这里插入图片描述

  • 有时也会在编写 C 语言代码中直接使用 extern "C" ，这样就可以直接被 C++ 调用了
    在这里插入图片描述

#pragma once

我们经常使用#ifndef、#define、#endif来防止头文件的内容被重复包含

#pragma once可以防止整个文件的内容被重复包含

区别：

  • #ifndef、#define、#endif受 C/C++ 标准的支持，不受编译器的任何限制

  • 有些编译器不支持#pragna once (较老编译器不支持，如GCC 3.4版本之前)，兼容性不够好

  • #ifndef、#define、#endif可以针对一个文件中的部分代码，而#pragma once只能针对整个文件

内联函数（inline function）

使用inline修饰函数的声明或者实现，可以使其变成内联函数。建议声明和实现都增加inline修饰。

特点：

  • 编译器会将函数调用直接展开为函数体代码
  • 可以减少函数调用的开销
  • 会增大代码体积

注意：

  • 尽量不要内联超过10行代码的函数

  • 有些函数即使声明为inline，也不一定会被编译器内联，比如递归函数

VS中可通过如下配置选择禁用或启用内联扩展：

在这里插入图片描述

内联函数与宏

  • 内联函数和宏，都可以减少函数调用的开销

  • 对比宏，内联函数多了语法检测和函数特性

思考以下代码的区别

#define sum(x) (x + x)

int a = 10;

int main() {
   
    std::cout << sum(a++) << std::endl; // 21
    std::cout << a << std::endl; // 12
}
  • 上面代码中 sum(a++) 等价于 (a++) + (a++)，sum的计算结果会先取a的值（10）再取a++之后a的值（11）所以之和是21，而a本身由于自增了两次所以结果是12
inline int sum(int x) {
    return x + x; }

int a = 10;

int main() {
   
    std::cout << sum(a++) << std::endl; // 20
    std::cout << a << std::endl; // 11
}
  • 上面代码中 sum(a++) 属于函数调用，因此会捕获 a 的副本（10）传入函数中，在函数体中执行 10 + 10 得到结果是 20，在这之后由于 a 本身执行自增操作变成了 11

表达式

C++ 的有些表达式是可以被赋值的

int a = 1;
int b = 2;
(a = b) = 3; // 赋值给了 a
(a < b ? a : b) = 4; // 赋值给了 b

const

  • const是常量的意思，被其修饰的变量不可修改

  • 如果修饰的是类、结构体（的指针），其成员也不可以更改

struct Student {
    int age; }; 

int main() {
   
    Student stu1 = {
   10};
    Student stu2 = {
   20};
    
    const Student *pStu1 = &stu1;
    *pStu1 = stu2;     // 编译报错，*pStu1不能修改
    (*pStu1).age = 30; // 编译报错，*pStu1的成员不能修改
    pStu1->age = 30;   // 编译报错，*pStu1的成员不能修改
    pStu1 = &stu2;     // 编译成功，pStu1指向可以修改
    
    Student * const pStu2 = &stu2;
    *pStu2 = stu1;     // 编译成功，*pStu2 可以修改
    (*pStu2).age = 30; // 编译成功，*pStu2 的成员可以修改
    pStu2->age = 30;   // 编译成功，*pStu2 的成员可以修改
    pStu2 = &stu1;     // 编译报错，pStu2不能修改指向
}

思考：以下5个指针分别是什么含义？

int age = 10;
const int *p0 = &age;
int const *p1 = &age;
int * const p2 = &age;
const int * const p3 = &age;
int const * const p4 = &age;

上面的指针问题可以用以下结论来解决：const修饰的是其右边的内容

验证代码：

int main() {
   
    int a = 2;
    int age = 10;
    const int *p0 = &age;
    p0 = &a; // p0 可以修改
    *p0 = 3; // *p0 不能修改, 编译报错

    int const *p1 = &age;
    p1 = &a; // p1 可以修改
    *p1 = 3; // *p1 不能修改, 编译报错

    int * const p2 = &age;
    p2 = &a; // p2 不能修改, 编译报错
    *p2 = 3; // *p2 可以修改
    
    const int * const p3 = &age;
    p3 = &a; // p3 不能修改, 编译报错
    *p3 = 3; // *p3 不能修改, 编译报错
    
    int const * const p4 = &age;
    p4 = &a; // p4 不能修改, 编译报错
    *p4 = 3; // *p4 不能修改, 编译报错
}

引用（Reference）

  • 在C语言中，使用指针（Pointer）可以间接获取、修改某个变量的值
  • 在C++中，使用引用（Reference）可以起到跟指针类似的功能
int age = 20;
// rage 就是一个引用
int &rage = age;

注意点：

  • 引用相当于是变量的别名（基本数据类型、枚举、结构体、类、指针、数组等，都可以有引用）
  • 对引用做计算，就是对引用所指向的变量做计算
  • 在定义的时候就必须初始化，一旦指向了某个变量，就不可以再改变，“从一而终”
  • 可以利用引用初始化另一个引用，相当于某个变量的多个别名
  • 不存在【引用的引用、指向引用的指针、引用数组】

引用存在的价值之一：比指针更安全、函数返回值可以被赋值

引用的本质

  • 引用的本质就是指针，只是编译器削弱了它的功能，所以引用就是弱化了的指针

  • 一个引用占用一个指针的大小

常引用（Const Reference）

引用可以被const修饰，这样就无法通过引用修改数据了，可以称为常引用

  • const必须写在＆符号的左边，才能算是常引用

const引用的特点：

  • 可以指向临时数据（常量、表达式、函数返回值等）
  • 可以指向不同类型的数据
  • 作为函数参数时（此规则也适用于const 指针）：
    ✓ 可以接受const和非const实参（但非const引用只能接受非const实参）
    ✓ 可以跟非const引用构成重载

注意：当常引用指向了不同类型的数据时，会产生临时变量，即引用指向的并不是初始化时的那个变量。

数组的引用

常见的2种写法：

int array[] = {
    10,20,30 }; 
int (&ref1)[3] = array;
int * const &ref2 = array; 

ref1[0] = 8;
int a = ref1[2];
ref2[1] = 4;
int b = ref2[2]

变量地址总结

一个变量的地址值，是它所有字节地址中的最小值

面向对象

类

  • C++ 中可以使用struct、class来定义一个类

struct 和 class 的区别：

  • struct 的默认成员权限是 public
  • class 的默认成员权限是 private

在这里插入图片描述
在这里插入图片描述

  • 上面代码中person对象、p指针的内存都是在函数的栈空间，自动分配和回收的
  • 可以尝试反汇编struct和class，看看是否有其他区别
  • 实际开发中，用class表示类比较多

C++编程规范

每个人都可以有自己的编程规范，没有统一的标准，没有标准答案，没有最好的编程规范

变量名规范参考:

  • 全局变量：g_
  • 成员变量：m_
  • 静态变量：S_
  • 常量：C_
  • 使用驼峰标识

对象的内存布局

思考：如果类中有多个成员变量，对象的内存又是如何布局的？

struct Person {
   
    int m_id; 
    int m_age; 
    int m_height;

    void display() {
   
        cout << "m id is " << m_id << endl;
        cout << "m_age is " << m_age << endl;
        cout << "m_height is " << m_height << endl;
    }
};

在这里插入图片描述

this

  • this是指向当前对象的指针

  • 对象在调用成员函数的时候，会自动传入当前对象的内存地址

struct Person {
   
    int m_id;
    int m_age;
    int m_height;

    void display() {
   
        cout << "m id is " << this->m_id << endl;
        cout << "m_age is " << this->m_age << endl;
        cout << "m_height is " << this->m_height << endl;
    }
};

思考：可以利用 this.m_age 来访问成员变量么？

  • 不可以，因为this是指针，必须用this->m_age

指针访问对象成员的本质

思考：以下代码最后打印出来的每个成员变量值是多少？

struct Person {
   
    int m_id;
    int m_age;
    int m_height;

    void display() {
   
        cout << "m id is " << this->m_id << endl;
        cout << "m_age is " << this->m_age << endl;
        cout << "m_height is " << this->m_height << endl;
    }
};

int main() {
   
    Person person;
    person.m_id = 10;
    person.m_age = 20;
    person.m_height = 30;

    Person *p = (Person *) &person.m_age;
    p->m_id = 40;
    p->m_age = 50;
    person.display();
}

答案输出是：

m id is 10
m_age is 40
m_height is 50

在这里插入图片描述

思考：如果将 person.display() 换成 p-＞display() 呢？

输出如下：

m id is 40
m_age is 50
m_height is -1063256544

此时 p->m_height 指向了一块未知的内存。、

封装

成员变量私有化，提供公共的getter和setter给外界去访问成员变量

struct Person{
   
private:
    int m_age;
public:
    void setAge(int age) {
   
        this->m_age = age;
    }
    int getAge() {
   
        return this->m_age;
    }
};

Person person;
person.setAge(20);
cout << person.getAge() << endl;

内存空间的布局

每个应用都有自己独立的内存空间，其内存空间一般都有以下几大区域

在这里插入图片描述

  • 代码段（代码区）：用于存放代码

  • 数据段（全局区）：用于存放全局变量等

  • 栈空间：

    • 每调用一个函数就会给它分配一段连续的栈空间，等函数调用完毕后会自动回收这段栈空间
    • 自动分配和回收

  • 堆空间：需要主动去申请和释放

在这里插入图片描述

在这里插入图片描述

堆空间

在程序运行过程，为了能够自由控制内存的生命周期、大小，会经常使用堆空间的内存

堆空间的申请\释放

  • malloc \ free

  • new \ delete

  • new[] \ delete[]

注意：

  • 申请堆空间成功后，会返回那一段内存空间的地址

  • 申请和释放必须是1对1的关系，不然可能会存在内存泄露

现在的很多高级编程语言不需要开发人员去管理内存（比如Java），屏蔽了很多内存细节，利弊同时存在

  • 利：提高开发效率，避免内存使用不当或泄露

  • 弊：不利于开发人员了解本质，永远停留在API调用和表层语法糖，对性能优化无从下手

下图是x86环境（32bit）:

在这里插入图片描述

堆空间的初始化

在这里插入图片描述

memset

memset函数是将较大的数据结构（比如对象、数组等）内存清零的比较快的方法

Person person;
person.m_id = 1;
person.m_age = 20;
person.m_height = 180;
memset(&person, 0, sizeof(person));

Person persons[] ={
    {
    1,20,180 }, {
    2,25,165,},{
    3,27,170 } }; 
memset(persons, 0, sizeof(persons));

对象的内存

对象的内存可以存在于3种地方：

  • 全局区（数据段）：全局变量
  • 栈空间：函数里面的局部变量
  • 堆空间：动态申请内存（malloc、new等）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

构造函数（Constructor）

构造函数（也叫构造器），在对象创建的时候自动调用，一般用于完成对象的初始化工作

特点：

  • 函数名与类同名，无返回值（void都不能写），可以有参数，可以重载，可以有多个构造函数
  • 一旦自定义了构造函数，必须用其中一个自定义的构造函数来初始化对象

注意：

  • 通过malloc分配的对象不会调用构造函数

一个广为流传的、很多教程/书籍都推崇的错误结论：

  • 默认情况下，编译器会为每一个类生成空的无参的构造函数

  • 正确理解：在某些特定的情况下，编译器才会为类生成空的无参的构造函数（哪些特定的情况？以后再提）

构造函数的调用

struct Person {
   
    int m_age;
    Person() {
   
        cout << "Person()" << endl;
    }
    Person(int age) {
   
        cout << "Person(int age)" << endl;
    }
}

在这里插入图片描述

默认情况下，成员变量的初始化

在这里插入图片描述

  • 如果自定义了构造函数，除了全局区，其他内存空间的成员变量默认都不会被初始化，需要开发人员手动初始化。

成员变量的初始化

对象初始化

Person() {
   
	memset(this, 0, sizeof(Person)); 
}

析构函数（Destructor）

析构函数（也叫析构器），在对象销毁的时候自动调用，一般用于完成对象的清理工作

特点：

  • 函数名以~开头，与类同名，无返回值（void都不能写），无参，不可以重载，有且只有一个析构函数

注意：

  • 通过malloc分配的对象free的时候不会调用析构函数
  • 构造函数、析构函数要声明为public，才能被外界正常使用。

声明和实现分离

在这里插入图片描述

命名空间

命名空间可以用来避免命名冲突

在这里插入图片描述

思考：如下代码能通过编译吗？

namespace MJ {
   
    int g_age;
}
namespace FX {
   
    int g_age;
}

using namespace MJ;
using namespace FX;

// 这句代码能编译通过么？
g_age = 20;
  • 不能，必须指明命名空间前缀，否则具有二义性，编译器无法做出判断

命名空间的嵌套

有个默认的全局命名空间，我们创建的命名空间默认都嵌套在它里面

namespace MJ {
   
    namespace SS {
   
        int g_age;
    }
}

int main() {
   
    MJ::SS::g_age = 10;
    
    using namespace MJ::SS;
    g_age = 20;

    using MJ::SS::g_age;
    g_age = 30;
}

int g_no = 20;

namespace MJ {
   
    namespace SS {
   
        int g_age;
    }
}

int main() {
   
    ::g_no = 20;
    ::MJ:SS::g_age = 30;
}

命名空间的合并

以下2种写法是等价的：

namespace MJ {
   
	int g_age;
}
namespace MJ {
   
	int g_no;
}

namespace MJ {
   
	int g_age;
	int g_no; 
}

在这里插入图片描述

其他编程语言的命名空间

Java：

  • Package

Objective-C：

  • 类前缀

继承

继承，可以让子类拥有父类的所有成员（变量＼函数）

struct Person {
   
    int m_age;
    void run() {
   
        cout << "Person::run()" << endl;
    }
};
struct Student : Person {
   
    int m_no;
    void study() {
   
        cout << "Student::study()" << endl;
    }
};

int main() {
   
    Student student; 
    student.m_age = 20; 
    student.m_no = 1; 
    student.run(); 
    student.study();
}

关系描述

  • Student 是子类（subclass，派生类）
  • Person 是父类（superclass，超类）

C++中没有像Java， Objective-C的基类：

  • Java: java.lang.Object
  • Objective-C: NSObject

继承关系中的对象内存布局

在这里插入图片描述

构造函数的初始化列表

  • 一种便捷的初始化成员变量的方式
  • 只能用在构造函数中
  • 初始化顺序只跟成员变量的声明顺序有关

下面两种代码写法是等价的：

struct Person {
   
    int m_age;
    int m_height;
    Person(int age, int hei

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

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

相关文章

chinese_llama_aplaca训练和代码分析

chinese_llama_aplaca训练和代码分析

训练细节 ymcui/Chinese-LLaMA-Alpaca Wiki GitHub中文LLaMA&Alpaca大语言模型本地CPU/GPU训练部署 (Chinese LLaMA & Alpaca LLMs) - 训练细节 ymcui/Chinese-LLaMA-Alpaca Wikihttps://github.com/ymcui/Chinese-LLaMA-Alpaca/wiki/%E8%AE%AD%E7%BB%83%E7%BB%86%E…
阅读更多...
selenium自动化测试入门 —— 获取元素对象！

selenium自动化测试入门 —— 获取元素对象！

一、元素定位简介 八种属性定位页面元素&#xff1a; By.ID By.XPATH By.LINK_TEXT By.PARTIAL_LINK_TEXT By.NAME By.TAG_NAME By.CLASS_NAME By.CSS_SELECTOR webdriver元素定位方法&#xff1a; driver.find_element(By.XXX,元素属性) # 定位单个元素 driver.find_elemen…
阅读更多...
按键精灵中常用的命令

按键精灵中常用的命令

1. 声明变量&#xff1a; Dim 2. 注释语句 (1). 单行注释&#xff1a;这是一行注释&#xff0c;使用一个单引号进行注释&#xff1b; (2). 单行注释&#xff1a;// 这是一行注释&#xff0c;使用一对反斜杠进行注释; (3). 多行注释&#xff1a;/*这是多行注释&#xff0c;中…
阅读更多...
canal+es+kibana+springboot

canal+es+kibana+springboot

1、环境准备 服务器&#xff1a;Centos7 Jdk版本&#xff1a;1.8 Mysql版本&#xff1a;5.7.44 Canal版本&#xff1a;1.17 Es版本&#xff1a;7.12.1 kibana版本&#xff1a;7.12.1 软件包下载地址&#xff1a;链接&#xff1a;https://pan.baidu.com/s/1jRpCJP0-hr9aI…
阅读更多...
基于野狗算法的无人机航迹规划-附代码

基于野狗算法的无人机航迹规划-附代码

基于野狗算法的无人机航迹规划 文章目录 基于野狗算法的无人机航迹规划1.野狗搜索算法2.无人机飞行环境建模3.无人机航迹规划建模4.实验结果4.1地图创建4.2 航迹规划 5.参考文献6.Matlab代码 摘要&#xff1a;本文主要介绍利用野狗算法来优化无人机航迹规划。 1.野狗搜索算法 …
阅读更多...
前端面试题整理（一）

前端面试题整理（一）

前言&#xff1a; 这篇博客是记录自己在看面试过程中还未完全掌握的前端知识点&#xff0c;也是一些前端面试需要掌握的知识点&#xff08;总结的并不全面&#xff0c;可以参考&#xff0c;具体情况以自己实际为准&#xff09;,并且这篇博客正在持续更新中… 附言&#xff1a…
阅读更多...
2023.11.4-Envoy使用案例-oss

2023.11.4-Envoy使用案例-oss

2023.11.4-Envoy使用案例 目录 本节实战 实战名称&#x1f6a9; 实战&#xff1a;前端代理-2023.11.2(测试成功)&#x1f6a9; 实战&#xff1a;流量镜像-2023.11.4(测试成功)&#x1f6a9; 实战&#xff1a;故障注入过滤器-2023.11.4(测试成功)&#x1f6a9; 实战&#xff1a…
阅读更多...
【Invea Therapeutics】申请7500万美元纳斯达克IPO上市

【Invea Therapeutics】申请7500万美元纳斯达克IPO上市

来源&#xff1a;猛兽财经 作者&#xff1a;猛兽财经 猛兽财经获悉&#xff0c;美国生物制药公司【Invea Therapeutics】近期已向美国证券交易委员会&#xff08;SEC&#xff09;提交招股书&#xff0c;申请在纳斯达克IPO上市&#xff0c;股票代码为(INAI) &#xff0c;Invea …
阅读更多...
基于龙格-库塔算法的无人机航迹规划-附代码

基于龙格-库塔算法的无人机航迹规划-附代码

基于龙格-库塔算法的无人机航迹规划 文章目录 基于龙格-库塔算法的无人机航迹规划1.龙格-库塔搜索算法2.无人机飞行环境建模3.无人机航迹规划建模4.实验结果4.1地图创建4.2 航迹规划 5.参考文献6.Matlab代码 摘要&#xff1a;本文主要介绍利用龙格-库塔算法来优化无人机航迹规划…
阅读更多...
xlua源码分析（二）lua Call C#的无wrap实现

xlua源码分析（二）lua Call C#的无wrap实现

xlua源码分析&#xff08;二&#xff09;lua Call C#的无wrap实现 上一节我们主要分析了xlua中C# Call lua的实现思路&#xff0c;本节我们将根据Examples 03_UIEvent&#xff0c;分析lua Call C#的底层实现。例子场景里有一个简单的UI面板&#xff0c;面板中包含一个input fie…
阅读更多...
多模态大模型最全综述

多模态大模型最全综述

由微软7位华人研究员撰写--多模态基础模型已经从专用走向通用 它从目前已经完善的和还处于最前沿的两类多模态大模型研究方向出发&#xff0c;全面总结了五个具体研究主题&#xff1a; 视觉理解视觉生成统一视觉模型LLM加持的多模态大模型多模态agent 1、谁适合阅读这份综述&…
阅读更多...
YOLOv8独家原创改进：自研独家创新BSAM注意力 ，基于CBAM升级

YOLOv8独家原创改进：自研独家创新BSAM注意力 ，基于CBAM升级

💡💡💡本文全网首发独家改进：提出新颖的注意力BSAM（BiLevel Spatial Attention Module），创新度极佳，适合科研创新，效果秒杀CBAM，Channel Attention+Spartial Attention升级为新颖的 BiLevel Attention+Spartial Attention 1）作为注意力BSAM使用； 推荐指数：…
阅读更多...
时序预测 | MATLAB实现时间序列ACF和PACF分析

时序预测 | MATLAB实现时间序列ACF和PACF分析

时序预测 | MATLAB实现时间序列ACF和PACF分析 目录 时序预测 | MATLAB实现时间序列ACF和PACF分析基本介绍程序设计参考资料基本介绍 自回归分析是线性回归分析的一种推广，主要是研究一个序列反映的自我因果关系。普通线性回归基于互相关分析，涉及两个以上的变量，一个作为因变…
阅读更多...
Iceberg教程

Iceberg教程

目录 教程来源于尚硅谷1. 简介1.1 概述1.2 特性 2. 存储结构2.1 数据文件(data files)2.2 表快照(Snapshot)2.3 清单列表(Manifest list)2.4 清单文件(Manifest file)2.5 查询流程分析 3. 与Flink集成3.1 环境准备3.1.1 安装Flink3.1.2 启动Sql-Client 3.2 语法 教程来源于尚硅…
阅读更多...
产品经理入门学习（一）：认识产品经理

产品经理入门学习（一）：认识产品经理

参考引用 黑马-产品经理入门基础课程 1. 合格的产品经理 1.1 什么是产品 上述产品的共性&#xff1a;解决某个问题的东西上述产品的区别 有形&#xff08;上图左&#xff09;&#xff1a;颜色、形状、质地和尺寸无形&#xff08;上图右&#xff09;&#xff1a;脑力劳动成果、…
阅读更多...
Leetcode—101.对称二叉树【简单】

Leetcode—101.对称二叉树【简单】

2023每日刷题&#xff08;十九&#xff09; Leetcode—101.对称二叉树 利用Leetcode101.对称二叉树的思想的实现代码 /*** Definition for a binary tree node.* struct TreeNode {* int val;* struct TreeNode *left;* struct TreeNode *right;* };*/ bool isSa…
阅读更多...
华为升腾C92安装win7

华为升腾C92安装win7

华为升腾C92安装win7 不知道什么原因&#xff0c;当初那批C92配置到学校班班通时&#xff0c;安装的是Linux系统。这也造成了我错误地认为C92这个小鸡子太弱了&#xff0c;只能运行Linux还行&#xff0c;无法运行Windows的。 其实错了&#xff0c;我们可以在C92开机时&#xff…
阅读更多...
轻量封装WebGPU渲染系统示例＜15＞- DrawInstance批量绘制(源码)

轻量封装WebGPU渲染系统示例＜15＞- DrawInstance批量绘制(源码)

当前示例源码github地址: https://github.com/vilyLei/voxwebgpu/blob/main/src/voxgpu/sample/DrawInstanceTest.ts 此示例渲染系统实现的特性: 1. 用户态与系统态隔离。 细节请见&#xff1a;引擎系统设计思路 - 用户态与系统态隔离-CSDN博客 2. 高频调用与低频调用隔离。…
阅读更多...
IEEE CAI2024

IEEE CAI2024

投递链接&#xff1a; ​https://ieeecai.org/2024/
阅读更多...
Spring 中 BeanFactory 和 FactoryBean 有何区别？

Spring 中 BeanFactory 和 FactoryBean 有何区别？

这也是 Spring 面试时一道经典的面试问题&#xff0c;今天我们来聊一聊这个话题。 其实从名字上就能看出来个一二&#xff0c;BeanFactory 是 Factory 而 FactoryBean 是一个 Bean&#xff0c;我们先来看下总结&#xff1a; BeanFactory 是 Spring 框架的核心接口之一&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023