Welcome to NICK's BLOG!

At Beginning

iiiii This is my first blog !!!!!

Paper Deep Dive: “Efficient Rectification of Neuro-Symbolic Reasoning Inconsistencies by Abductive Reflection”

TL;DR (Key Takeaways)

This paper introduces Abductive Reflection (ABL-Refl), a novel neuro-symbolic (NeSy) learning framework that efficiently detects and corrects inconsistencies between neural network outputs and symbolic reasoning. Inspired by human dual-process cognition (System 1 & System 2), ABL-Refl uses a reflection mechanism to flag errors in neural predictions and invokes abductive reasoning to fix them.

Why it matters?

• Efficiency: Avoids costly combinatorial search in prior ABL methods.
• Accuracy: Outperforms state-of-the-art NeSy methods on Sudoku and combinatorial optimization tasks.
• Versatility: Works with symbolic, visual, and graph-structured data, leveraging different forms of domain knowledge (logic, math, etc.).

Deep Learning Note

PyTorch

What is PyTorch?

• An machine learning framework in Python.
• Two main features: ○ N-dimensional Tensor computation (like NumPy) on GPUs ○ Automatic differentiation for training deep neural networks

Dataset & Dataloader

• Dataset

  stores data samples and expected values

  dataset = MyDataset(file)

• Dataloader

  groups data in batches, enables multiprocessing

  dataloader = DataLoader(dataset, batch_size, shuffle=True)

Unity 笔记

编辑器

补充说明

1. 组合操作
   • Shift + 鼠标右键：加速相机移动。
   • Alt + 鼠标左键：围绕选中物体旋转视角。
2. 视图操作技巧
   • 双击 Hierarchy 中的对象：快速聚焦到选中对象。
   • F 键：在 Scene 视图中聚焦到当前选中对象。
   • Ctrl/Cmd + Z：撤销操作（适用于场景修改）。
3. 工具切换小技巧
   • 可以在工具栏的 Transform Gizmo 中快速切换 移动、旋转、缩放 工具（对应快捷键：W、E、R）。

Prefab

1. 创建预制体

• 将 Hierarchy 中的物体拖动到 Project 面板，即可创建一个预制体（Prefab）。

2. 修改预制体

• 对 Project 中的预制体进行修改，会同步更新 Scene 中所有引用该预制体的实例。

3. 修改 Scene 中的预制体实例

• 如果直接修改 Scene 中引用预制体的实例，其对应的原始预制体不会改变。
• 如果需要将修改同步到预制体，可以通过以下两种方式：
  • 在 Inspector 面板中点击相应组件的 “Add Component” 并选择 “Add to Prefab”。
  • 点击 Override 菜单中的 Apply 按钮，同步更改到预制体。

4. 创建预制体的变体（Prefab Variant）

• 如果需要创建预制体的副本，可以将修改后的预制体再次拖动到 Project 面板。
• 在弹出的选项中选择 “Create a Variant from the existing Prefab”。
• 这样创建的变体（Variant）会依赖于原始预制体，其组件属性与原始预制体保持关联，修改原始预制体时变体会同步更新。

Pinia 笔记

安装Pinia并注册

1

npm i pinia

在main.js中：

1
2
3
4
5
6
7
8

import { createPinia } from 'pinia'

const app = createApp(App)

// 以插件的形式注册
app.use(createPinia())
app.use(router)
app.mount('#app')

实现counter

核心步骤：

1. 定义store
2. 组件使用store

1- 定义store

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

import { defineStore } from 'pinia'
import { ref } from 'vue'

export const useCounterStore = defineStore('counter', ()=>{
  // 数据 （state）
  const count = ref(0)

  // 修改数据的方法 （action）
  const increment = ()=>{
    count.value++
  }

  // 以对象形式返回
  return {
    count,
    increment
  }
})

2- 组件使用store

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

<script setup>
  // 1. 导入use方法
	import { useCounterStore } from '@/stores/counter'
  // 2. 执行方法得到store store里有数据和方法
  const counterStore = useCounterStore()
</script>

<template>
	<button @click="counterStore.increment">
    {{ counterStore.count }}
  </button>
</template>

Vue3

注：内容改编自黑马程序员教程

Vue3

create-vue

create-vue是Vue官方新的脚手架工具，底层切换到了 vite （下一代前端工具链），为开发提供极速响应

前置条件 - 已安装16.0或更高版本的Node.js

执行如下命令，这一指令将会安装并执行 create-vue

1

npm init vue@latest

项目和关键文件

组合式API

根号分治

根号分治，是暴力美学的集大成体现。

与其说是一种算法，我们不如称它为一个常用的trick。

根号分治，其实就是将一个数据较大、复杂度较大的解法转化为根号级别的解法

寿司晚宴

题目

题目链接：P2150 [NOI2015] 寿司晚宴

浅谈敏感信息处理

“信息安全的核心不是完美的技术，而是有效的管理与人性化的考虑。” —— Bruce Schneier

什么是敏感信息？

在项目开源的过程中，不可避免地会碰到敏感信息，例如：

• 云数据库的账号密码信息
  MySQL等数据库的用户名和密码。
• 微信登录涉及的 AppID、AppSecret
  这些信息用于第三方服务的 OAuth 认证，如果泄露可能导致账号被恶意使用。
• API 密钥
  用于调用第三方服务的 API_KEY，如支付网关、地图服务、邮件发送等。
• SSH 私钥
  服务器管理中的 SSH 私钥文件，如果泄露会让攻击者获得服务器的完全访问权限。
• JWT Secret
  这些密钥用于生成和验证 JWT，保护用户身份信息。
• 支付信息
  例如：银行卡号、支付网关的密钥（如支付宝的签名密钥）。
• 个人身份信息（PII）
  例如：身份证号码、护照信息、电话号码、住址、电子邮件地址等。
• 密码文件
  例如：包含用户登录密码或哈希密码的配置文件、.env 文件中明文存储的敏感数据。

这些敏感信息如果在开源项目中暴露，可能会引发数据泄露、财务损失、甚至法律责任等严重后果，因此在项目中需要妥善处理和保护。

WebSocket

WebSocket是一种在基于TCP连接上进行全双工通信的协议

全双工（Full Duplex）：允许数据在两个方向上同时传输。

半双工（Half Duplex）：允许数据在两个方向上传输，但是同一个时间段内只允许一个方向上传输。

原理

请求数据

1
2
3
4
5
6
7

GET ws://localhost/chat HTTP/1.1
Host: localhost
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Version: 13
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Extensions: permessage-deflate

响应数据

1
2
3
4
5

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Sec-WebSocket-Extensions: permessage-deflate

Go Web笔记

net/http

请求

Get、Head、Post和PostForm函数发出HTTP/HTTPS请求。

1
2
3
4
5
6

resp, err := http.Get("http://example.com/")
...
resp, err := http.Post("http://example.com/upload", "image/jpeg", &buf)
...
resp, err := http.PostForm("http://example.com/form",
	url.Values{"key": {"Value"}, "id": {"123"}})

程序在使用完response后必须关闭回复的主体。

1
2
3
4
5
6
7

resp, err := http.Get("http://example.com/")
if err != nil {
	// handle error
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
// ...

Big Biomedical Data Analysis

DAY 1

Environment

Download Anaconda Distribution | Anaconda

下载安装后，搜索Anaconda Navigator，打开后运行JupyterLab，在里面敲代码就行

JupyterLab快捷键+调试技巧

Translate Your Name Into DNA Code

The corresponding dictionary:

1
2
3
4
5
6
7
8
9

letterToDna = {
    'A': 'GCT', 'B': 'GCA', 'C': 'TGC', 'D': 'GAT',
    'E': 'GAG', 'F': 'TTT', 'G': 'GGG', 'H': 'CAT',
    'I': 'ATA', 'J': 'ATC', 'K': 'AAG', 'L': 'CTC',
    'M': 'ATG', 'N': 'GAC', 'O': 'GAT', 'P': 'CCC',
    'Q': 'GAG', 'R': 'CGT', 'S': 'TCA', 'T': 'ACT',
    'U': 'ACG', 'V': 'GTC', 'W': 'TGG', 'X': 'GTA',
    'Y': 'TAC', 'Z': 'TAT'
}

encode name

1
2
3
4
5

#Replace with dictionary
encodedName = [letterToDna[item] for item in "NICK"]
TName="".join(encodedName)
TName
//'GACATATGCAAG'

Matlab笔记

基本使用

MATLAB 每行输入结束后需按回车键才可以执行，若MATLAB 命令后为逗号或无标点符号，则在屏幕上直接显示命令的执行结果

若命令后为分号，则禁止显示结果，用分号抑制不必要的结果输出，可以极大地提高编程或计算效率。

1

1+1

注释

%后面的文字为注释

续行

...表示续行

使用续行符之后 MATLAB 会自动将前一行保留而不加以计算,并与下一行衔接,等待完整输入后再计算整个输入的结果

清屏

若命令窗口内容过多,希望恢复初始状态,则可以输入 clc 命令,清除当前窗口内容

Go基础笔记

Hello, World

创建文件 hello.go

1
2
3
4
5
6
7

package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}

• 需要注意的是 { 不能单独放在一行，不然会报错

命令行运行

1

go run hello.go

在 Go 语言里，命名为 main 的包具有特殊的含义。 Go 语言的编译程序会试图把这种名字的包编译为二进制可执行文件。所有用 Go 语言编译的可执行程序都必须有一个名叫 main 的包。一个可执行程序有且仅有一个 main 包。

当编译器发现某个包的名字为 main 时，它一定也会发现名为 main()的函数，否则不会创建可执行文件。 main()函数是程序的入口，所以，如果没有这个函数，程序就没有办法开始执行。

程序编译时，会使用声明 main 包的代码所在的目录的目录名作为二进制可执行文件的文件名。

c++程序设计

数据类型与语句

数据类型

sizeof()运算符

sizeof(<类型>)或者sizeof(<变量>)

1
2
3
4
5
6

int a; sizeof(a)
sizeof(int)//其值为4
sizeof(double)//其值为8
sizeof(float) //其值为4
sizeof(char)//其值为1
sizeof(long double)//vc 8, mingw 16

类型转换

C++的转换语法不像Java那么严格，例如，double可以自动(隐式)转换出float，浮点数自动转换得到整数，但自由的代价是风险增大

1

int x = 1.7;//居然可以

C++支持的强制类型转化语法

• Java风格，C风格 (类型名)(表达式)：(double)a，(int)(x+y)，(int)6.2%4

• C++风格 类型作为函数名，()作为参数：double(a)，int(x+y)，int(6.2)%4

• 复杂风格，引入注目，突出这儿有类型转换：static_cast \(expression)

1

int ii = static_cast<int>(5.5)://等效于 int ii = 5.5；等效于 imt ii = int(5.5);

在强制类型运算后原变量不变，但得到一个所需类型的中间变量。

函数

函数概述

C/C++系统函数是C/C++编译系统(开发包)已预定义的函数。

• 包括一些常用数学计算函数(如sqrt0、exp0等)、字符串处理函数、标准输入输出函数、容器(List/Map)等
• 当用户使用库函数时，在程序中必须包含相应的头文件。
  #include <iostream>
#include <iomanip>
• C++标准库万能函数头，懒人用，竞赛用,
  #include <bits/stdc++.h>

定义和调用

• 函数的参数

  • 形参是定义函数时的参数声明；
  • 实参是运行函数时的参数赋值。
  • 形参与实参必须类型相同一一对应。
  • 实参必需是确定的数值，可以是由常量、变量或表达式／函数计舞产生的。

• 在C++中，函数的参数计算顺序是未定义的。

  这意味着在表达式 max(f(x), g(x)) 中，f(x) 和 g(x) 的计算顺序是不确定的。

• 函数声明：在—个文件（或者函数） a中声明函数b, 写出b 的函数头。
  • 声明后， b在a 中可见
  • 声明时，函数头形参只要类型，不要名字
  • 函数定义的同时也是一次声明，可以多处声明
  • 同一个cpp代码文件中，定义在后面的函数如果希望被前面的函数调用，必须声明

• C++中， 所有函数的定义都是独立的，不可嵌套定义。（Java可以定义匿名内类， C/C++不可以）

内联函数

内联函数(inline) , 编译时，就将被调函数体的代码直接插到调用处（c/c++特色）

• 实质是用目标程序的长度来换取执行时间。程序代码占用多份空间，但免去调用的额外开销。
• —般把规模很小但频繁调用的函数声明成内联
• 内联函数的定义方法： 在函数类型前增加修饰词inline 。

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

inline int max (int x, int y)
{ 
    int z;
    z=(x>y)? x: y;
	return z;
}
inline void printStar(){
	cout << "*****"<<endl;
}
void main (void)
{ 
    int a,b,c;
	cin>>a>>b;
	c=max (a+b , a*b);
	cout<<"The max is"<<c<<endl;
	printStar();
}

• 使用inline , 只是请求编译器内联该函数，是否内联由编译器决定。

函数的重载

重载函数是相同的作用域，两个或更多具有相同函数名，不同参数列表的函数。编译器根据调用时的实参个数以及类型来确定调用淮。

重载函数必须具有不同参数列表，理解为：不同的参数个数，或不同的参数类型。

• 形参缺省值与重载有些类似，注意区分

  • ```c++
    int func(int xl, int x2 = 2, int x3 = 3) {

    return xl + x2 + x3;
    

    }// int
    void main(void){

    cont<< func(10) <<endl; // 10, 2,3
    cout<< func(10,8} <<endl; //10,8,3
    

    1

    1 2 3 4 5

    - 定义时不可以靠左边缺省 ```c++ int func(int x1 = 5, int x2, int x3) //错误

  • 赋值时不可以中间缺省

    1	cout<< func(lO, , 8) <<endl; II 错误

  • 不可以定义与声明同时赋值

    如果一个函数有原型声明，则默认参数值应在函数原型声明中给出

    1 2	int func(int X 1 , int x2 = 3, int x3=4); //声明 int func(int xl, int x2, int x3) { return xl + x2 + x3;}// 定义

当形参缺省多处声明＋重载相遇

1 2 3 4 5 6 7 8

int f(int x,int y=3); int f(int); int main(){ int f(int x,int y=4); //如果去掉，则因为二义性导致编译错误 cont<< f(3) << endl; //结果7 return O; } int f(int x,int y){ return x+y;} //重载 int f(int x){ return x;} //重载

模板函数

以类型作为变量

• 定义T是一个变量， 变量T代表某一个类型，而不是数值。
  在编译时， 可以允许编译器根据max的实参类型，推断T, 也可以指定T 的类型。

1
2
3
4
5
6
7
8
9
10
11

template<typename T>//作用域就是下面的一个方法
T max(T a,T b,T c){
    if(b>a) a=b;
    if(c>a) a=c;
    return a;
}
int main(){
    i = max(il ,i2 , i3) ;
    d = max(dl ,d2 , d3) ;
    g = max<long>(1 , 2 , 3);
}

• 函数模板(function template) 是—个通用函数，其函数返回类型、形参类型、以及函数体内的局部变量定义的类型，都可以不具体指定，用虚拟类型（如T1 ,T2) 代表。
• 作用：函数实现逻辑相同的函数，只有变量类型不同的函数，都可以用统一模板来代替，不必定义多个函数。
• 在编译过程中，如果不指定具体类型，编译器通常会根据函数的实参类型来取代模板中的虚拟类型， 创建（实例化） 具体函数；
  • 虽然你写了—个函数模板max, 实际在你的代码中有多个max
  • 但虚拟返回值类型不能推断。
• 函数模板不能取代函数重载，难以处理参数个数不同，或逻辑实现不同（实数、复数的加法）的情况。

作用域和生命周期

变量具有生命周期和作用域。函数具有作用域。

生命周期指变量的空间分配到释放的周期，三类生命周期，为方便管理，C++将不同生命周期的变量存储在不同性质的存储空间中。

• 1 、静态：一旦分配，一直存在，直到程序结束被释放；
• 2、栈：函数开始，分配空间（压栈），函数结束，被释放（弹栈）；
• 3 、堆：程序员主动申谓释放； new申请， delete释放(C语言 malloc 申请， free 释放）；

存储类别

1. 程序代码区—存放函数体的二进制代码（忽略）
2. 静态区(static) : —旦分配， 直到程序结束才回收（终生不死）；全局变量，静态局部变量（包含文字常量区，存放字符串常量）
3. 栈(Stack) : 存储函数参数和局部变量，空间由系统自动动态分配、回收。函数被调用、分配、压栈；执行完回收、弹出。特点：空间小(×MB量级），速度快
4. 堆(Heap) : 程序员动态申请的内存块， new申请，delete释放(Java自动释放）。特点：空间大(×GB量级），速度慢。对于C/C++ , 如果程序员忘记回收，终生不死，直到操作系统关闭。

静态局部变量：作用范围局部（函数内部），生命周期：静态。

• 只最初赋值一次，在静态存储区内分配存储单元，在程序整个运行期间都不释放。在下一次该函数调用时，该变量保留上—次函数调用结束时的值。
• 静态局部变量或全局变量未赋初值时， 系统在编译时自动使之为0或空字符。
• 静态局部变量—直存在，但对其他函数”不可见”。可见范围仍是局部
• 用静态存储要多占内存，而且降低了程序的可读性。明明看到static int i =3 ; 但i 其实不—定是3 , i只是最初是3 。
• 如不是必须，不要多用静态局部变呈。

作用域

• 局部作用域：在函数内部或在块（复合语句）中定义的变量都是局部变量，其作用域开始于声明处，结束于函数／块的结尾处。

  • 不同的函数可以使用相同名字的局部变量，同名局部变已分属不同函数，互不干扰。
  • 局部变量名相同时，以最内层定义的局部变量为准。java 中，不允许。C++, 尽量避免

• 全局作用域（物理文件）

  • 在函数外定义的变量称为全局变量，对应文件作用域。其缺省的作用范围是： 从定义位置开始到该源程序文件结束。

  • 全局变量与局部变量同名时，局部变量优先。可以利用域作用符：：标记全局变量

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

    #include <iostream.h> int i = 100; void main(void) { int i , j=50; i = 18; //访问局部变量i ::i = ::i+4; //访问全局变量i j = ::i + i ; //访问全局变量i和局部变量j cout<<"::i="<<::i<<'\n';//::i=104 cout<<"i="<<i<<'\n';//i=18 cout<<"j="<<j<<'\n';//j=122 }

  • 函数要访问当前源文件中定义的全局变量：

    • 通常在前面定义全局变量，后面定义函数，函数可以访问全局变量

    • 如果在后面定义全局变量，需要在前面利用extern声明全局变量，声明之后可以使用

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

      #include < iostream > using namespace std; int max(int,int); //函数声明 void main() { extern int a,b;//对全局变量a,b作提前引用声明，不是定义，不是定义，不是定义 cout< < max(a,b) <<end I; } int a=15 , b=-7;//定义全局变量a,b int max(int x,int y) { int z; z=x>y?x:y; return z; }

    • 声明可以在函数内部或者外部，声明的位置决定了其作用范围

static修饰函数

static 也可以修饰函数，描述其为内部函数

• 内部函数：函数只局限于在本文件中调用，其它文件不能调用，用static 定义该函数。

• 外部函数：是函数的默认形式，即可以被外部调用。

  • 在调用文件中用extern 声明，把该函数的作用域扩展到调用文件。

    1 2 3 4

    static float fac1(float n) {……} //该函数不能被其他文件使用 float fac(int n) {} //该函数可以被其他文件使用

    1 2	extern float fac(int n); //这个函数的定义来自其他文件

命名空间作用域

c++提供了名空间(namespace) 机制来解决名冲突问题。

在—个名空间中定义的全局标识符（函数／全局变呈），其作用域为该名空间。

当在—个名空间外部需要使用该名空间中定义的全局标识符时，可用该名空间的名字来修饰或受 限。

1
2
3
4
5
6
7
8
9
10

namespace A
{
    int x=1;
    void f(){}
}
namespace B
{
    int x=0;
    void f(){}
}

1 、不使用using

1
2
3
4

...A::x... //A中的x
A::f();//A中的f
...B::x... //B中的x
B::f();//B中的f

2、使用using省略整个命名空间

1
2
3
4
5

using namespace A;
...x...//A中的x
f();//A中的f
...B::x... //B中的x
B::f();//B中的f

3、使用using省略命名空间的某个函数

1
2
3
4
5

using A::f;
A::x... //A中的x
f0;//A中的f
...B::x... //B中的x
B::f();//B中的f

预处理编译

文件包含

一个源文件也可以将另外一个源文件的全部内容包含进来，即将另外的文件包含到本文件之中。

#include "文件名“

通常情况下， 很少在一个cpp中include另一个cpp , 而应当include其声明文件h , 即包含file的声明（引用），而不是其全部。（可以使用，但不拥有）

mathx.h

1
2
3
4

const double Pl = 3.14;
int max(int ,int);
double pow(double,double);
......

mathx.cpp

1
2
3
4
5
6

#include "mathx.h"
int max(int x,int y){
    int z;
    z=x>y?x:y;
    return z;
}

file1.cpp

1
2
3
4
5
6

#include < iostream >
#include "mathx.h"
using namespace std;
int main(){
……，可以盲接使用max, 以及PI
}

.h文件中能包含：

• 类成员数据的声明，但不能赋值
• 类静态数据成员的定义和赋值，但不建议，只是个声明就好。
• 类的成员函数的声明
• 非类成员函数的声明
• 常数的定义：如：constint a=5;
• 静态函数的定义
• 类的内联函数的定义

不能包含：

• 1． 所有非静态变量（不是类的数据成员）的声明
• 2。 默认命名空间声明不要放在头文件，using namespace std;等应放在.cpp中，在 .h 文件中使用 std::string

因为一个头文件的内容实际上是会被引入到多个不同的 .cpp 文件中的，并且它们都会被编译。放声明当然没事，如果放了定义，那么也就相当于在多个文件中出现了对于一个符号（变量或函数）的定义，纵然这些定义都是相同的，但对于编译器来说，这样做不合法。

数组与容器

一维数组

数组是同一类型的一组值（例如， 10个int或15个char) , 在内存中顺序存放。

整个数组共用—个名字，其中的每—项称为—个元素，对应一个下标，下标从0开始。

C++规定，数组元素个数必须是常量，不能通过赋值修改数组长度。（VC 会报错，但MinGW 允许）

C++ 中， 数组不是对象，不用new去创建

• 越界后果自负。int a [10]; a [15] = 1 ; 可能带病工作，可能立即崩溃
• 定义的同时必须确定长度。
• 在栈上分配空间，由于栈空间有限， 不要定义很大的数组。
• 如果需要很大的数组( 1 个亿）， 需要用指针配合new 申请堆空间。

定义数组时，可以用｛｝给数组元素赋值而不指定长度

赋值元素的个数为数组的长度。int a[]= {0,1, 2, 3}; 则a的长度为4 。

定义时，同时指定长度与｛ ｝赋值，应该保证指定长度＞＝赋值元素个数

• 未赋值的元素为0 、0.0或者null 。int b[10]= {1};

• int c[2]= {1, 2, 3}; 挑衅编译器，规范的编译器捉示语法错；

不赋初值时， static 或全局数组均默认其为0或’\0 ‘ , 其他局部数组赋值随机

用数组名作函数参数

在C++中，数组名被认为是数组在内存中存放的首地址。Java中也是这样认为的

用数组名作函数参数。实参传递的是数组在内存中的地址

被调函数内外，共用同一段内存被调函数内可以修改数组的内容

用数组名作函数参数，实参/形参类型一致。

• 如果是一维数组，形参通常省略元素个数，例如int a[]

  如果是二维数组，形参通常省略第一维，但不可省略第二维，且第二维必须与实参中的维数相等。

  如果是高维数组，形参通常省略第一维，但不可省略低维，其他维度必须一致

字符数组与字符串

约定：用可作为字符串的结束标志，它占内存空间，但不计入串长度。C程序依据’\0’ 判断字符串是否结束，而不是根据字符数组的长度。

1
2
3

char a[]= {'C','H','I','N','A'};
char b[]="CHINA";
char c[l0]="CHINA";

a是字符数组，非字符串； b是字符数组也是字符串，数组长度6B, 字符串长度5B

c是字符数组也是字符串，数组长度为10, 串长度为5, 串占有6个字节

字符串处理

要求有足够空间可以存放运笢结果

1
2
3
4
5
6
7
8
9
10
11

#include <string.h>
...
char str1[20]={"I am a"}; char str2[ ]={"boy"};
strcat(str1 , str2);//合并strcat
strcpy(str1 , str2);//复制strcpy, 覆盖掉str1 对应位置的字符，其他不变；
	//结果"boy" {b,o,y,\0, ,a,\0,\0,\0,\0}
int strcmp(str 1, str2)
    //对字符串中的字符按照ASCII逐个两两相减，直到遇到不同字符或可为止。函数值由两个对应字符相减而得。
strlen(str1)//求字符串长度的函数,参数为数组名，返回值为数组首字母到'\O 的长度。
strlwr(str1) //将str1中的大写字母转换成小写字母
strupr(str1) //将str1中的小写字母转换成大写字母

vector

包含头文件#include<vector>

标准操作：初始化、添加、遍历、插入、删除、查找、排序、释放（动态数据管理）

vector 的初始化：可以有五种方式

• vector< int> a(10); //10个整型元素的向最，初始长度，可变长
• vector< int> a(10, 1); //10个整型元素的向鼠，且初值均为1
• vector< int> b(a); //用b 向量来创建a 向量，整体复制性赋值
• vector< int> a(b.begin(),b.begin()+ 3);//从容器b中获取第0个到第2个（共3个）元素
• int b[7] ={1,2,3,4,5,9,8}; vector< int> a(b,b+ 7); //从数组b中获得初值

添加，插入，删除： 对千连续空间的数据结构，插入，删除代价巨大

• vector< int> vec1; for(int i =O;i < 1 O;i + +) vec1 .push_back(i); //后端插入
• vec1.insert(vec1.end(),5,3); //从vec1.back位置插入5个值为3 的元素
• vec1 .erase(vec1.begin(),vec1.begin()+3);//删除之间的元素，其他元素前移

遍历：

• for(int i =O;i < =v.size()-1 ;i + +) cout < <v[i] < < " "
• for (const int i:v)cout < < i < < "\t";

排序，查找：需要include<algorithm>

1
2
3
4
5
6

int a[10] = { 9, 0, 1, 2, 3, 7, 4, 5, 100, 10 };
vector<int> v(a,a+10); //用a初始化v
sort(a, a + 10);
sort(v.begin(), v.end());
for (int i= O; i < 10; i++)
cout << a [i] << "\t"<<v[i]<<"\t";

1
2
3
4
5

bool cmp(const student &a, const student &b){
    return a.score<b.score; 
}
vector<student> vectorStudents;
sort(vectorStudents.begin(), vectorStudents.end(),cmp);

指针

指针变量的定义（语法）
类型标识符＊指针变量名

1

int * p; // *用于定义指针p, int定义指针p指向整数

• 定义语句中， ＊ 表示定义指针；非定义语句中I *表示间接访问（指针指向的空间）运算。
• 定义语句中，＆表示定义引用（后面讲） I 非定义语句中，＆表示“取变星的地址”运算。
• 一个指针变星只能指向同一类型的变量。例如： int *p, 则p只能存放int数据的地址。

1

void * p; //无类型指针、空类型指针、万能指针，只考虑指向，不考虑类型

空指针

空类型指针可以指向任何带类型的指针（地址）。

void * p= &x;

x可以是基本数据类型，或者对象／结构体类型；

p = &table; p = &book;

空指针在使用（获取内容）时必须转换成具体的类型，一般是原本的类型

1
2
3
4
5

int a=3;
void * p1;
p1=&a;//p1指向a的纯地址
cout <<(int*)p1;//void *转换为 int*，语法逻辑都正确,
cout<<(float *)p1; //void *转换为 float*，语法正确，逻辑错误;

指针访问数组

数组在内存中占据—段连续的单元，通过首地址＋偏移可以访问到每个元素。

C++规定： 数组名就是数组的起始地址，同时也是指针，也是0号元素的地址；

实际应用中，通常额外引入一个新的指针变量p, 通过++,—在数组上游走

例如：

1
2

int a[10],*p;
p=a;//或者 p=&a[0];

可以通过p++指向下一个整数，但不可以a++因为数组名a是常量指针，只能指向数组首地址

C++ 规定，可以通过指针引用数组元素， 即a [i]可以理解为*(a+i) 。

const指针

1
2
3
4
5
6
7

   const int pi=3;
   const int* p = π//指向常量的指针，也可以指向普通量但不允许修改
//或者int const * p;
   int q=1;
   p=&q;

   int* const w=π//常量指针

引用

如果&a 的前面有类型符， 则是对引用的声明／定义；

int &a

如果&a 的前面无类型符，则是取变量的地址运算。

int a, * p; p = &a;

• 一个变量可以有多个引用（别名）
• 理解为c++向java学习就行了，把引用的传参逻辑当作java的传参

作用

用作函数的（形式）参数，实现参数的双向传递。

1
2
3
4
5
6
7
8
9
10
11

void swap(int &x, int &y)
//x,y是实参a,b的别名，而不是副本/拷贝
{
    int t;
    t=x;x=y;t=t;
int main(void)
{
    int a=3,b=5;
	swap(a,b);//实参为变量
	cout<<a<<'\t'<<b<<endl;
}

引用作为形参，实参是变呈而不是地址，这与指针变呈作形参不一样

但实际效果—样，习惯上，双向传递一个参数，使用引用，传递数组，使用指针（数组首地址）

引用可以部分代替指针的操作，例如双向传递参数，降低程序设计的难度

引用更符合数据结构代码风格

常量引用：用canst修饰的引用，防止通过引用修改数值

1

void m3(const int& x){ ~ } // 传递常引用，通过x修改数值， 语法错误

自定义数据类型

类和对象的使用

构造函数

在创建对象时，负责将对象初始化（成员变量赋初值）。

任何类都会有构造函数，无论你是否主动定义

没有主动定义的情况，编译器自动产生一个缺省构造函数className::classNameO { }，对所有数据成员置0, 或者NULL

主动显式的定义了类的（任何）构造函数，编译器不再产生缺省构造函数。

但可以使用” = default “ 强制编译器生成缺省构造函数

1 2	Clock() = default;//指示编译器提供默认构造函数 Clock(int newH, int newM, int newS); //构造函数

参数初始化表

在函数头部对数据成员初始化。

1

Box::Box(int h,int w,int len) : height(h), width(w), length(len){}

其中， height; width; length是成员变量；

相当于

1

Box::Box(int h,int w,int len) {height=h; width=w; length=len;}

委托构造函数

构造函数调用其他构造函数

1
2

Clock(): Clock(0, 0, 0) {}//委托构造函数(delegat i ng constructor)
//对应Java中的this(0,0,0); 但c++必须通过委托构造函数实现

析构函数

析构函数在对象的生命期结束时，被系统自动调用，作用是收回为对象分配的存储空间。

析构函数名必须是在类名前面加上字符”~” 。

1

ClassNaine::~ClassName( ){ …… }

析构函数不能带有任何参数，没有返回值，不指定函数类型。

如果没有显式定义析构函数，则编译器自动产生一个缺省的析构函数， 其函数体为空。

分配空间时，构造；回收空间时，析构

• 全局对象(在函数外定义的对象)，在程序开始执行时，调用构造函数;到程序结束时，调用析构函数。
• 局部对象(在函数内定义的对象)当程序执行到定义对象的地方时，调用构造函数;在退出对象的作用域时，调用析构函数。
• 静态变量(static定义的局部对象)，在首次到达对象的定义时调用构造函数;程序结束时，调用析构函数
• 用new运算符动态生成的对象，在new产生对象时调用构造函数，在使用delete运算符释放对象时，调用析构函数。系统不能自动释放动态生成(new)的对象。

如果在构造函数中用new为对象动态分配了存储空间，则在类中应该定义一个析构函数，使用delete，收回由new申请的存储空间。

复制构造函数

编译器自动生成的复制构造函数，用初始值对象的每个成员数据的值

1
2
3
4

A::A(const A &a){
x-a.x;
y=a.y;
}//系统生成的复制构造函数

C++11: 用”= delete” 指示编译器不要生成默认的复制构造函数。

1
2
3
4
5

class Point{//Point 类的定义
	int x，y;//私有数据
public:
	Point(const Point& p)= delete; //编译器不生成默认复制构造函数
};

缺省的复制函数为浅拷贝，如果数据成员是指针，则复制函数拷贝指针，不拷贝指针指向的内存空间。推论：使用new 申谓空间， 通常需要自定义复制函数，实现深拷贝

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

class Str{
	int Length; char *Sp;
public:
	Str(char *str){
		if(str) {
			Length-strlen(str);
			Sp=new char[Length+1];
			strepy(Sp,str);
		}
	else Sp=0;
	}
	void show(void) {cout<<Sp<<endl;}StO{ if(Sp)delete []Sp; }
	Str::Str(const Str &s){//深拷贝
        if(s.Sp){
            Length=s.Length ;
            Sp=new char[Length+ 1];
            strcpy(Sp, s.Sp);
        }
        else Sp=NULL;
	}
};

复制构造函数被自动调用的三种情况

• 定义—个对象时，以本类另—个对象作为初始值，发生复制构造； A a2 = a1;//Aa2(a1)

• 如果函数的形参是类的对象，调用函数时，将使用实参对象初始化形参对象，发生复制构造；

  • ```cpp
    int func(A a); A a(1,2); func(a);

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

    - 如果函数的返回值是类的对象，函数执行完成返回主调函数时，将使用return语句中的对象初始化—个临时无名对象，传递给主调函数，此时发生复制构造。 - ```cpp Box f() //函数f的类型为Box类类型 { Box box1 (12, 15, 18) ; return box1; / /返回值是Box类的对象 } int main() { Box box2; //定义Box类的对象box2 box2=f() ; //返回Box类的临时对象，并将它赋值给box2 }

复制构造函数被自动调用的三种情况

• 定义—个对象时，以本类另—个对象作为初始值，发生复制构造；

  • ```c++
    Aa2 = a1;//Aa2(a1)

    1 2 3 4 5

    - －如果函数的形参是类的对象，调用函数时，将使用实参对象初始化形参对象，发生复制构造； - ```cpp int func(A a); A a(1,2); func(a);

• 如果函数的返回值是类的对象，函数执行完成返回主调函数时，将使用return语句中的对象初始化—个临时无名对象，传递给主调函数，此时发生复制构造。

  • ```cpp
    Box f(){//函数f的类型为Box类类型

    Box box1(12,15,18);
    return box1;//返回值是Box类的对象
    

    }
    int main(){

    Box box2;//定义Box类的对象box2
    box2=f();//返回Box类的临时对象，并将它赋值给box2
    

    }

    1 2 3 4 5 6 7 8 9 10

    ### 返回对象引用和返回对象的区别 ```c++ Box funl ()//返回一个克隆对象 Box & fun(const Box & b)//返回引用（对象的名字）

• 返回引用，调用和被调函数对同一个对象进行操作，节省时间和内存。

• 函数不能返回在函数中创建的局部变量对象的引用， 因为当函数结束时，局部变量对象将消失，这种引用是非法的。（在这种情况下，通过new动态创建）

静态成员

静态成员被该类的所有对象所共有、共享。用关键字static声明

在内存中只占一份空间。如果改变它的值，则各对象中这个数据成员的值都同时改变。

只要在类中定义了静态数据成员，即使不创建对象，也为静态数据成员分配空间，可以通过类名访间到类的静态成员。

全生命周期，在程序启动时被分配空间，到程序结束时释放；不随对象的建立而分配空间，也不随对象的撤销而释放。

成员函数

1

static int volume();

在类外调用静态成员函数， 可以用类名或者对象名。如

1
2

Box::volume();
a.volume(); //但这并不意味着此函数是专属于对象a 的。

静态成员函数可以访问本类中的静态数据成员，不能访问本类中的非静态成员。

友元

友元将—个模块（函数、类）声明为本类的朋友，从而可以访问本类中隐截内容。

友元函数

外部函数f () , 在类A中用friend修饰声明，则f()为类A的友元函数， f可以访问A的所有成员。

friend void f () ;

友元函数不一定是独立函数，也可以是另外一个类的函数

友元类

在类A中声明另—个类B声明为friend , 则类A所有数据类B可以访问： friend class B;

友元的关系是单向的而不是双向的，友元关系不能传递

作用：增加灵活性，使程序员可以在数据安全性和使用便利性之间做选择。指明哪些是朋友，对淮开放。

副作用： 破坏数据封装和隐截。建议尽呈不要使用友元类。
副作用2 : 程序设计更加复杂了，—些额外的问题，例如父亲的朋友是不是朋友

const

• const修饰的变量称为常量。

• const修饰的成员数据称为常数据成员

  • 只能通过构造函数的参数初始化表对常数据成员进行初始化

  • ```cpp
    const int hour; //声明hour为常数据成员
    Time::Time (int h):hour(h){ hour = h; //错误｝

    1 2 3 4 5 6 7 8 9

    - const修饰的成员函数称为常函数 - 常成员函数可以引用非const的数据成员，但不能修改其数值 - ```cpp void get_ time() canst; //在声明和定义函数时者都要有const关键字，在调用时不必加const

• const声明的对象为常对象。

  • 常对象必须进行初始化，不能被更新（修改）。

  • 对象的数据成员的值不被改变

  • ```c++
    const Time tl(l2,34,46); //tl是常对象

    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

    － 对象的数据成员的值不被改变 Time canst tl (12, 34, 46); / /tl是常对象 常对象必须进行初始化，不能被更新（修改）。 ## 运算符重载 运算符重载:为运算符(+_*/><...)定义函数(运算符重载函数一个(若干个) 遇到运算符根据不同的运算对象调用对应的函数 <返回类型> operator <运算符>(<参数表>) operator是运算符重载函数关键字，operator<运算符>是函数名 运算符的操作数映射为重载函数的参数，运算符重载函数通常是类的成员困数或者是友元函数。 **重载运算符+** ```cpp Class A{ int i; public: A(int a=0){i=a;} A operator+(const A &a){//重载运算符+ A t; t.i=i+a.i; return t; };

重载运算符+=

+=重载函数，其返回值类型为void。因为+=-=*=等修正运算，不会产生新的对象

1
2
3

void operator+=(const A &a){//重载运算符+=
    i = i + a.i;
}

自增运算符

1
2
3
4
5
6
7
8
9
10

A& operator++() {  // 重载前置自增运算符
    i++;
    return *this;
}

A operator++(int) {  // 重载后置自增运算符
    A temp = *this;
    i++;
    return temp;
}

运算符重载为成员函数的参数只能有二种情况：没有参数或带有—个参数。

• 对于单目运算符（如＋＋），正载时通常不能有参数；

• 对于双目运算符，只能带有—个参数。参数可以是对象，对象的引用，或其它类型的参数。

只能对C++ 中已定义了的运筒符进行重载。但有5个不允许重载

1. .(点运算符)s.length，但是->(箭头运算符)是可以重载的
2. 域运算符，Math::P
3. .*(点星运算符,)s.*p,即成员是指针类型
4. ?:(条件运算符)
5. sizeof,不可以重载

禁止重载（修改）基本类型数据的运算符。参数不能全部是C++的基本标准类型。

静态成员函数不能是运算符重载函数

运算符重载为类成员函数， 成员函数所属对象是一个操作数，另一个操作数是函数参数

1
2
3
4

A a ,b, c;
c=a+b; 	//实际上是c=a.operator+(b) ; 有参有返回值
c=++a; 	//实际上是c=a.operator++() ; 无参有返回值
c+=a; 	//实际上是c.operator+=(a) ; 有参无返回值

运算符重载为类的友元函数（或者普通函数）， 参与运算的对象全部成为函数参数。

1
2
3

c=a+b;	//实际上是c=operator+(a, b); 两个参数friend A operator+ (A &a, A &b)
c=++a;	//实际上是c=operator++(a) ; 一个参数friend A operator++ (A &a)
c+=a;	//实际上是operator+=(c, a); friend void operator+= (A &c, A &a)

如果参数有基本数据类型时，则运算符建议重载为友元函数。例如：

1
2
3

Complex Complex::operator+(int &i){
	return Complex(real+i,imag) ;
}

则限制使用者必须写作c3 = c2+100;

而不能写成c3=100+c2; 因为100不是类对象，100.operator+(c2)编译错误

流运算符重载

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

#include<iostream>
using namespace std;
class Complex{
public:
	friend ostream& operator<<(ostream&, Complex&)
	friend istream& operator>>(istream&, Complex&)
private:
    double real;
    double imag;
};
ostream& operator<<(ostream& output，Complex& c){
	output<<"("<<c. real<<”+”<<c.imag<<”i)"
	return output
}
istream& operator>>(istream& input,Complex& c){
    cout<<"input real part and imaginary part of complex number:"
	input>>c.real>>c.imag;
	return input;
}

赋值运算符重载

1
2
3
4
5
6
7
8
9
10

A& A::operator =(A &b){//重载赋值运算符 
	if(ps) delete []ps;
	if (b.ps){
        ps=new char [strlen(b.ps)+1];
        strcpy( ps, b.ps);
	}
    else
    ps =0;
    return *this;
}//不返回void为了实现连等

注意

1
2
3

A a2;//调用了默认构造函数
A a1=a2;//调用拷贝构造函数
a2=a1;//调用赋值运算符

继承和派生

访问权限

1

class SubClass: public/protected/private BaseClass

• 公有派生，基类中所有成员在派生类中保持访问权限。

• 保护派生时，基类中公有成员在派生类中均变为保护的；

• 私有派生时，基类中所有成员在派生类中均变为私有的；

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

class A{
    private:	int a1;
    protected: 	int a2;
	public: 	int a3;
};
class B:private A{
    A a;
    protected:int b2;
    public:int b3;
    void method b(){
        cout << a2 << a3 << a.a3;
    }
};
void main(){
    A a; B b;
    cout << a.a3 <<b.b3;
    // a.al a.a2
    // b.al b.a2 b.a3
    // b.A b.b2 均不可访问
}

构造函数

• 派生类的构造函数要么调用基类的构造函数，要么调用自己的另一个构造函数二选一。

• 派生类的构造函数调用不能出现递归

• 派生类如果有多个构造函数，必然有至少一个调用基类的构造函数

• 必须在初始化列表中调用

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

class A{
	int x;
	public:A(int i){
		cout<< i;
	}
};
class B:public A{
    public:
    B(int i):A(i){};
    B():B(0){};
    //B():A(0),B(0){}错误
    //B(){B(0);}错误
};

构造的顺序

1.执行参数初始化列表

A)调用基类的构造函数，初始化基类成员

A(i+1)

B)按照成员变量定义顺序，依次初始化

int b;A a; 则b(i++),a(i)
A a;int b; 则执行a(i),b(i++)

2.调用自身构造函数的实现部分

析构顺序相反

多重继承

1
2
3

class D: public A, protected B, private C {
public D(): C(), B(),A() { m();} // 执行次序， A(),B(), C() ,m()
… //派生类中新增加成员

二义性冲突

当派生类中新增加的数据或函数与基类中成员同名时，缺省优先调用派生类中的成员。

多个基类数据或函数同名时，利用类作用域符号来指明数据或函数的来源。

• 同一个公共的基类在派生类中产生多个拷贝，多占用空间，容易混淆。

  • ```cpp
    ctass A{
    public:

    int x;
    A(int a) { x=a;}};
    

    class B: public A{
    public:

    int y;
    B(int a=0,int b=0):A(a) { y=b;}};
    

    class C: public A{
    public:

    int z;
    C(int a,int c):A(a){ z=c; }};
    

    class D: public B, public C{
    public:

    int dx;
    D(int al,int b,int c,int d,int a2):B(al,b),C(a2,c)
    {dx=d;}};
    

    void main(void){

    D dl(l0,20,30,40,50);
    cout<<dl.x<<endl;//模糊引用错误
    cout<<dl.B::x<<endl; //10
    cout<<dl.C::x<<endl; //50
    

    }

    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

    ### 虚基类 在多重派生的过程中，若使公共基类在派生类中只有一个拷贝，可将公共基类说明为虚基类 由虚基类派生出的对象初始化时， **直接调用**虚基类的构造函数。 规则： 1) —个类可以在—个类族中既被用作虚基类，也被用作非虚基类。 2) 在派生类的对象中，同名的虚基类只产生—个虚基类了对象，而某个非虚基类产生各自的子对象。 ## 多态 ### `virtual` 调用同—个函数名，根据引用类型实现不同的功能。 与java相同，基类的指针可以指向子类（派生类）对象。 C++中，若要访问派生类中相同名字的函数，必须将基类中的同名函数定义为虚函数， 只有用virtual修饰的函数才是可以被覆盖的 --- #### **1. 虚函数与多态性** • **动态绑定（运行时多态）** 虚函数通过**虚函数表（vtable）**实现动态绑定，调用时根据对象的**实际类型**决定执行哪个函数。 ```cpp class Base { public: virtual void foo() { cout << "Base::foo"; } // 虚函数 }; class Derived : public Base { public: void foo() override { cout << "Derived::foo"; } // 重写虚函数 }; Base* obj = new Derived(); obj->foo(); // 输出 Derived::foo（运行时确定）

• 非虚函数：静态绑定（编译时确定），根据指针/引用的静态类型调用。

1
2
3

void non_virtual() { ... }  // 非虚函数
Base* obj = new Derived();
obj->non_virtual();  // 始终调用 Base::non_virtual()

2. 虚析构函数

• 必要性：基类析构函数必须为 virtual，确保通过基类指针删除派生类对象时，调用完整的析构链。

1
2
3
4
5
6
7
8
9
10
11

class Base {
public:
    virtual ~Base() { cout << "Base析构"; }
};
class Derived : public Base {
public:
    ~Derived() { cout << "Derived析构"; }
};

Base* obj = new Derived();
delete obj;  // 输出 Derived析构 → Base析构

• 未使用虚析构的后果
仅调用基类析构函数，导致派生类资源泄漏。

3. 变量遮蔽（Shadowing）

• 同名成员变量：派生类变量会遮蔽基类同名变量。

1
2
3
4
5
6
7
8
9

class Base { protected: int a = 10; };
class Derived : public Base { 
protected: int a = 20;  // 遮蔽 Base::a
public:
    void print() { 
        cout << a;          // 20（访问派生类变量）
        cout << Base::a;    // 10（显式访问基类变量）
    }
};

4. 派生类析构函数调用基类析构函数

• 自动调用：派生类析构函数执行完毕后，编译器自动调用基类析构函数。

1
2
3
4

~Derived() { 
    // 析构派生类成员
    // 编译器自动插入 Base::~Base();
}

5. 虚函数覆盖的访问权限

• 允许修改权限：派生类虚函数的访问权限可以不同于基类。

1
2
3
4

class Base { public: virtual void foo() {} };
class Derived : private Base { 
private: void foo() override {}  // 合法但不推荐
};

6. 最佳实践

1. 使用 override 关键字（C++11+）：明确标记重写，避免签名错误。

   1	void foo() override { ... } // 编译器检查签名匹配

2. 虚析构函数规则：
   • 基类必须有虚析构函数。
   • 若类可能被继承，析构函数默认声明为 virtual。

3. 避免变量遮蔽：
   • 基类和派生类避免同名变量。
   • 若需访问基类变量，使用 Base::variable。

4. 多态接口设计：
   • 虚函数用于定义接口（如 calculate()）。
   • 非虚函数用于工具方法（如 validate()）。

总结表

代码对比示例

虚析构函数的作用

1
2
3
4
5
6
7

// 基类析构函数非虚
Base* obj = new Derived();
delete obj;  // 仅调用 Base::~Base()

// 基类析构函数为虚
Base* obj = new Derived();
delete obj;  // 调用 Derived::~Derived() → Base::~Base()

掌握 virtual 的机制，是写出安全、灵活 C++ 代码的关键！

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

class Point{
    float x,y;
public:
	Point() {}
	float area(void){
		returm 0.0:
	}
	const float Pi=3.14159.
}
class Circle: public Point{//类Point的派生类
	float radius;
public:
	Circle(float r): radius(r){}
	float area(void){
		return Piradius radius.
	}
void main(void){
Point *pp;
//基类指针
Circle c(5.4321):
PP-&c;//，可以将派生类对象的地址赋给基类指针
cout<<pp->area()<<endl;//点的面积，结果是0
cout<<c.area<<endl;//圆面积
}

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

class A{
protected: 	int x, a;
public: A(){x =1000;}
	virtual void print(){cout <<"x="<<x<<'\t';}
};
class B:public A{ 	int y,a=1;
public: 	B() { y=2000;}
	void print(){ cout <<"y="<<y<<'\t';}
};
class C: public A{ int z,a=2;
public: 	C(){z=3000;}
	void print(){ cout <<"z="<<z<<'\n';}
};
int main(){ 
    A a, *pa;
    B b; C c;
    a.print(); b.print(); c.print(); //静态调用
    pa=&a; pa->print();//调用类A的虚函数
    pa=&b; pa->print();//调用类B 的虚函数
    pa=&c; pa->print();//调用类C的虚函数
	return 0;
}
void m(A* pa){
    pa->print();
}

父类（基类）的析构方法一般为virtual, 保证派生类的析构方法得到执行

抽象类

1. 定义与特点

• 抽象类：包含至少一个 纯虚函数（Pure Virtual Function） 的类，无法被实例化。
• 纯虚函数：声明时在函数末尾添加 = 0，表示该函数无默认实现，必须由派生类重写。

1
2
3
4

class Shape {
public:
    virtual double area() const = 0; // 纯虚函数
};

2. 核心用途

• 定义接口规范：强制派生类实现特定方法，统一多态行为。
• 实现多态性：通过基类指针或引用调用不同派生类的实现。
• 代码复用：抽象类可包含部分已实现的成员函数或数据成员，供派生类继承使用。

3. 使用示例

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

#include <iostream>
using namespace std;

// 抽象类：动物
class Animal {
public:
    virtual void makeSound() const = 0; // 纯虚函数
    virtual ~Animal() {}                // 虚析构函数（确保正确析构派生类）
};

// 派生类：狗
class Dog : public Animal {
public:
    void makeSound() const override {
        cout << "Woof!" << endl;
    }
};

// 派生类：猫
class Cat : public Animal {
public:
    void makeSound() const override {
        cout << "Meow!" << endl;
    }
};

int main() {
    Animal* animals[] = {new Dog(), new Cat()};
    for (Animal* animal : animals) {
        animal->makeSound(); // 多态调用
        delete animal;
    }
    return 0;
}

输出结果：

1
2

Woof!
Meow!

4. 关键规则

• 无法实例化：直接创建抽象类对象会引发编译错误。

1

Animal animal; // 错误：Animal 是抽象类

1

class Bird : public Animal {}; // 错误：未实现 makeSound()，Bird 仍是抽象类

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

class Shape {
public:
    virtual void draw() const = 0;
};
void Shape::draw() const { // 纯虚函数的默认实现
    cout << "Drawing a shape." << endl;
}

class Circle : public Shape {
public:
    void draw() const override {
        Shape::draw(); // 显式调用基类实现
        cout << "Drawing a circle." << endl;
    }
};

5. 抽象类 vs 接口

• 接口（C++模拟）：抽象类的特例，所有函数均为纯虚函数，无数据成员。

1
2
3
4
5

class IPrintable {
public:
    virtual void print() const = 0;
    virtual ~IPrintable() = default;
};

6. 设计注意事项

• 虚析构函数：抽象类应定义虚析构函数，确保派生类对象通过基类指针删除时正确释放资源。
• 避免过度抽象：合理设计抽象层级，防止继承结构过于复杂。
• 组合优先于继承：若无需多态行为，优先使用组合而非继承抽象类。

7. 应用场景

• 框架设计：定义通用接口（如 GUI 控件的渲染方法）。
• 插件系统：规定插件必须实现的函数。
• 算法策略：通过抽象基类定义算法骨架，派生类实现具体步骤（模板方法模式）。

编译期多态

1. CRTP（奇异递归模板模式）

定义：通过模板继承在编译期实现多态，无需虚函数表（vtable），实现零运行时开销。
核心思想：基类模板以派生类作为模板参数，通过 static_cast 将 this 转换为派生类指针，直接调用派生类方法。

代码示例

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

template <typename Derived>
class Base {
public:
    void interface() {
        // 编译期绑定到派生类的实现
        static_cast<Derived*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() {
        std::cout << "Derived::implementation()" << std::endl;
    }
};

int main() {
    Derived d;
    d.interface();  // 输出 Derived::implementation()
    return 0;
}

关键点：
• 零运行时开销：所有函数调用在编译期静态绑定。
• 应用场景：
• 静态多态（替代虚函数）。
• Mixins（为类动态添加功能）。
• 优化性能敏感代码（如数学库中的向量运算）。

2. std::variant + std::visit

定义：基于类型安全的联合体（std::variant）和访问者模式（std::visit），在编译期根据实际存储的类型分发操作。

代码示例

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

#include <variant>
#include <iostream>
#include <string>

// 定义可存储的类型集合
using Var = std::variant<int, double, std::string>;

// 访问者：为不同类型定义操作
struct Visitor {
    void operator()(int x)    { std::cout << "int: " << x << std::endl; }
    void operator()(double x) { std::cout << "double: " << x << std::endl; }
    void operator()(const std::string& x) { std::cout << "string: " << x << std::endl; }
};

int main() {
    Var v1 = 42;
    Var v2 = 3.14;
    Var v3 = "Hello";

    // 编译期多态分发
    std::visit(Visitor{}, v1);  // 输出 int: 42
    std::visit(Visitor{}, v2);  // 输出 double: 3.14
    std::visit(Visitor{}, v3);  // 输出 string: Hello

    return 0;
}

关键点：
• 类型安全：std::variant 替代传统联合体，避免类型错误。
• 访问者模式：通过重载的 operator() 为不同类型定义操作。
• 编译期分发：std::visit 在编译期生成类型分发代码，无运行时类型检查（RTTI）开销。
• 应用场景：
• 状态机（不同状态对应不同类型）。
• 解析器（处理多种类型的语法节点）。
• 替代继承体系的多态设计。

JPA

JPA全称Java Persistence API（2019年重新命名为 Jakarta Persistence API ），是Sun官方提出的一种ORM规范。

O:Object R: Relational M:mapping

• 作用

  1.简化持久化操作的开发工作：让开发者从繁琐的 JDBC 和 SQL 代码中解脱出来，直接面向对象持久化操作。

  2.Sun希望持久化技术能够统一，实现天下归一：如果你是基于JPA进行持久化你可以随意切换数据库。

  该规范为我们提供了：

  1）ORM映射元数据：JPA支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对

  象持久化到数据库表中；

  如：@Entity 、 @Table 、@Id 与 @Column等注解。

  2）JPA 的API：用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和

  SQL代码中解脱出来。

  如：entityManager.merge(T t)；

  3）JPQL查询语言：通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。

  如：from Student s where s.name = ?

  So: JPA仅仅是一种规范，也就是说JPA仅仅定义了一些接口，而接口是需要实现才能工作的。

• Hibernate与JPA:

  所以底层需要某种实现，而Hibernate就是实现了JPA接口的ORM框架。

• 和mybatis区别：

  • mybatis：

    小巧、方便？、高效、简单、直接、半自动

    半自动的ORM框架，

    小巧： mybatis就是jdbc封装

    在国内更流行。

    场景： 在业务比较复杂系统进行使用，

  • hibernate：

    强大、方便、高效、（简单）复杂、绕弯子、全自动

    全自动的ORM框架，

    强大：根据ORM映射生成不同SQL

    在国外更流。

    场景： 在业务相对简单的系统进行使用，随着微服务的流行。

日志框架log4j

Log4j有三个主要的组件/对象：Loggers(记录器)，Appenders (输出源)和Layouts(布局)。这里可简单理解为日志类别，日志要输出的地方和日志以何种形式输出。

每条日志语句都要设置一个等级（DEBUG、INFO、WARN、ERROR和FATAL）。

其中DEBUG < INFO < WARN < ERROR < FATAL。fatal等级最高

对应调试信息 一般信息 警告信息 错误信息 严重错误信息

1、Loggers 在设置日志输出位置的时候，会给那个位置设置一个级别，只有大于等于那个级别的日志才会打印输出到指定位置。

例如：某个Loggers（日志输出位置的等级记录器）级别设定为INFO，则INFO、WARN、ERROR和FATAL级别的日志信息都会输出到那个文件，而级别比INFO低的DEBUG则不会输出。

2、Appenders

禁用和使用日志请求只是Log4j的基本功能，Log4j日志系统还提供许多强大的功能，比如允许把日志输出到不同的地方，如控制台（Console）、文件（Files）等，可以根据天数或者文件大小产生新的文件，可以以流的形式发送到其它地方等等。

常使用的类如下：

org.apache.log4j.ConsoleAppender（控制台） org.apache.log4j.FileAppender（文件） org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件） org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件） org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

基本上可以满足我们的日常需求，当然如果你的需求比较特殊，可以自己实现Appender输出路径。只需要定义一个类，实现Appender接口就可以了。Appender接口中定义了一系列记录日志的方法，按照自己的规则实现这些方法即可

3、Layouts

用户可以根据自己的喜好格式化自己的日志输出，Layouts提供四种日志输出样式，如根据HTML样式、自由指定样式、包含日志级别与信息的样式和包含日志时间、线程、类别等信息的样式。

常使用的类如下：

org.apache.log4j.HTMLLayout（以HTML表格形式布局） org.apache.log4j.PatternLayout（可以灵活地指定布局模式） org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串） org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等信息）

配置

在pom.xml

1
2
3
4
5

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

创建配置文件

在src/main/resources目录下创建log4j.properties

Log4j.properties配置详解

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

### 日志的输出级别是dubug，输出位置名字叫stdout,D,E

log4j.rootLogger = debug,stdout,D,E
###表示Logger不会在父Logger的appender里输出，默认为true。###
#log4j.additivity.org.apache=false

### 输出信息到控制台 ###

log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
#用特定格式输出日志
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
#下面是规定好的格式，有点像c语言printf的%d，%m是输出代码中指定的消息的占位符
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

### 输出DEBUG级别以上的日志到文件里 ###

log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ./log/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### 输出ERROR级别以上的日志到文件里 ###

log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =./log/error.log
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

使用

1
2
3
4
5
6
7
8
9
10

public class HttpRequestUtil {
    private static Logger logger = Logger.getLogger(HttpRequestUtil.class);
    public static String login(LoginRequest request){
            try {
                ...
            } catch (IOException | InterruptedException e) {
                logger.error(e);
            }
    }
}

同理还有：

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

package com.log4j;
import org.apache.log4j.Logger;
public class TestLog4j {
  // 得到记录器并读取配置文件 -- 基于类的名称获取日志对象
  private static Logger logger = Logger.getLogger(TestLog4j.class);
  public static void main(String[] args) {
    // 插入记录信息（格式化日志信息）
    // 记录debug级别的信息
    logger.debug("调试信息.");
    // 记录info级别的信息
    logger.info("输出信息.");
    // 记录error级别的信息
    logger.error("错误信息.");
    // 记录warn级别的信息
    logger.warn("警告信息.");
    logger.trace("跟踪信息");
    logger.fatal("致命信息");
  }
}

控制台信息：

1
2
3
4
5
6
7
8
9
10
11

[DEBUG]
2019-03-31 11:33:36,492 method:com.log4j.TestLog4j.main(TestLog41.java:19)
调试信息.
[INF0 ] 2019-03-31 11:33:36,507 method:com.log4j.TestLog4j.main(estlog4j.java:21)
输出信息.
[ERROR] 2019-03-31 11:33:36,508 method:com.log4j.TestLog4j.main(TestLog4i.iava:23
错误信息.
[WARN ]2019-03-31 11:33:36,510 method:com.log4j.TestLog4j.main(TestLog4j.java:25
警告信息.
[FATAL] 2019-03-31 11:33:36,515 method:com.log4j.TestLog4j.main(TestLog4i.java:27)
致命信息.

输出的文件：

1
2
3
4
5
6
7

2019-03-31 11:33:36 [ main:0 ] - [ DEBUG ] 调试信息.
2019-03-31 11:33:36 [ main:15 ] - [ INFO ] 输出信息.
2019-03-31 11:33:36 [ main:16 ] - [ ERROR ] 错误信息.
2019-03-31 11:33:36 [ main:16 ] - [ ERROR ] 错误信息.
2019-03-31 11:33:36 [ main:18 ] - [ WARN ] 警告信息.
2019-03-31 11:33:36 [ main:23 ] - [ FATAL ]  致命信息.
2019-03-31 11:33:36 [ main:23 ] - [ FATAL ] 致命信息.

<details style="margin: 10px 0;">
  <summary style="font-weight: bold; border: 2px solid rgb(240, 98, 146); border-radius: 5px; background-color: rgb(252, 228, 236); padding: 5px;">PROOF</summary>
  <img style="display: block; margin: 0 auto;" src="image-20240406184732973.png"></img>
</details>

第1章 线性代数中的线性方程组

1.2行化简与阶梯形矩阵

序列化和反序列化

Java 序列化是一种将对象转换为字节流的过程，以便可以将对象保存到磁盘上，将其传输到网络上，或者将其存储在内存中，以后再进行反序列化，将字节流重新转换为对象。

序列化在 Java 中是通过 java.io.Serializable 接口来实现的，该接口没有任何方法，只是一个标记接口，用于标识类可以被序列化。

当你序列化对象时，你把它包装成一个特殊文件，可以保存、传输或存储。反序列化则是打开这个文件，读取序列化的数据，然后将其还原为对象，以便在程序中使用。

传输对象

实现 Serializable 接口： 要使一个类可序列化，需要让该类实现 java.io.Serializable 接口，这告诉 Java 编译器这个类可以被序列化.

1
2
3
4
5

public class User implements java.io.Serializable {	//该接口没有任何方法，只是一个标记接口，用于标识类可以被序列化。
    private static final long serialVersionUID =1L;
    private String name;
    private String password;
}

• java.io.ObjectOutputStream

​ 代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obi对象进行序列化，把得到的字节序列写到一个目标输出流中。

• java.io.ObjectInputStream

​ 代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

通过Socket传输对象

• 客户端

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

  public class userClient { public static void main(String[l args){ //创建客户端socket，指定服务器的p和端口 try { Socket socket = new Socket("127.0.0.1",9999); //获取该socket的输出流，用来向服务器发送信息 OutputStream os=socket.getOutputStream(); ObiectOutputStream oos =new ObjectOutputStream(os); //序列化user对象，以字节序列输出 oos.writeObject(new User(1, "root","123456")); socket.shutdownOutput(); //获取输入流，取得服务器的信息 InputStream is= socket.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String info = null; while ((info = br.readLine())!= null){ System.out.println("服务器的信息是:"+ info) } } }

• 服务端

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

  public class ServerHandleThread implements Runnable{ //表示该类的实例可以被一个线程执行 Socket socket=null; public ServerHandleThread(Socket socket){ super(); this.socket= socket; } public void run() { OutputStream os = null; PrintWriter pw = null; try { InputStream is = socket.getInputStream(); ObjectInputStream ois=new ObjectInputStream(is); //从客户端读取字节序列，反序列化为对象 System.out.println("客户端发送的对象:"+(User) ois.readObject()); socket.shutdownInput();// 关闭套接字的输入流，连接并未关闭 os=socket.getOutputStream(); pw=new PrintWriter(os); pw.println("欢迎登录!"); pw.flush(); socket.shutdownOutput(); } } }

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

  public class simpleServer { public static void main(String[] args){ try { ServerSocket serverSocket =new ServerSocket(9999); intcount=0://记录客户端的数量 System.out.println("服务器启动，等待客户端的连接。。。"); Socket socket = null; while(true){ socket=serverSocket.accept(); ++count; //调用线程函数 Thread serverHandleThread=new Thread(new ServerHandleThread(socket)); serverHandleThread.setPriority(4); serverHandleThread.start(); System.out.println("上线的客户端有"+ count+"个!"); InetAddress inetAddress=socket.getInetAddress(); System.out.println("当前客户端的!P地址是:"+inetAddress.getHostAddress()); } }catch(lOException e){ // TODO Auto-generated catch block e.printStackTrace(); } } }

存储对象

• 序列化对象

  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

  import java.io.*; public class SerializeDemo { public static void main(String [] args) { Employee e = new Employee(); e.name = "Reyan Ali"; e.address = "Phokka Kuan, Ambehta Peer"; e.SSN = 11122333; e.number = 101; try { FileOutputStream fileOut = new FileOutputStream("/tmp/employee.ser"); ObjectOutputStream out = new ObjectOutputStream(fileOut); out.writeObject(e); out.close(); fileOut.close(); System.out.printf("Serialized data is saved in /tmp/employee.ser"); }catch(IOException i) { i.printStackTrace(); } } }

  • 当序列化一个对象到文件时， 按照 Java 的标准约定是给文件一个 .ser 扩展名

• 反序列化对象

  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

  import java.io.*; public class DeserializeDemo { public static void main(String [] args) { Employee e = null; try { FileInputStream fileIn = new FileInputStream("/tmp/employee.ser"); ObjectInputStream in = new ObjectInputStream(fileIn); e = (Employee) in.readObject(); in.close(); fileIn.close(); }catch(IOException i) { i.printStackTrace(); return; }catch(ClassNotFoundException c) { System.out.println("Employee class not found"); c.printStackTrace(); return; } System.out.println("Deserialized Employee..."); System.out.println("Name: " + e.name); System.out.println("Address: " + e.address); System.out.println("SSN: " + e.SSN); System.out.println("Number: " + e.number); } }

静态资源的上传与访问

在BlessingChess项目中，想要做一个图片实时上传和读取的需求，第一想到的是直接把文件放在static目录下，然后实时上传和读取。

读取资源（也就是web端访问static资源）其实就很简单，Spring Boot 默认就配置了 /static/** 映射，所以无需任何配置就能访问。

很快啊，工具类起手：

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121