编程与计算机基础 on 庄泽伟的博客

C++ 基础

Sun, 16 Feb 2025 15:16:25 +0800

C++中int* a = new int(10)与int* a = new int[10]的区别

int* a = new int(10)表示申请一个内存空间，存放的初值是10。释放：delete a;
int* a = new int[10]表示申请一个存放十个元素的数组。释放：delete[] a;

map和unordered_map的区别和联系

一、map和unordered_map的实现机理： map:是基于红黑树来实现的（红黑树是非常严格的平衡二叉搜索树），红黑树具有自动排序功能，红黑树的每一个节点都代表着map中的一个元素，因此对于map的查找，删除和插入操作都是对红黑树的操作。 unordered_map:是基于哈希表来实现的，查找的时间复杂度是O(1),在海量数据处理中有着广泛的应用。

二、map和unordered_map的优缺点 map的优点：（1）map是有序的（2）基于红黑树实现，查找的时间复杂度是O(n) map的缺点：空间占用率比较高，因为内部实现了红黑树，虽然提高了运行效率，但是每个节点都要保存父亲节点和孩子节点和红黑树的性质，使得每一个节点都占用大量的空间。适用的情况：对于要有序的结构，适用map

unordered_map的优点：因为内部是哈希表来实现的，所以查找效率会非常高 unordered_map的缺点：哈希表的建立比较费时适用的情况：对于查找问题，适用unordered_map会更好一点。

C++多态

面向对象思想的“三大特征”：多态、封装、继承多态的定义：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果

编译时的多态：通过重载实现
运行时的多态：通过虚成员实现

作用：增加程序的可扩充性，降低后期修改代码的难度。

多态的实现：拥有虚函数的类，通过基类指针或引用动态调用基类函数或继承类函数，每个虚函数的类都有一个虚函数表，该类任何对象都有虚函数指针。

虚函数是怎么实现的

虚函数通过虚函数表实现

结构体内存对齐

内存对齐：结构体内数据将对齐最长的数据原因：

操作系统为了提高访问内存的策略，降低二次访问
便于移植，不是所有硬件平台都能任意访问地址上的任意数据
防止空间浪费

常见类型长度（64位操作系统）： char（1）、int（4）、double（8）、float（4）、string（40）、指针（8）

函数重载与重写

重载：概念：同一作用域内，定义相同名称的函数，参数列表必须不同（个数或类型），返回值可相同可不相同。作用：命名一组功能相似的函数，避免名字空间污染，增加程序可读性。

重写：概念：也称覆盖，子类重新定义父类中有相同名称和参数的虚函数，返回类型可以不同但必须是父类返回类型的子类。作用：实现面向对象的三大特性之一的多态

tips：

不是虚函数也能进行重写，但在一个类中声明一个非虚函数实际上为这个类建议一种特殊性上的不变性，没必要重写这个非虚函数。
父实子虚（子类无法更改父类函数）或父虚子实（子类屏蔽父类函数）都是设计错误。

赋值符重载与拷贝构造函数

赋值符重载：重载operator=函数，给一个对象赋值时会调用重载过的赋值运算符。拷贝构造函数：以拷贝的方式初始化一个对象，调用拷贝构造函数

区别：

赋值运算符没有新的对象生成，拷贝构造函数会生成新的对象。

拷贝构造函数何时调用

用类的一个对象初始化类的另一个对象时。
函数的形参或函数的返回值是类的对象时。

四种类型转换运算符

static_cast：用于良性转换
const_cast：用于const和非const、volatile和非volatile之间的转换。
reinterpret_cast：高度危险转换，对二进制位重新解释。
dynamic_cast：用于基类对象的指针或引用转换为继承类对象的其他指针或引用

const的用法

const：常量限定符，用来限定特地变量，使其不可被编译器修改。用法：

const修饰基本数据类型，例如：const int a = 1;
const修饰指针：const int* p（指针常量）、int* const p（常量指针）、const int* const p（常量指针常量）
const修饰引用
const修饰函数形参，修饰函数返回值，修饰成员变量，修饰整个函数

static作用

修饰全局变量，使其他文件不可见。
修饰局部变量，使其不会因为函数终止而删除。
修饰函数，使其他文件不可见。
修饰类的数据成员，该类所有对象这个数据只有一个实列。
修饰类成员函数，该函数只能访问它的参数，类静态数据，以及全局变量。

vector的push_back原理

vector有预存内存（大小为capacity），当存入元素溢出，会重新分配一个比原来大2倍或1.5倍的内存。

tips：原来的指向旧内存的指针会变为野指针。

析构函数可以是虚函数吗

析构函数可以是虚函数，有时必须声明为虚函数，否则会出现：父类析构，子类没析构的情况，从而产生析构不完全。

析构函数为什么不能是虚函数

创建对象时需要确定对象类型，而虚函数在运行时动态确定其类型，而构造对象时，由于对象未创建，编译器无法知道对象类型，因此虚函数无法动态确定其类型
虚函数调用需要虚函数表指针，而该指针存放在对象内存空间中，对象还没创建，没有内存存放虚函数表，无法调用虚构造函数。

引用和指针的差别

指针是变量，存放地址，指向内存的存储单元。引用是原变量的别名，与原变量是同一个东西。
指针可以多级指针，引用只能一级。
指针可以不初始化，引用必须初始化。
指针可以指向NULL，引用不可以。
指针可以改变，引用不可以（引用的值改变，被引用的值也会被改变）。

STL是什么？

STL：标准模板库，一些容器、算法和一些组件的集合，容器包括vector、list、map、set等。六大类组件：容器、迭代器、算法、函数对象、适配器、分配器。

Container(容器)：各种数据结构，如Vector,List,Deque,Set,Map,用来存放数据，STL容器是一种Class Template,就体积而言，这一部分很像冰山载海面的比率。
Adapter(适配器)：一种用来修饰容器（Containers）或仿函数（Functors）或迭代器（Iterators）接口的东西，例如：STL提供的Queue和Stack，虽然看似容器，其实只能算是一种容器配接器，因为 它们的底部完全借助Deque，所有操作有底层的Deque供应。改变Functor接口者，称为Function Adapter;改变Container接口者，称为Container Adapter;改变Iterator接口者，称为Iterator Adapter。配接器的实现技术很难一言蔽之，必须逐一分析。
Algorithm(算法)：各种常用算法如Sort,Search,Copy,Erase,从实现的角度来看，STL算法是一种Function Templates。
Iterator(迭代器)：扮演容器与算法之间的胶合剂，是所谓的“泛型指针”，共有五种类型，以及其它衍生变化，从实现的角度来看，迭代器是一种将：Operators*,Operator->,Operator++,Operator--等相关操作予以重载的Class Template。所有STL容器都附带有自己专属的迭代器——是的，只有容器设计者才知道如何遍历自己的元素，原生指针（Native pointer）也是一种迭代器。
Function object(函数对象)：行为类似函数，可作为算法的某种策略（Policy）,从实现的角度来看，仿函数是一种重载了Operator()的Class 或 Class Template。一般函数指针可视为狭义的仿函数。
Allocator(分配器)：负责空间配置与管理，从实现的角度来看，配置器是一个实现了动态空间配置、空间管理、空间释放的Class Template。

作用：可以更加方便灵活地处理数据

map：关联容器，提供一对一地hash 特性：

内部实现是红黑树结构，具有自动排序的功能。

vector：封装了动态大小数组的顺序容器特性：

容器内元素按严格的线性顺序排序，支持索引访问，随机存取时间复杂度为O（1），查找时间复杂度为O（n）
添加元素时会进行动态分配内存。
常用函数：push_back()、pop_back()、empty() 、sort()等

list：用双向环形链表实现，内存空间不连续。插入和删除时间复杂度O（1）

haspmap：基于哈希表，具有快速存储和查找的优点，但消耗内存多。原理：使用一个下标范围比较大的数据存储元素，存储key时，将其哈希化，获得对应桶号，将value存入桶中。

C++内存分配方式

静态存储区分配内存：程序编译时就分配好，程序地整个运行期间都存在，例如全局变量，静态变量。栈上分配内存：系统自动分配，如函数内部的局部变量，随着函数结束而释放。堆上分配内存：程序员动态分配内存，例如new、malloc。

malloc/free和new/delete的区别

共同点：都是从堆上申请空间，并且需用用户手动释放。区别：

malloc和free是函数，new和delete是操作符。
malloc申请空间要手动计算空间大小，new只需在其后输入空间类型。
malloc申请空间不会初始化，new可以初始化。
malloc申请空间失败，返回NULL，new申请失败，抛出异常。
malloc返回void*，new返回空间类型。

C++11新特性

auto（值推导）
左值右值：
1. 左值：能取地址且有名字
2. 右值：不能取地址且没有名字
列表初始化
lambda表达式
智能指针
nullptr
const/constexpr
sizeof
内存对齐

智能指针（动态指针）

智能指针：利用对象生命周期控制程序资源的技术作用：防止内存泄漏、二次释放等问题指针类型：

shared_ptr：多个指针指向相同的对象。共享资源所有权的指针.
unique_ptr：“唯一”拥有其所指对象，同一时刻只能有一个unique_ptr指向给定对象。独占资源所有权的指针。
weak_ptr：配合shared_ptr而引入的一种智能指针。

lambda表达式

lambda表示式：定义一个匿名函数，可以捕获一定范围内的变量。优点： 1. 可维护性高。 2. 简洁：避免代码膨胀，功能分散。 3. 在需要的时间和地点实现功能闭包，使程序更灵活。缺点：

代码可读性变差。
学习难度高。 3. 不容易调试。

强枚举类型（enum class）

传统枚举类型：由用户定义的若干枚举常量的集合。枚举值对应整数数值，默认从零开始。存在问题：

同作用域同名枚举报错。
无法自定义枚举常量定义类型。（c++11可以）
枚举常量占用存储空间及符号不确定。因此强枚举类型（enum class）诞生，优点：
强作用域：不同枚举集合可取同名枚举。
转换限制：不再与整型发生隐式转换。
自定义枚举常量定义类型。

C++编译连接过程

源代码（预编译检查） -》编译器 -》汇编代码 -》汇编器 -》目标代码（机器指令） -》连接器 -》可执行程序。

一个空的class类里有什么

包含六个默认函数：

默认构造函数
拷贝构造函数
析构函数
赋值运算符重载
取地址操作符重载
const修饰的取地址操作符重载

内联函数的含义？

内联函数：用关键字inline修饰的函数，每次调用，都写一次函数在对应位置优点：避免指针跳转，加快程序执行速度缺点：导致程序代码量庞大，占用更多内存空间

数组越界要怎么知道？

发现是否有数组越界问题，没有特殊的好方法，一般采用静查法（认真阅读，检查程序是否按照设计要求编写）。
调试法，通过测试例子，测试结果是否与预期结果一致，进行判断。

野指针

野指针：没有指向有效内存的指针造成野指针的原因：

指针变量未初始化。
指针指向内存被释放，而指针没有处理。
指针超过变量作用范围，例如函数局部变量的地址值被传出来，而局部变量会在函数执行完自动清理

函数运行全过程的底层机制

主函数正常运行，遇到被调用函数。
分配被调用函数所需要的栈空间。
保存当前函数运行状态和返回地址。
传递参数给被调用函数，并将控制权转交给被调函数。
被调函数执行完毕，通过返回地址返回之前函数的状态，释放栈空间。

typedef和define有什么区别

typedef：常用来定义一个标识符及关键字的别名，增加程序的可读性常用于：

定义类型别名
辅助struct定义别名
定义与平台无关的类型

define：宏定义语句，定义常量，在预编译过程完成区别：宏定义只是简单的字符串代换（原地扩展），typedef具有一定的封装性。

例如： typedef （int*） pINT； pINT a,b效果等于int *a, b; define pINT int； pINT a,b效果等于int *a, b;

define与const的区别

共同作用：定义常量区别：

编译器处理方式：define作用于预处理，const作用于编译阶段。
类型检查：define无类型，不进行类型安全检查，const有数据类型，进行类型检查
内存空间：define不分配内存，const在静态存储区分配内存。

vector中resize()和reserve()区别

resize(): 重新申请并改变当前vector对象的有效空间大小，改变有效空间大小：小于空间大小，裁剪多出来的数据，capacity不变，大于空间大小，赋值为定义数据，capacity大小与改变大小相同。

reserve()：重新申请并改变当前vector对象的总空间（capacity）大小，不改变有效数据大小。

递归与循环（迭代）的区别

区别在于：函数或算法是否具备收敛性，具备收敛性，才能使用递归。优越点：递归：内存占用高，但容易理解迭代：运行效率高，但不易理解

C和C++的区别

C和C++的主要区别在于C是过程式编程语言，不支持类和对象，而C++是过程式和面向对象编程语言的结合；因此C++可以被称为混合语言。

拷贝构造函数和移动构造函数

拷贝构造函数：它是一种特殊的构造函数。它的作用就是用一个已经生成的对象来初始化另一个同类的对象。当类中拥有指针类型的成员变量时，拷贝构造函数中需要以深拷贝（而非浅拷贝）的方式复制该指针成员。

1
2
3
4


Integer(const Integer& source)
	: m_ptr(new int(*source.m_ptr)) {
	cout << "Call Integer(const Integer& source)拷贝" << endl;
}

移动构造函数：指的就是以移动而非深拷贝的方式初始化含有指针成员的类对象。简单的理解，移动语义指的就是将其他对象（通常是临时对象）拥有的内存资源“移为已用”。

1
2
3
4
5


Integer(Integer&& source)
 : m_ptr(source.m_ptr) {
	source.m_ptr= nullptr;
	cout << "Call Integer(Integer&& source)移动" << endl;
}

std::move() 能把左值强制转换为右值。

memcpy的用法

c和c++使用的内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。

如果复制的字节数n超出了dest的空间容量，或者n超出src的容量，这个函数是不会进行判断的，这样就会很危险。需要程序员自己检查是否有溢出的情况出现。
这个函数不会检查参数dest与参数src所指向的数组（或其他类型）是否具有同样的空间。

memset函数

函数功能：为指针变量s所指的前n个字节的内存单元填充给定的int型数值c，它可以为任何数据进行初始化。换句话说，就是将数值c以单个字节逐个拷贝的方式放到指针变量s所指的内存中去。注意：只将数值c的最低一个字节填充到内存。

内存分配机制

1、栈区（stack）：由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS（操作系统）回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
3、全局区（静态区）（static）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。
4、文字常量区：常量字符串就是放在这里的。程序结束后由系统释放。
5、程序代码区：存放函数体的二进制代码。

进制之间的转换

R进制数转换为十进制数：按权展开相加（系数乘以基数的权次方相加）
十进制转换R进制：将十进制整数转换成R进制整数采用“除R取倒余法”。即将十进制整数除以R，得到一个商和一个余数；再将商除以R，又得到一个商和一个余数；以此类推，直到商等于零为止。每次得到的余数的倒排列，就是对应R进制数的各位数。

各种容器的迭代器失效问题

迭代器失效是指当容器底层存储发生变动时，原来指向容器中某个或某些元素的迭代器由于元素存储位置发生了改变而不再指向他们，从而成为无效的迭代器。引起迭代器失效的主要操作有：改变容器容量的方法：reserve()、resize()、push_back()、pop_back()、insert()、erase()、clear() 一些泛型算法：sort()、 copy() 、replace()、 remove()、 unipue()

#include＜＞和#include“”

#include<>：编译器直接从系统类库目录里查找头文件： #include""：默认从项目当前目录查找头文件，所谓项目当前目录，就是项目工程文件（*.vcxproj）所在的目录

操作系统

Sun, 16 Feb 2025 15:16:25 +0800

LRU怎么实现的？

LRU：（Least Recently Used）最近最少使用，常用于页面置换算法，是为虚拟页式存储管理服务的。

原理：使用双向链表和哈希表实现LRU算法，

双向链表用于保存key-value，队头的元素表示最近一次被访问的元素，队尾的元素表示最近最久未使用的元素
哈希表提供key到key对应节点在双向链表中的位置的映射。

进程和线程的联系和区别

进程是表示资源分配的基本单位，线程是进程中执行运算和调度的最小单位。

一个线程只能属于一个进程，而一个进程可以拥有多个线程。
资源分配给进程，同一进程的所有线程共享该进程的所有资源。
进程拥有独立的地址空间，进程都是建立在虚拟内存的基础上，而线程没有独立的地址空间。
进程比线程健壮，一个进程崩溃不会影响其他进程，而一个线程崩溃会导致整个进程崩溃。
进程执行开销大，而线程依附于进程，执行开销小。

什么是死锁？死锁产生的条件？如何解除死锁？

死锁：在两个或者多个并发进程中，如果每个进程持有某种资源而又等待其他进程释放它们保持的资源，从而导致进程无法继续进行，称为死锁。简单的来说，就是两个及以上进程无限期阻塞、相互等待的一种状态。

死锁产生的四个必要条件：

互斥：至少有一个资源是非共享的。
占有并等待：进程保持某种资源又同时申请其他资源（该资源被其他进程占有）。
非抢占：进程不能被抢占，资源只能被进程主动释放。
循环等待：若干个进程之间形成一种头尾相接的环形等待资源关系。

如何预防死锁：

死锁预防（将四个必要条件至少一个条件打破，就能预防死锁）：

a. 打破互斥条件：使资源共享。

b. 打破占有并等待：实行资源预先分配策略

c. 打破非抢占式条件：允许进程抢夺其他进程资源。

d. 打破循环等待条件：实现资源有序分配策略。
死锁解除

a. 进程终止。

b. 资源抢占。

进程有哪几种状态？

1. 就绪状态：进程已获得除处理机以外的所需资源，等待分配处理机资源。

2. 运行状态：占用处理机资源运行。

3. 阻塞状态：等待某种资源或条件导致进程无法继续运行。

分页和分段有什么区别（内存管理）？

段式存储：将程序的地址空间划分为若干段，每一段存储相同意义的信息。

页式存储：将程序的逻辑地址划分为固定大小的页，物理内存也划分同样大小的帧。

区别：

目的不同：分页服务于系统管理，分段服务于用户，段内数据是一组有意义且相对完整的信息。
大小不同：页的大小固定，段长度由功能决定。
地址空间不同：段向用户提供二维地址空间，页向用户提供一维地址空间。
信息共享：段是信息的逻辑单位，便于存储保护和信息共享，页的保护和共享受到限制。
内存碎片：页式存储没有外碎片，但会有内碎片；段无内碎片，但会产生外碎片。

操作系统中进程调度策略有哪几种？

FCFS（先来先服务，队列实现，非抢占）：所有进程平等，缺点：无法让紧急进程优先
SJF（最短作业优先）：缺点：难以找到哪个进程最短
优先级调度算法（可抢占）：优先级越高越先分配，相同优先级先来先服务。缺点：会出现饥饿现象。
时间片轮转调度算法（可抢占）：每个进程分配一个时间片的CPU时间，进程CPU超过时间片，则被抢占并放回队列。
多级队列调度算法：将就绪队列分成多个独立队列，每个队列有各自的调度算法，队列之间采用固定优先级抢占调度。进程被永久分配在一个队列里。
多级反馈队列调度算法：与多级队列调度算法相比，进程可以在队列之间移动。可以防止饥饿现象。

什么是虚拟内存？

虚拟内存：每个进程拥有独立地址空间，空间被分为许多相同大小的页，运行部分在物理内存中，未运行部分在外存中，那部分缺少，就从外存调入物理内存运行。而对进程而言，逻辑上有很大的内存空间。

IO多路复用

单线程或单进程同时监测若干个文件描述符是否可以执行IO操作的能力。

I/O模型 目前Linux系统中提供了5种IO处理模型

阻塞IO
非阻塞IO
IO多路复用 IO多路复用在Linux下包括了三种，select、poll、epoll，抽象来看，他们功能是类似的，但具体细节各有不同：首先都会对一组文件描述符进行相关事件的注册，然后阻塞等待某些事件的发生或等待超时。更多细节详见下面的 “具体怎么用”。IO多路复用都可以关注多个文件描述符，但对于这三种机制而言，不同数量级文件描述符对性能的影响是不同的

解决方案总览： Linux: select、poll、epoll MacOS/FreeBSD: kqueue Windows/Solaris: IOCP
信号驱动IO
异步IO

计算机图形学

Sun, 16 Feb 2025 15:16:25 +0800

光追加速结构(BVH树)

一、层次包围体 BVH Bounding volume hierarchy (BVH)即层次包围体，在BVH中，所有的几何物体都会被包在bounding volume的叶子节点里面，bounding volume外面继续包着一个更大的bounding volume，递归地包裹下去，最终形成的根节点会包裹着整个场景。常用于碰撞检测和光线追踪的加速，能够将时间复杂度降低到关于物体数量的对数级别。

二、轴对齐包围盒 AABB 轴对齐包围盒：axis-aligned bounding box, 缩写为 AABB

光线追踪

真实地显示物体的方法,光线跟踪方法沿着到达视点的光线的反方向跟踪，经过屏幕上每一个象素，找出与视线相交的物体表面点P0，并继续跟踪，找出影响P0点光强的所有光源，从而算出P0点上精确的光线强度，在材质编辑中经常用来表现镜面效果。光线跟踪或称光迹追踪是计算机图形学的核心算法之一;

视觉展示：

亮度：受光与平面的夹角影响，自身颜色 [图片未在原笔记仓库中找到] [图片未在原笔记仓库中找到]
阴影，反射，折射：光线路径是否有阻挡，阻挡程度
漫反射 [图片未在原笔记仓库中找到]

渲染管线

渲染管线贴切的翻译应该叫渲染流水线，作用：将数据从3D场景转换为2D图像，并最终在屏幕上显示出来的过程。分为：应用阶段、几何阶段、光栅阶段。

应用阶段：碰撞检测、计算数据（顶点坐标、法向量、纹理坐标、纹理），通过数据总线传给图形硬件。

几何阶段：顶点着色器（MVP变换）–》曲面细分着色器（修改网格精度）–》几何着色器（生成多种图元）–》裁剪与背面剔除（去掉多余的点和面）–》屏幕影射（NDC空间）。

光栅阶段：矢量图形转化成像素点的过程。

光照模型

一．综述 [图片未在原笔记仓库中找到]

二．真实感渲染(Photorealistic Rendering) [图片未在原笔记仓库中找到] 真实感图形技术包括消隐技术、光照模型、明暗处理和纹理及纹理映射，阴影生成等

三．光照模型（illumination model）当光照射到物体表面时,物体对光会发生反射、透射、吸收、衍射、折射、和干涉,其中被物体吸收的部分转化为热,反射、透射的光进入人的视觉系统,使我们能看见物体。为模拟这一现象,我们建立一些数学模型来替代复杂的物理模型，这些模型就称为明暗效应模型或者光照明模型。

3.1什么是局部光照模型： [图片未在原笔记仓库中找到] 在真实感图形学中,仅处理光源直接照射物体表面的光照明模型被称为局部光照明模型。

Lambert漫反射模型 Lambert是光源照射到物体表面后，向四面八方反射，产生的漫反射效果。这是一种理想的漫反射光照模型。如下图：这个是顶点函数处理后的该光照模型，因此看起来像素不够平滑。 [图片未在原笔记仓库中找到]
phong光照明模型 Lambert模型较好的表现了粗糙表面的光照现象，如墙壁，纸张等，但是在用于诸如金属等有光泽效果的材质上则会显得呆板，表现不出光泽，主要原因是Lambert光照模型没有考虑表现这些表面的镜面反射效果。 [图片未在原笔记仓库中找到]
BlinnPhong光照模型 BlinnPhong光照模型混合和了Lambert的漫反射和标准的高光，渲染有时比Phong高光更柔和、更平滑，此外它的处理速度相当快，因此成为许多CG软件中默认的光照渲染方法。 Phong模型及它的改进模型Blinn-Phong模型至今仍在使用，比如著名的3D软件3dsMax中的基于它们的Blinn-Phong明暗器。
cook-torrance光照模型 BlinnPhong模型和cook-torrance模型均建立在双向反射率这一概念上.双向反射率的定义为表面朝给定方向的反射光亮度与入射光在景物表面产生的照度之比.

3.2什么是全局光照模型 [图片未在原笔记仓库中找到] 全局光照模型是基于光学物理原理的，光照强度的计算依赖于光能在现实世界中的传播情况，考虑光线与整个场景中各物体表面及物体表面间的相互影响，包括多次反射、透射、散射等。因此，与局部光照模型相比，全局光照模型需要相当大的计算量，但同时也能取得非常逼真的真实效果。

3.3光线跟踪光线跟踪算法通过模拟光的传播方式，即光从光源出发经过若干次反射或折射到达摄像机的过程来实现全局光照效果。其思想起源于光线投射算法。由于只有最终到达摄像机的光线才会对生成的图像有贡献，因此光线跟踪的实现通常是从摄像机逆向发出光线，以寻找达到光源的路径。尽管对光线的跟踪方向不同，两者所遵循的计算方式是一致的。其核心操作是寻找光线与场景中物体的交点。

whitted光线追踪 whitted提出了一种递归的光线跟踪方式，可实现直接光照、镜面反射和折射效果，如图所示。为了确定着色点是否对光源直接可见，算法从着色点向光源发射一条阴影线以寻找任意交点。如果交点存在，则意味着光照被某个物体遮挡，因而着色点必然位于阴影中。否则，着色点一定能够直接被光源照射到。为了实现镜面的反射和折射效果，当光线命中一个材质为镜面的物体时，跟踪过程在结束对当前着色点的直接光照后，会继续向反射和折射方向发射新的光线。反射和折射方向可根据物理定律得到。由于新的光线又会重复可见性判定和着色操作，因此整个跟踪过程可以按照递归的方式实现。通常，阴影线、反射和折射线被统称为次级光线以区别于从摄像机发出的主光线。 [图片未在原笔记仓库中找到]
分布式光线跟踪分布式光线跟踪引入了随机采样的思想，可以实现比递归光线跟踪更加丰富的效果。递归光线跟踪只允许点光源模型，即光源与着色点之间的遮挡判定只有“是”或“否”两种结果。因而只能实现硬阴影效果。而分布式光线跟踪允许使用面积光源从而能够支持软阴影效果。通过从面积光源表面随机抽取若干采样点，光源与着色点间可以形成多条阴影线。遮挡关系可以通过综合多条阴影线的判定结果得出。随着阴影线数量的增加，遮挡关系的表示精度也相应扩大，从而使阴影的程度不仅限于“是”或“否”两种级别。

3.4辐射度辐射度方法对热辐射的发散和反射的描绘基于热能工程模型,它为物体间的多重反射提供了更加精确的处理方法,避免了对漫反射光线直接处理。

辐射度方法是一种物体空间的算法,用于解离散的点或者环境中的表面曲面片的光强度问题,而不是用于解图像平面投影中的像素问题。因此,解是独立于观察者的位置的。辐射度方法也是一种能量守恒或者叫做能量平衡的方法,它作为一个封闭的空间中所有表面的辐射度提供一个解。对于系统的输入,能量来自那些作为发射器的表面。

3.5光子映射在提出光子映射之前,主流的全局光照渲染算法是光线跟踪和辐射度算法,早期的光线跟踪算法只能处理镜面反射、折射以及直接光照,随着蒙特卡罗的方法对光线跟踪算法进行的扩展,使得光线跟踪算法可以处理焦散、间接光照等效果,这种方法对甸条光线使用随机的光线分布,要得到满意的图像需要对光线进行大量的采样。

光子映射在1994年被提出,95年有第一篇关于它的论文发表,它可以很好模拟包括漫反射辉映、焦散等全局光照效果,和一般的光线跟踪一样的灵活,但计算时间却少得多。当然,光子映射仍然无法达到实时的地步。

基飞光子映射的全局光照算法有两步:

第一步,从光源向场景发射光子,少在它们碰到镜面物体时发生反射,在碰到镜面物体时按一定几率反射,将不发生反射的光子保存在一个光子图中,建立光子图。光子图表示了光源发出的能量在场景中的分布。

第二步,渲染,使用统计方法从光子图中提取出场景中所有点的入射通量以及反射辐射能。光子图与场景表述是完全分离开的,这一特性使得光子映射方法能处理很复杂的场景,包括千万个三角面片,实例化的几何体,复杂的过程式物体.

计算机网络

Sun, 16 Feb 2025 15:16:25 +0800

TCP和UDP区别

TCP（传输控制协议），是面向连接，可靠，基于字节流的传输协议，只支持单播，可以全双工通信，拥有拥塞控制，流量控制。建立连接使用三报文握手，断开连接使用四报文挥手。

UDP（用户数据报协议），是无连接，不可靠，基于报文流的传输协议，支持单播、多播、广播，不可以全双工通信。

TCP三报文握手

第一次握手：客户端–》服务端（数据包：SYN=1，seq=x），客户端进入SYN_SENT状态。

第二次握手：服务端–》客户端（数据包：SYN=1，ACK=1，seq=y，ack=x+1），服务端进入SYN_RCVD状态。

第三次握手：客户端检查数据包是否准确，客户端–》服务端（数据包：ACK=1，seq=x+1，ack=y+1），服务端检查数据包是否准确，两者进入ESTABLISHED状态。

TCP四报文挥手

第一次挥手：客户端–》服务端（数据包：FIN=1，ACK=1，seq=u，ack=v），客户端进入FIN_WAIT_1状态。客户端不再发送数据，但可以接收数据。

第二次挥手：服务端–》客户端（数据包：ACK=1，seq=v，ack=u+1），服务端进入CLOSE_WAIT状态。服务端开始处理剩下的数据（采用四报文握手的主要原因）。客户端接收ACK，进入FIN_WAIT_2状态。

第三次挥手：服务端–》客户端（数据包：FIN=1，ACK=1，seq=w，ack=u+1），服务端进入LAST_ACK状态。服务端不再发送数据。

第四次挥手：客户端–》服务端（数据包：ACK=1，seq=u+1，ack=w+1），客户端进入TIME_WAIT状态（防止最后的确认数据包丢失）,服务端接收ACK，进入CLOSED状态，一段时间后，客户端也进入CLOSED状态。

为什么会采用三次握手，若采用两次握手可以吗？

采用三次握手原因：防止接收端接收到失效的连接请求报文，因而产生错误。

若采用两次握手：

如果发送端有一条失效了很久的请求连接报文段，因为网络滞留导致连接结束才到达服务端，如果只两次握手，此时接收端就会直接建立连接，而服务端发送的确认报文段也无客户端响应，导致服务端浪费资源，一直等待客户端响应。
如果直接两次握手，只能说明发送端与接收端建立了正常通信，不能说明接收端与发送端建立正常通信。

TCP如何实现可靠连接

1. 序列号：防止数据乱序。

2. 确认应答机制/超时重传：防止数据丢包或重复包。

3. 检验和：检查包内数据是否正确。

4. 流量控制：通过滑动窗口动态控制数据传输速度。

5. 拥塞控制：防止网络瘫痪。

设计一个可靠的UDP协议应该怎么做？

UDP不可靠原因：UDP传输过程中会出现丢包、数据不完整、乱序等问题。解决问题：

防止丢包：加入确认应答机制和超时重传。
数据不完整：加个16或32位的CRC验证字段。
乱序：加个数据包序列号SEQ。

现有的：RUDP(Reliable UDP)

IP地址的作用，以及MAC地址的作用

MAC地址是硬件地址，定义网络设备位置，由数据链路层负责。IP地址由IP协议提供的统一的地址格式，为互联网的每一个网络和主机分配一个逻辑地址，来抵消物理地址的差异。

用户从输入URL到显示页面整个过程

DNS解析URL，浏览器查询DNS，获取域名对应的IP地址。
浏览器向服务器请求连接（TCP三报文握手）。
浏览器向服务器发送HTTP请求。
服务器接收请求，根据路径参数映射到请求处理器处理，并将处理结果返回浏览器。
浏览器解析并渲染页面。

TCP拥塞控制？以及达到什么情况的时候开始减慢增长速度

拥塞控制：防止过多数据注入网络，导致网络瘫痪。

原理：

慢开始：最开始发送方拥塞窗口（cwnd）为1，每经过一次传输轮次RTT，拥塞窗口（cwnd）加倍，当cwnd超过慢开始门限，使用拥塞避免算法。
拥塞避免算法：每经过一次传输轮次RTT，拥塞窗口（cwnd）+1，一旦发现网络拥塞，将慢开始门限设置为当前值一半，重新慢开始。
快重传：接收方每收到一个失序报文段就立即发出重复确认，发送方只要收到3个重复确认就立即重传。
快恢复：当发送方连续收到三个重复确认，就将慢开始门限减半，将当前窗口设置为慢开始门限，并采用拥塞避免算法。

OSI网络体系结构

应用层：为用户的应用进程提供网络通信服务。
表示层：数据编码，压缩和解压缩，数据的加密和解密。
会话层：用户应用程序和网络之间的接口。
传输层：提供可靠的数据传输。
网络层：将网络地址翻译成对应的物理地址，并选择最适当的路径。
数据链路层：接收物理层的比特流数据，封装成帧。接收网络层的帧，拆装为比特流数据。
物理层：相邻计算机节点之间比特流的透明传送。

TCP/IP模型

4. 应用层：

3. 传输层：

2. 网络层：

1. 物理链路层：

设计模式

Sun, 16 Feb 2025 15:16:25 +0800

单例模式

一个类中只产生一个对象，并提供一个外部访问点，被程序全员共享，简化了在复杂环境下的配置管理，这种模式被成为单例模式。

特征：

单例类最多只能有一个实例；
单例类必须自己创建自己唯一的实例；
单例类必须给所有其他的对象提供这一实例。

优点：1.内存中该类只实例化了一个对象，减少了内存的消耗；2.避免资源的重复占用缺点：单例类的话，不能被继承，因为它的构造函数那些东西都是私有(private)的；

一、饿汉模式不管用不用，在程序开始就加载，会导致程序启动慢，且如果有多个单例类对象实例启动顺序不确定。线程安全，一共只生成一个静态对象。饿汉模式虽好，但其存在隐藏的问题，在于非静态对象（函数外的static对象）在不同编译单元中的初始化顺序是未定义的。如果在初始化完成之前调用 getInstance() 方法会返回一个未定义的实例。

将单例类的唯一对象实例，通过一个静态成员变量来实现，加载进程时即完成创建，无论用或不用该单例对象都一直存在。当这个对象特别大的时候，无论你用不用该对象，在使用程序开始的那一课开始，对象已经存在，会造成巨大的内存浪费。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


// .h
class HungerSingleton {
private:
	static HungerSingleton instance;	//静态对象
	HungerSingleton();
	~HungerSingleton();
	//防拷贝
	HungerSingleton(const HungerSingleton&) = delete;
	HungerSingleton& operator=(const HungerSingleton&) = delete;
public:
	static HungerSingleton* GetInstance();
	void func(int n)
	{
		std::cout << n << std::endl;
		Sleep(n);
	}
};


// .cpp
#include"HungerSingleton.h"
HungerSingleton HungerSingleton::instance;	//类外初始化

HungerSingleton* HungerSingleton::GetInstance() {
	return &instance;
}
HungerSingleton::HungerSingleton() {
	std::cout << "HungerSingleton构造函数" << std::endl;
}
HungerSingleton::~HungerSingleton() {
	std::cout << "HungerSingleton析构函数" << std::endl;
}


// main
int main() {	//HungerSingleton构造函数
	auto hung = HungerSingleton::GetInstance();
	hung->func(5);	//5
	hung->func(3);	//3
	return 0;	//HungerSingleton析构函数
}

二、懒汉模式等到用的的时候程序再创建实例对象第一次使用实例对象时，创建对象，进程启动无负载。多个单例实例启动顺序自由控制非线程安全，当多进程同时创建时，会发生争抢，需要加锁和双重检验无内存管理，会发生内存泄漏

1.简易版

为保证多线程下的线程安全，使用双重检验，对单例对象加锁保证竞争不会重复创建

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


/*
*	LazySingleton.h
*/
#pragma once
#ifndef _LAZYSINGLETON_H_
#define _LAZYSINGLETON_H_
#include <iostream>
#include <mutex>

class LazySingleton {
private:
	static LazySingleton* instance;	//指向对象的指针
	LazySingleton();
	~LazySingleton();
	static std::mutex m_mtx; //互斥锁
public:
	static LazySingleton* GetInstance();
};
#endif // !_LAZYSINGLETON_H_


/*
*	LazySingleton.cpp
*/
#include"LazySingleton.h"

LazySingleton* LazySingleton::instance = nullptr;	//初始化为空指针
std::mutex LazySingleton::m_mtx;

LazySingleton::LazySingleton() {
	std::cout << "LazySingleton构造函数" << std::endl;
}

LazySingleton::~LazySingleton() {
	std::cout << "LazySingleton析构函数" << std::endl;
}

LazySingleton* LazySingleton::GetInstance() {
	if (instance == nullptr) {
		//加锁
		std::lock_guard<std::mutex>lock(m_mtx);	//类模板，只提供构造函数和析构函数，在析构时自动解锁，可以使用{}来限制使用范围
		if (instance == nullptr) {	//双重检验
			instance = new LazySingleton();
		}
	}
	return instance;
}


void func(int n)
{
	cout << LazySingleton::GetInstance() << endl;
}

int main() {
	thread t1(func, 10);
	thread t2(func, 10);
	t1.join();	//进程1运行：创建LazySingleton	单例对象地址不变
	t2.join();	//进程2运行：不用创建
	cout << LazySingleton::GetInstance() << endl;	//不用创建
	cout << LazySingleton::GetInstance() << endl;	//不用创建
	//懒汉模式不会自动析构
	return 0;
}

数据结构

Sun, 16 Feb 2025 15:16:25 +0800

一、基本概念

1. 数据结构分类

逻辑结构：

线性结构
集合
树形结构
图结构

物理结构：

顺序存储：把逻辑上相邻的元素存储在物理位置也相邻的存储单元中。优点：支持随机存取、存储密度高缺点：大片连续空间分配不方便，改变容量不方便
链式存储优点：离散的小空间分配方便，改变容量方便缺点：不可随机存取，存储密度低

	增	删	按位查找	按值查找
顺序	O(n)	O(n)	O(1)	O(n)
链式	O(n)	O(n)	O(n)	O(n)

索引存储
散列存储

2. 算法效率

时间复杂度、空间复杂度

二、数据结构

1. 线性表

具有相同数据类型的n（n>=0）个数据元素的有限序列

1. 顺序表

特点： 1. 随机访问：能在O(1)时间内找到第i个元素 2. 存储密度高 3. 拓展容量不方便 4. 插入、删除数据元素不方便基本操作：

插入：插入位置之后的元素都要往后移，时间复杂度：O(1)、O(n)、O(n)；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// 基本操作-插入数据
bool ListInsert(Seqlist& L, int i, int e)
{
 // 检测输入是否有效
 if (i <= 0 || i > L.length + 1)
 {
 return false;
 }

 // 检测是否有位置插入
 if (L.MaxSize <= L.length)
 {
 IncreaseSize(L, L.MaxSize * 2); // 扩充两倍
 }

 // 将i位后的所有数字往后移一位
 for (int j = L.length; j >= i; j--)
 {
 L.data[j] = L.data[j - 1];
 }

 L.data[i - 1] = e; // 插入数据
 L.length++; // 更新数组长度

 return true;
}

删除：删除位置之后的元素都要往前移，时间复杂度：O(1)、O(n)、O(n)；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 基本操作-删除数据
bool ListDelete(Seqlist& L, int i, int& e)
{
 // 检测输入是否有效
 if (i <= 0 || i > L.length)
 {
 return false;
 }

 e = L.data[i - 1]; // 获取被删除的值
 // 将i位后所有数字往前移
 for (int j = i; j < L.length; j++)
 {
 L.data[j - 1] = L.data[j];
 }

 L.length--; //更新数组长度
 return true;
}

按位查找：时间复杂度：O(1)、O(1)、O(1)；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 基本操作-按位查找
int ListGetElem(Seqlist& L, int i)
{
 // 检测输入是否有效
 if (i <= 0 || i > L.length)
 {
 return INT_MIN;
 }

 return L.data[i - 1];
}

按值查找：时间复杂度：O(1)、O(n)、O(n)；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 基本操作-按值查找
int ListLocateElem(Seqlist& L, int e)
{
 for (int i = 0; i < L.length; i++)
 {
 if (L.data[i] == e)
 {
 return i + 1;
 }
 }

 return -1;
}

2. 单链表

基本操作：

插入：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


// 基本操作-插入数据
bool ListInsert(LinkList &L, int i,int e)
{
 // 检测输入是否有效
 if(i < 1)
 {
 return false;
 }

 LNode *p; // 指针P指向当前扫描到的节点
 int j = 0; // 当前P指向的是第几个节点
 p = L; // P指向头节点
 // 循环寻找第i-1个节点
 while(p != nullptr && j < i-1)
 {
 p = p->next;
 j++;
 }
 // 检测p是否合法
 if(p == nullptr)
 {
 return false;
 }
 LNode *s = new LNode();
 s->data = e;
 // 将新节点s插入i位置，并重新连接链表
 s->next = p->next;
 p->next = s;

 return true;
}

删除：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


// 基本操作-删除数据
bool ListDelete(LinkList &L,int i,int &e)
{
 // 检测输入是否有效
 if(i < 1)
 {
 return false;
 }

 LNode *p = L; // 指针P指向当前扫描到的节点
 int j = 0; // 当前p指向的是第几个节点
 // 循环找到第i-1个节点
 while(p != nullptr && j < i-1)
 {
 p = p->next;
 j++;
 }
 // 检测p以及p的下一个要被删除的数是否有效
 if(p == nullptr || p->next == nullptr)
 {
 return false;
 }
 LNode *q = p->next; // 保存被删除的指针
 e = q->data; // 返回删除的值
 p->next = q->next; // 重新链接
 delete q; // 释放指针
 return true;
}

按位查找：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 基本操作-按位查找
LNode* GetElem(LinkList L,int i)
{
 // 检测输入是否有效
 if(i < 0)
 {
 return nullptr;
 }

 LNode* p = L; // 指针p指向当前扫描到的节点
 int j = 0; // 当前p指向的是第几个节点
 // 循环寻找第i个节点
 while(p != nullptr && j < i)
 {
 p = p->next;
 j++;
 }

 return p;
}

按值查找：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 基本操作-按值查找
LNode* LocateElem(LinkList L,int e)
{
 LNode *p = L->next;
 // 循环查找
 while(p != nullptr && p->data != e)
 {
 p = p->next;
 }

 return p; // 返回指针，不存在则返回nullptr
}

求表长：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 求表长度
int Length(LinkList L)
{
 int len = 0; // 统计表长
 LNode *p = L;
 while(p != nullptr)
 {
 p = p->next;
 len++;
 }
 return len;
}

尾插法创建单链表：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 尾插法建立单链表
LinkList List_TailInsert(LinkList &L) // 正向建立单链表
{
 int x;
 L = new LNode(); // 建立头指针
 LNode *s = nullptr;
 LNode *r = L; // r为表尾指针
 std::cin >> x; // 输入节点的值
 while (x != 9999)
 {
 s = new LNode();
 s->data = x;
 r->next = s;
 r = s; // r指向新的表尾节点
 std::cin >> x;
 }

 r->next = nullptr; // 尾节点指针置空
 return L;
}

头插法创建单链表：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 头插法建立单链表
LinkList List_HeadInsert(LinkList &L) // 逆向建立单链表
{
 LNode *s = nullptr;
 int x; // 记录用户输入的值
 L = new LNode(); // 创建头指针
 L->next = nullptr; // 初始化头指针
 std::cin >> x; // 用户输入
 while (x != 9999)
 {
 s = new LNode();// 创建新节点
 s->data = x;
 s->next = L->next;
 L->next = s;
 std::cin >> x;
 }

 return L;
}

3. 双链表

基本操作：

插入：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


bool InsertNextDNode(DNode *p,DNode *s)
{
 // 检测输入是否为空
 if(p == nullptr || s == nullptr)
 {
 return false;
 }

 s->next = p->next;
 if(p->next != nullptr) //判断是否存在需要更改前驱的节点
 {
 p->next->prior = s;
 }
 s->prior = p;
 p->next = s;

 return true;
}

删除：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


bool DeleteNextDNode(DNode *p)
{
 // 检测输入是否有效
 if(p == nullptr)
 {
 return false;
 }
 DNode *q = p->next; // 储存删除节点
 if(q == nullptr)
 {
 return false; // 无需要删除的节点
 }
 p->next = q->next;
 
 if(q->next != nullptr)
 {
 q->next->prior = p;
 }
 delete q; // 释放节点空间

 return true;
}

清空：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 清空整个双向链表
void DestoryList(DLinklist &L)
{
 // 循环释放各个数据节点
 while(L->next != nullptr)
 {
 DeleteNextDNode(L);
 }
 delete L; // 释放头指针
 L = nullptr; // 初始化头指针
}

4. 循环单链表

5. 循环双链表

6. 静态链表（数组实现链表）

优点：增、删操作不需要大量移动元素缺点：不能随机存取，只能从头节点开始依次往后查找；容量固定不可变。适用场景：

不支持指针的低级语言；
数据元素数量固定不变：操作系统的文件分配表FAT

7. 顺序栈

只允许在一端进行插入或删除操作的线性表基本操作：

入栈：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 基本操作-入栈
bool Push(SeqStack &S,int x)
{
 // 判断栈是否满
 if(S.top == MaxSize-1)
 {
 return false;
 }

 S.data[++S.top] = x; //元素入栈
 return true;
}

出栈：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 基本操作-出栈
bool Pop(SeqStack &S,int &x)
{
 if(S.top == -1) // 栈空，返回
 {
 return false;
 }
 x = S.data[S.top--]; // 栈顶元素先出栈，指针再减一
 
 return true;
}

读取栈顶元素：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 基本操作-读取栈顶元素
bool GetTop(SeqStack S,int &x)
{
 if(S.top == -1) // 栈空，返回
 {
 return false;
 }
 x = S.data[S.top]; // 返回栈顶元素
 return true;
}

8. 链栈

与单链表无异

9. 顺序队列

只允许在一端进行插入，在另一端删除的线性表基本操作

入队：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 基本操作-入队
bool EnQueue(SeqQueue &Q,int x)
{
 // 判断是否队满
 if((Q.rear + 1)%MaxSize == Q.front)
 {
 return false;
 }
 Q.data[Q.rear] = x; // 新元素插入队尾
 Q.rear = (Q.rear + 1) % MaxSize; // 形成循环队列
 return true;
}

出队：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 基本操作-出队
bool DeQueue(SeqQueue &Q,int &x)
{
 // 判断队列是否为空
 if(QueueEmpty(Q))
 {
 return false;
 }

 x = Q.data[Q.front];
 Q.front = (Q.front + 1) % MaxSize;

 return true;
}

获取头元素：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 获取队头元素
bool GetHead(SeqQueue Q,int &x)
{
 // 判断队列是否为空
 if(QueueEmpty(Q))
 {
 return false;
 }
 x = Q.data[Q.front];
 return true;
}

10. 链队

基本操作

入队

1
2
3
4
5
6
7
8
9


// 基本操作-入队
void EnQueue(LinkQueue &Q, int x)
{
 LinkNode *s = new LinkNode();
 s->data = x;
 s->next = nullptr;
 Q.rear->next = s; // 将新节点插入到尾部
 Q.rear = s; // 修改表尾指针
}

出队

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 基本操作-出队
bool DeQueue(LinkQueue &Q,int &x)
{
 // 判断是否为空队列
 if(Q.front == Q.rear)
 {
 return false;
 }

 LinkNode *p = Q.front->next;
 x = p->data; // 获取出队值
 Q.front->next = p->next; // 修改头指针
 // 检测是否为最后一个节点,需要修改rear指针指向
 if(Q.rear == p) 
 {
 Q.rear = Q.front;
 }

 delete p;
 return true;
}

11. 双端队列

只允许从两端插入、两端删除的线性表

12. 串

即字符串是由零个或多个字符组成的有限序列。 KMP算法

2. 树与图

1. 树

二叉树
1. 满二叉树：所有非叶子节点的节点都有两个子节点。
2. 完全二叉树：在满二叉树的基础上，从最后面删除叶子节点
3. 二叉排序树（BST）：
  - 左子树上所有结点的关键字均小于根节点的关键字，
  - 右子树上所有结点的关键字均大于根结点的关键字，
  - 左右子树又各是一颗二叉排序树。
4. 平衡二叉树（AVL）：树上任一结点的左子树和右子树的深度之差不超过1。优点：减少二叉树元素查找的深度，从而提升平均查找效率。
5. 线索二叉树：将叶子结点和未满孩子的结点的孩子指针利用起来，按照某种遍历顺序串起来。
6. 哈夫曼树：在含有n个带权叶结点的二叉树中，其中带权路径长度（WPL）最小的二叉树称为哈夫曼树，也称最优二叉树。

2. 图

存储方式：

邻接矩阵法
邻接表法
十字链表（存储有向图）
邻接多重表（存储无向图）

图遍历：

求最小生成树：

Prim算法
Kruskal 算法

最短路径：单源最短路径：

BFS算法
Dijkstra算法各顶点间的最短路径：
Floyd算法

有向无环图（DAG）：若一个有向图中不存在环，则称为有向无环图，简称DAG图； AOV网：用顶点表示活动网；拓扑排序

三、查找

顺序查找
折半查找：仅适用于有序的顺序表
分块查找：
B树（多路平衡查找树）
B+树
散列查找（哈希表）解决冲突：
开放定址法：线性探测再散列、二次(平方)探测再散列、伪随机探测再散列
再哈希法
链地址法
建立公共溢出区

四、排序

插入排序
希尔排序
冒泡排序
快速排序快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
简单选择排序
堆排序
归并排序
基数排序
外部排序
败者树
置换和选择排序
最佳归并树

排序算法的时间复杂度

[图片未在原笔记仓库中找到]

性能优化

Sun, 16 Feb 2025 15:16:25 +0800

游戏中影响性能的几个因素（游戏优化）

计算机资源有两种：CPU负责其中的帧率，GPU主要负责分辨率

对于CPU：渲染方面：

过多地调用Draw Calls命令，每次调用都要预先计算好顶点数据（位置、法线、颜色、纹理坐标等）,导致CPU过载。

优化方案：

顶点优化：

a. LOD（level of detail）技术：根据摄像机距离对象的远近，选择使用不同精度的模型。

b. 使用遮挡剔除（Occlusion culling）技术。

c. 使用视锥剔除技术。
CPU优化：

a. 批处理，同时处理统一材质的物体。
复杂的资源，例如不合理的网格资源和纹理资源等。

优化方案：

贴图的大小非2的次方时，最好改成2的次方，或者合并其他贴图使其尽量为2的次方。
采用享元模式，减少多个重复资源的内存占用。
采用原型模式，降低复杂对象生成过程，提高运行效率。

UI模块：UI性能低效。优化方案：

降低频繁更新UI元素的频率：例如怪物血量控制在某个区域才更新，或者技能CD，伤害飘字隔帧更新，基于事件通知更新UI。
复杂的UI（字体加了阴影、描边等）不要变动，或者少用。
UI出现重叠时，关闭被遮挡的UI。

加载模块：场景的卸载和加载（资源加载和实例化）。

优化方案：

同步的方式显示进度条加载，后面采用异步的方式加载资源。代码效率： “二八原则”：80%的性能开销都集中在20%的函数上

其他：

ARPG游戏中的动画系统和物理系统。
音乐休闲类游戏中的音频系统和粒子系统等。

优化方案：

采用享元模式，减少多个重复资源的内存占用。

对于内存：资源内存占用（资源的内存占用往往占据了总体内存的70%以上）：

纹理（Texture）、网格（Mesh）、动画片段（AnimationClip）、音频片段（AudioClip）、材质（Material）、着色器（Shader）、字体资源（Font）以及文本资源（Text Asset）等等。其中，纹理、网格、动画片段和音频片段则是最容易造成较大内存开销的资源。

纹理：纹理格式、纹理尺寸、Mipmap功能、read&write。
网格：Normal、Color、Tangent。
引擎自身模块占用。
托管堆内存占用。

优化方案：

采用对象池优化方案，降低对象的生成和销毁。
享元模式，共用同一份资源。
对象池管理模式，降低资源重复创建和销毁。
合并纹理。
降低纹理大小。

对象池的介绍与使用（设计模式）

对象池：一定数量的已经创建好的对象(Object)的集合。当需要创建对象时，先在池子中获取，如果池子中没有符合条件的对象，再进行创建新对象，同样，当对象需要销毁时，不做真正的销毁，而是将其setActive(false)，并存入池子中。这样就避免了大量对象的创建。

作用：减少频繁创建和销毁对象带来的成本，实现对象的缓存和复用。

优点：

提升获取对象的响应速度。
一定程度上减少了GC的压力。

缺点：

出现脏对象：脏对象持有上次使用的引用，导致内存泄漏，脏对象拥有上次的数据，再次调用影响此次程序数据处理。
维持大量的对象，占用空间大。

享元模式（设计模式）

享元模式：不同的实例共享相同的特性（共性），同时保留自己的特性部分，以达到极大减小开销的效果。

优点：

传递信息享元化，节约计算时间。
存储信息享元化，节约占用空间。
与对象池联动，进一步减少内存开销。

原型模式（设计模式）

原型模式：将一个或多个对象当做原型，通过统一的生成器克隆出很多类似原型的对象，同时可以通过配置表更改克隆体属性，制造出很多具有自身个性的对象。

优点：

创建新的对象比较复杂时，利用原型模式简化对象生成，提供运行效率。
无需初始化对象，动态获取对象运行状态。

缺点：

原型对象发生改变，克隆对象也会随之改变。

数据库基础

Sun, 16 Feb 2025 15:15:16 +0800

数据库基础

本文整理数据库系统、关系模型、SQL、数据库设计与事务控制等基础知识。

数据库概述

SQL 概述

SQL，一般发音为 sequel，SQL 的全称 (Structured Query Language)，SQL 用来和数据库打交道，完成和数据库的通信，SQL是一套标准。

什么是数据库

数据库，通常是==一个或一组文件，保存了一些符合特定规格的数据==,数据库对应的英语单词是 DataBase,简称:DB。数据库软件称为数据库管理系统（DBMS），全称为 DataBase Management System，如：Oracle、SQL Server、MySql、Sybase、informix、DB2、interbase、PostgreSql。

MySQL 概述

MySQL 最初是由“MySQL AB”公司开发的一套==关系型数据库管理系统==（RDBMS-Relational Database Mangerment System）。 MySQL 不仅是最流行的开源数据库，而且是业界成长最快的数据库，每天有超过 7 万次的下载量，其应用范围从大型企业到专有的嵌入应用系统。

数据库中的表

表(table)是一种结构化的文件，可以用来存储特定类型的数据，如：学生信息，课程信息，都可以放到表中。另外表都有特定的名称，而且不能重复。表中具有几个概念：列、行、主键。 ==列叫做字段(Column)==，==行叫做表中的记录==,每一个字段都有:字段名称/字段数据类型/字段约束/字段长度。表是数据库最基本的单元。

SQL 的分类

数据查询语言(DQL-Data Query Language):select;
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
select
 '字段'
from
 '表名'
where
 '条件方程式'
group by
 '字段'
having
 '条件方程式'
order by
 '字段' desc/asc
limit
 '起始下标','长度';
数据操纵语言(DML-Data Manipulation Language):insert,delete,update; 数据定义语言(DDL-Data Definition Language):create ,drop,alter; 事务控制语言(TCL-Transactional Control Language):commit ,rollback; 数据控制语言(DCL-Data Control Language):grant,revoke;

连接查询

各表数据

内连接（无主次关系）：

等值连接

1
2
3
4
5
6
7
8


select 
 e.ename,d.dname 
from 
 emp as e 
inner join 
 dept as d 
on 
 e.deptno = d.deptno;

非等值连接

1
2
3
4
5
6
7
8


select
 e.ename,e.sal,s.grade
from
 emp as e
inner join
 salgrade as s
on
 e.sal between s.losal and s.hisal;

自连接

1
2
3
4
5
6
7
8


select
 a.ename as '员工名',b.ename as '领导名'
from
 emp as a
inner join
 emp as b
on
 a.mgr = b.empno;

外连接（有主次关系）：

左外连接

1
2
3
4
5
6
7
8


select
 e.ename,d.dname
from
 dept as d
left outer join
 emp as e
on
 e.deptno = d.deptno;

右外连接

1
2
3
4
5
6
7
8


select
 e.ename,d.dname
from
 emp as e
right outer join
 dept as d
on
 e.deptno = d.deptno;

全连接

MySQL 常用数据类型

类型	描述
Char(长度)	定长字符串，存储空间大小固定，适合作为主键或外键
Varchar(长度)	变长字符串，存储空间等于实际数据空间
double(有效数字位数，小数位)	数值型
Float(有效数字位数，小数位)	数值型
Int(长度)	整型
bigint(长度)	长整型
Date	日期型
BLOB	Binary Large OBject（二进制大对象）
CLOB	Character Large OBject（字符大对象）

表约束

a) 非空约束：not null（数据不能为空） b) 唯一约束：unique （数据不能重复）

列级约束(单一约束)

表级约束(联合约束) （unique（‘字段名’,‘字段名’））

c) 主键约束：primary key(PK)（唯一标识）

列级约束(单一主键)

表级约束(复合主键) （unique（‘字段名’,‘字段名’））

d) 外键约束：foreign key(FK) 指令：foreign key(‘字段名’) references ‘另一张表名’(‘字段名’)

MySQL 常用存储引擎

MyISAM 存储引擎
MyISAM 存储引擎是 MySQL 最常用的引擎。它管理的表具有以下特征： – 使用三个文件表示每个表：

格式文件 — 存储表结构的定义（mytable.frm）

数据文件 — 存储表行的内容（mytable.MYD）

索引文件 — 存储表上索引（mytable.MYI）

– 灵活的 AUTO_INCREMENT 字段处理 – 可被转换为压缩、只读表来节省空间

InnoDB 存储引擎
InnoDB 存储引擎是 MySQL 的缺省引擎。它管理的表具有下列主要特征： – 每个 InnoDB 表在数据库目录中以.frm 格式文件表示 – InnoDB 表空间 tablespace 被用于存储表的内容 – 提供一组用来记录事务性活动的日志文件 – 用 COMMIT(提交)、SAVEPOINT 及 ROLLBACK(回滚)支持事务处理 – 提供全 ACID 兼容 – 在 MySQL 服务器崩溃后提供自动恢复 – 多版本（MVCC）和行级锁定 – 支持外键及引用的完整性，包括级联删除和更新

MEMORY 存储引擎
使用 MEMORY 存储引擎的表，其数据存储在内存中，且行的长度固定，这两个特点使得 MEMORY 存储引擎非常快。 MEMORY 存储引擎管理的表具有下列特征： – 在数据库目录内，每个表均以.frm 格式的文件表示。 – 表数据及索引被存储在内存中。 – 表级锁机制。 – 不能包含 TEXT 或 BLOB 字段。 MEMORY 存储引擎以前被称为 HEAP 引擎。

数据库系统结构

数据库管理系统主要负责以下工作：

数据定义：定义外模式、模式、内模式以及相应约束。
数据操纵：提供数据检索和更新能力。
数据控制：负责安全性、完整性、并发控制和故障恢复。
数据维护：执行数据转储、恢复、重组和性能分析。
通信：协调应用程序、用户与数据库之间的交互。

三级模式与两级映像

数据库系统采用三级模式结构：

外模式：用户能够看到和使用的局部数据逻辑结构。
模式：全体数据的逻辑结构及其关联约束，也称概念模式。
内模式：数据存储结构的描述，包括存储方式和索引方式等。

外模式与模式之间的映像保证逻辑独立性，模式与内模式之间的映像保证物理独立性。

关系模型

候选键、主键与外键

候选键：能够唯一标识关系中元组，并且不含多余属性的属性集合。
主键：从候选键中选定、用于标识元组的键。
外键：一个关系中引用另一个关系主键的属性或属性集合。

完整性约束

实体完整性：每个元组的主键值必须非空且唯一。
参照完整性：外键值必须为空，或者等于被参照关系中的某个主键值。

常用 SQL 操作

创建表

1
2
3
4


create table 表名 (
 字段名 数据类型 约束,
 字段名 数据类型 约束
);

创建视图

1
2
3


create view 视图名 as
select 字段名
from 表名;

新增、删除与修改数据

1
2
3
4
5


insert into 表名 (字段名) values (值);

delete from 表名 where 条件;

update 表名 set 字段名 = 值 where 条件;

数据库设计

E-R 模型

E-R 模型使用实体、属性和联系描述现实世界中的数据关系。

将 E-R 模型转换为关系模型时，需要把实体集转换为关系，并根据联系的类型确定外键或中间关系。

关系规范化

第一范式：每个字段都具有原子性，不能继续拆分。
第二范式：在第一范式基础上，非主属性完全依赖候选键，不能存在部分依赖。
第三范式：在第二范式基础上，非主属性不能传递依赖候选键。

必要时可以通过模式分解消除不合理的依赖关系，将低级范式转换为高级范式。

事务与并发控制

事务是数据库的逻辑工作单位，其中的一组操作要么全部完成，要么全部不执行。

常见并发问题包括：

丢失修改；
脏读；
不可重复读。

通过并发控制，可以保证事务的隔离性和数据一致性。基于封锁的三级协议分别解决不同问题：

一级封锁协议：修改数据前加排他锁，直到事务结束，用于防止丢失修改。
二级封锁协议：在一级协议基础上，读取数据前加共享锁，读取完成后释放，用于防止脏读。
三级封锁协议：共享锁保持到事务结束，用于保证可重复读。

当事务长期等待资源时可能出现活锁，可以采用先来先服务的调度策略。多个事务相互等待对方持有的资源时会形成死锁，可以通过一次封锁、统一封锁顺序或撤销代价较小的事务进行预防或处理。