风酥糖

大小端序存储

Wed, 25 Feb 2026 15:46:39 +0800

端序概念

端序（Endianness)主要定义了多字节数据在内存地址中的存放顺序.

大端模式 (Big-Endian): 数据的高位字节（MSB)存放在内存的低地址端.
- 符合人类从左到右的阅读习惯.
小端模式 (Little-Endian): 数据的低位字节（LSB)存放在内存的低地址端.
- 符合计算机逻辑运算的处理习惯.

记忆口诀:

大端: 高位在低址

小端: 低位在低址

存储示例

以十进制数字 44033 为例, 其十六进制值为 0x0000AC01（32位整数, 4字节).

假设内存地址从左向右依次增大（低地址 -> 高地址):

模式	内存布局 (地址: 低 -> 高)	说明
大端存储	`00` `00` `AC` `01`	`01`是最低位, 放在最高地址
小端存储	`01` `AC` `00` `00`	`01`是最低位, 放在最低地址

常见标准与应用场景

大小端模式的存在, 主要是因为不同 CPU 架构的设计理念不同. 为了在不同的软硬件环境中准确地传递和解析数据, 形成了以下几个层面的标准与应用规范:

物理硬件与操作系统 (系统端序)

这一层决定了数据在物理内存条中真实的摆放顺序.

小端序 (Little-Endian) - 当前绝对主流:
- 架构: Intel/AMD 的 x86/x64 架构, 以及大部分移动设备使用的 ARM 架构.
- 操作系统: Windows, Linux, Android, iOS, 以及现代的 macOS (Intel 和 Apple Silicon 芯片).
- 优势: CPU 从低地址读取低位字节, 方便在读取的同时进行进位运算, 硬件电路设计相对简单高效.
大端序 (Big-Endian) - 历史与特定设备:
- 架构: 早期的 PowerPC 架构, SPARC 架构, 以及 IBM 大型机.
- 操作系统: 早期的 Mac OS (基于 PowerPC 芯片时代).

编程语言层面的处理 (语言端序)

不同编程语言对底层硬件的抽象程度不同, 导致它们对待端序的策略也不同:

C / C++ (贴近硬件的 Native 语言):
- 策略: 完全映射底层硬件. 硬件是小端, 程序内存里就是小端.
- 特点: 允许通过指针直接访问物理内存布局, 因此可以用 C 语言代码准确检测出当前系统的端序.
Java (自带虚拟机的跨平台语言):
- 策略: 强制统一标准, 屏蔽硬件差异.
- 特点: Java 虚拟机 (JVM) 规范要求其类文件结构, 字节流解析默认统一使用 大端序 (Big-Endian) . 底层运行时, JVM 会自动将宿主机的小端数据翻转为大端供 Java 程序使用. 因此, Java 程序员通常不需要感知底层硬件的端序.
Go / Rust: 类似于 C, 默认采用宿主机的字节序（通常是小端), 但在标准库中提供了显式处理大端/小端的包（如 Go 的 encoding/binary), 方便编写网络协议.
Python: 纯解释型语言. 整数在 Python 内部是一个复杂的对象（PyObject), 根本看不到它底层的字节序. 只有当使用 struct 模块把数字转成二进制流时, 才需要指定 < (小端) 或 > (大端).

网络数据传输 (TCP/IP 协议标准)

这是端序转换最核心的应用场景.

痛点: 如果一个运行在 x86 系统 (小端) 的电脑, 给一个运行在老式 IBM 主机 (大端) 的设备发送数据, 由于双方解析字节流的顺序相反, 数据就会出错.
统一标准 (网络字节序): 为了解决异构平台的通信问题, TCP/IP 协议强制规定: 在网络上传输的多字节数据, 必须统一采用大端模式 (Big-Endian) .
转换规则:
- 单字节数据 (char): 只占 1 个字节, 不存在顺序问题, 直接传输.
- 多字节数据 (int, short, float等):
  - 发送端: 必须先将数据从主机字节序转换为网络字节序 (大端) 后, 再发送到网络上.
  - 接收端: 收到网络数据后, 必须将其从网络字节序转换回当前环境对应的主机字节序, 然后再进行处理.

在实际工作中, 我们在定消息协议时, 可以提前定义好字节序与对齐方式, 之后网络两端的程序都按照规定的方式解析

比如某个消息按照二进制传输, 约定字节按照1字节对齐(无空白字节填充), 小端序传输, 只要保证所有网络端的程序都按照相同约定的方式处理数据即可

字节端序源码示例

以下代码演示了 Python 中如何使用大端或小端打包数据, 并按字节输出, 与之前的结论示例对应

import struct

# 数字 44033 (0x0000AC01)

print("--- 小端模式 (<) ---")
# pack('<i'): 小端打包成 int
# unpack('<BBBB'): 按小端解包成 4 个 unsigned char
result = struct.unpack('<BBBB', struct.pack('<i', 44033))
print('0x', end='')
for b in result:
    print(f'{b:02X}', end='')
# 输出: 0X01AC0000 (低位 01 在前)

print("\n\n--- 大端模式 (>) ---")
# pack('>i'): 大端打包成 int
result = struct.unpack('>BBBB', struct.pack('>i', 44033))
print('0x', end='')
for b in result:
    print(f'{b:02X}', end='')
# 输出: 0X0000AC01 (高位 00 在前)

使用C语言检测系统端序

可以通过检查变量在内存中的首字节来判断当前环境的端序

方法一: 指针强制转换法

原理: 将 int 的地址强制转换为 char*, 只读取内存的第一个字节（低地址).

#include <stdio.h>

int test1_endian() {
    int i = 1; // 十六进制 0x00000001
    char *a = (char *)&i; // 获取低地址的值

    // 如果低地址存的是 1, 说明低位在低址 -> 小端
    if (*a == 1)
         printf("当前系统为: 小端\n");
    else
         printf("当前系统为: 大端\n");
    return 0;
}

方法二: 联合体法

原理: Union 的所有成员共用同一块内存首地址.

#include <stdio.h>

int test2_endian() {
     union {
            int i;
            char c;
     } un;

     un.i = 1; // 写入 0x00000001

     // 读取 c, 相当于读取 int 的低地址字节
     if(un.c == 1) {
            printf("当前系统为: 小端\n");
     }
     else {
            printf("当前系统为: 大端\n");
     }
     return 0;
}

C++11现代化编程基础

Fri, 13 Feb 2026 00:00:00 +0000

C++11中引入了右值引用, 移动语义, 新增了许多标准库内容, 这里主要介绍一些基于C++11的现代类构建, 内存资源管理等基础内容, 也算是自己的一次复习, 文中部分内容来自书本<C++ primer 5th>

重点:

RAII: 智能指针
Functional: lambda
STL: vector, map, unordered_map

语言基础

基本编译与运行

# g++编译源码,输出二进制可执行文件
# 若省略-o prog1,编译器默认输出a.out
# 通过-std=c++0x,指定C++11支持
g++ -o prog1 prog1.cc

# 运行程序
./prog1

# 查看程序返回值
echo $?

测试-1返回值

1
2
3

int main() {
  return -1;
}

1
2
3

g++ -o prog1 -std=c++0x prog1.cc
./prog1
echo $? # 255

输入不定数量的数字

#include <iostream>
int main() {
  int num = 0, sum = 0;
  while (std::cin >> num) { // 持续读取直到遇见EOF(end-of-file), bash中可通过ctrl+d输入EOF
    sum += num;
  }
  std::cout << sum << std::endl;
}

内联函数和constexpr函数

内联机制用于优化规模较小、流程直接、频繁调用的函数, inline关键字也只是给编译器的建议, 如果函数过长(超过10行), 或者其中包含分支/循环/递归, 实际上编译器不支持内联展开

constexpr函数约定: 函数的返回类型及所有形参的类型都得是字面值类型, 而且函数体中必须有且只有一条return语句

constexpr函数的返回值由编译器在编译时确定, constexpr函数被隐式地指定为内联函数

constexpr int new_sz() { return 42; }
constexpr int foo = new_sz();
constexpr size_t scale(size_t cnt) {
  return new_sz() * cnt;
}

int main() {
  std::cout << scale(2) << std::endl;
  return 0;
}

函数指针与返回指针的函数

1
2

bool (*pf)(const std::string&, const std::string&); // 函数指针
bool *pf(const std::string&, const std::string&); // 返回指针的函数

类

class基本

struct和class没有很大区别,主要是默认访问权限不同,struct默认为public,class默认为private

The only difference between struct and class is the default access level.

If we use the struct keyword, the members defined before the first access specifier are public; if we use class, then the members are private.

sale_data.h

#include <iostream>
#include <string>
#include <cstdint>

struct SaleData {
  // costructors
  SaleData() = default; // 使用自动生成的默认构造
  SaleData(const std::string& s, uint32_t n, double p) :
    book_no(s), units_sold(n), revenue(p) {} // 构造函数初始值列表, 若成员是const或者引用, 必须在此时初始化
  SaleData(const std::string& s) : SaleData(s, 0, 0.0) {} // 委托构造
  SaleData(SaleData&) = delete; // 禁用自动生成的复制构造
  // operations
  std::string isbn() const { return book_no; }
  SaleData& combine(const SaleData&);
  double avg_price() const;
  // data members
  std::string book_no;
  uint32_t units_sold = 0;
  double revenue = 0.0;
};
// nonmember SaleData interfaces functions
std::ostream& operator<<(std::ostream&, const SaleData&);
std::istream& operator>>(std::istream&, SaleData&);

sale_data.cc

#include "item.h"

double SaleData::avg_price() const {
  if (units_sold > 0) {
    return revenue / units_sold;
  } else {
    return 0.0;
  }
}

SaleData& SaleData::combine(const SaleData& rhs) {
  units_sold += rhs.units_sold;
  revenue += rhs.revenue;
  return *this;
}

std::ostream& operator<<(std::ostream& os, const SaleData& data) {
  os << "ISBN: " << data.isbn() << "; Sold: " << data.units_sold
    << "; Avg price: " << data.avg_price() << std::endl;
  return os;
}

std::istream& operator>>(std::istream& is, SaleData& data) {
  double price = 0.0;
  is >> data.book_no >> data.units_sold >> price;
  data.revenue = price * data.units_sold;
  return is;
}

main.cc

#include <iostream>
#include "item.h"
int main() {
  SaleData d1, d2;
  std::cin >> d1 >> d2;
  d1.combine(d2);
  std::cout << "Combine: " << d1 << std::endl;
  return 0;
}

隐式类类型转换

如果构造函数只接受一个实参, 则它实际上定义了转换为此类类型的隐式转换机制, 有时我们把这种构造函数称作转换构造函数

只有接收一个参数的构造函数才会用于隐式转换, explicit关键字也只能修饰只有一个参数的构造函数
隐式转换不能连续转换两次, 比如 const char* -> std::string -> MyClass
explicit修饰构造函数可阻止隐式转换发生

class MyClass {
public:
  MyClass(const std::string& n) : name(n) {}
  explicit MyClass(int n) : num(n), name("default") {}
  std::string to_string() const {
    return std::string("{ MyClass: ") + name + " * " + std::to_string(num) + " }";
  }
private:
  std::string name;
  int32_t num = 0;
};

void test(const MyClass& t) {
  std::cout << t.to_string() << std::endl;
}

int main() {
  test(std::string("cpp"));
  MyClass c = std::string("cpp");
  // test("cpp"); // Error 隐式转换不能连续转换两次 const char* -> std::string -> MyClass
  // test(99); // Error 使用explicit声明的构造函数不可以用作隐式转换
  return 0;
}

Friends

友元: private成员只允许类成员函数访问, 若希望允许在外部类/函数中访问private成员, 可使用友元声明

class SaleData {
// friends declarations
friend std::ostream& operator<<(std::ostream&, const SaleData&);
friend std::istream& operator>>(std::istream&, SaleData&);
// friend class TestClass;

public:
  // costructors
  SaleData() = default;
  SaleData(const std::string& s) : book_no(s) {}
  SaleData(const std::string& s, uint32_t n, double p) :
    book_no(s), units_sold(n), revenue(p) {}
  SaleData(SaleData&) = delete;
  // operations
  std::string isbn() const { return book_no; }
  SaleData& combine(const SaleData&);
  double avg_price() const;
private:
  // data members
  std::string book_no;
  uint32_t units_sold = 0;
  double revenue = 0.0;
};
// nonmember SaleData interfaces functions
std::ostream& operator<<(std::ostream&, const SaleData&);
std::istream& operator>>(std::istream&, SaleData&);

类型别名

// 可在类外定义, typedef 与 using 等价, using更直观
typedef std::string::size_type pos;
using spos = std::string::size_type;

// 也可以在类中定义, 作为类成员, 受到访问权限控制
class MyClass {
public:
  typedef std::string::size_type pos;
  using spos = std::string::size_type;
};

int main() {
  MyClass::pos p = 0;
  return 0;
}

const对象与const成员

声明为 const 的对象只能访问类中声明为 const 的成员函数, 不能调用其它成员函数

const成员函数

class Test {
public:
  void print(int i) const;
};

const 是函数类型的一个组成部分, 因此在实现部分也要带 const 关键字
常成员函数不能更新对象的数据成员, 也不能调用该类中没有用 const 修饰的成员函数

使用const的建议

要大胆的使用 const, 这将给你带来无尽的益处, 但前提是你必须搞清楚原委
要避免最一般的赋值操作错误, 如将 const 变量赋值, 具体可见思考题
在参数中使用 const 应该使用引用或指针, 而不是一般的对象实例, 原因同上
const 在成员函数中的三种用法（参数、返回值、函数）要很好的使用
不要轻易的将函数的返回值类型定为 const
除了重载操作符外一般不要将返回值类型定为对某个对象的 const 引用

顶层const与底层const

如果能弄明白以下所有的情况, 那么恭喜你迈出了可喜的一步

  int a = 0;
  const int * b1 = &a; // 1
  int const * b2 = &a; // 2
  int * const b3 = &a; // 3
  const int * const b4 = &a; // 4

上面的示例中, 1和2情况相同, const位于星号左侧, 都是指针指向的内存不可变, 但指针的值可以修改; 3表示指针本身值不可变, 但指向的内存可变; 4则是两者都不可变

顶层const: 指针本身为常量, 指针的值(地址)不可变, 但它指向的内存是可修改的
底层const: 指针的值(地址)可修改, 但它指向的内存是不可变的
顶层const+底层const: 指针值和指向的内存都是不可变的

拷贝与移动控制

左值与右值

理解C++11中拷贝与移动的前提是了解左值右值, 以及对应的引用

左值 (Lvalue): 指向明确内存地址, 有名字的对象. 可以取地址. 例如: 变量名, 指针成员, 返回左值引用的函数.
右值 (Rvalue): 临时对象, 表达式产生的中间结果, 没有持久的身份. 无法取地址. 例如: 字面量 (除字符串外), 返回非引用类型的函数结果, 表达式 a + b.

引用类型

左值引用 (T&): 只能绑定到左值, 长久存在, 而且可修改
右值引用 (T&&): 只能绑定到右值, 其核心意义在于: 这个右值对象是临时的, 可以安全的移动它的资源, 不用担心造成其他影响
常量左值引用 (const T&): 可以绑定到任何值(左值, 右值), 但只读不能修改

C++11中专门引入右值引用用于解决两大痛点: 移动语义和完美转发

int a = 10;           // a 是左值, 10 是右值
int& lref = a;        // 左值引用绑定到左值
// int& lref2 = 10;   // 错误: 左值引用不能绑定右值!!
int&& rref = 10;      // 右值引用 (&&) 绑定到右值
// int&& rref2 = a;   // 错误: 右值引用不能绑定左值!!
const int& cref = 10; // 常量左值引用可绑定到右值

右值引用变量具备名称, 可以被取地址, 所以右值引用的变量本身是一个左值, 右值引用的变量用于函数匹配时会匹配到左值的版本! 重要

并且前文提到, 左值引用只能绑定到左值, 右值引用只能绑定到右值

函数形参匹配时同样遵循该规则: 形参为左值引用时无法传入右值; 形参为右值引用时无法传入左值

#include <iostream>
void work(int&) { std::cout << "Left value" << std::endl; }
void work(int&&) { std::cout << "Right value" << std::endl; }
int main() {
  int n = 0;
  int& r1 = n;
  int&& r2 = 10; // 其实在此语句之后, r2和普通的int变量(左值)已经没有什么区别
  work(r1); // 传入左值, 匹配左值引用版本
  work(r2); // 传入左值, 匹配左值引用版本, 记住: 右值引用的变量本身 还是左值 (有名字, 可取地址)
  work(std::move(n)); // 传入右值, 匹配右值引用版本
  work(20); // 传入右值, 匹配右值引用版本
  return 0;
}

// 输出
// Left value
// Left value
// Right value
// Right value

右值是中间结果, 临时对象, 即将消亡的对象, 而右值引用可以延长临时对象的声明周期

C++ 标准明确规定: 当右值引用绑定到临时对象时, 临时对象的生命周期会被延长至与右值引用的生命周期一致

// 延长字面值的生命周期
// 字面值可能在源码指令中,没有内存地址,也可能存储在只读数据段.rodata,不可修改
// 右值引用无法绑定到只读的字面值,发生绑定时,编译器会在栈上创建一个临时int变量并初始化
// 右值引用绑定到临时变量,延长临时变量生命周期与自身一致
int&& rref = 20; // 栈上临时变量,右值引用绑定在临时变量上
rref = 999; // 右值引用为左值,可修改
cout << rref; // 999


std::vector<int> get_big_data() { return {1, 2, 3, 4, 5}; }
// get_big_data() 产生的临时 vector 在这行结束后本该销毁
// 但 data 接住了它, 延长了它的寿命, 且没有发生深拷贝
// 左值引用无法引用右值, 无法承接返回的数据, 若不使用右值引用, 可能会发生不必要的数据拷贝
std::vector<int>&& data = get_big_data();

类的"五法则"

一个类若要管理资源(动态内存/句柄等), 通常需要实现"五法则", 包括以下成员

析构函数 (~T())
拷贝构造函数 (T(const T&)) 参数必须是const, 避免无限递归
拷贝赋值运算符 (T& operator=(const T&))

实现自身成员赋值, 与旧资源释放
移动构造函数 (T(T&&)) – C++11新增
移动赋值运算符 (T& operator=(T&&)) – C++11新增

拷贝构造函数和拷贝赋值运算符一般来说要实现类资源的深拷贝, 而不是简单的指针值拷贝

而移动构造函数和移动赋值运算符需要实现类资源的"移动", 避免不必要的拷贝, 提升性能, 减少资源浪费

‍

std::move本质上是一个强制类型转换(static_cast<T&&>), 它本身不移动任何内容, 只是告诉编译器将对象当作右值引用看待, 用于触发移动语义, 至于是否发生移动, 取决于对应的类是否实现了移动构造函数/移动赋值运算符

‍

以一个类的实现举例

#include <iostream>
#include <algorithm>

class ResourceManager {
private:
  int* data; // 方便示例, 这里没使用智能指针
  size_t size;
public:
  // 构造函数
  ResourceManager(size_t s): size(s), data(new int[s]) {}
  ResourceManager(): ResourceManager(10) {}
  // 析构函数
  ~ResourceManager() {
    delete[] data;
  }
  // 拷贝构造函数 (深拷贝)
  ResourceManager(const ResourceManager& other): size(other.size), data(new int[other.size]) {
    std::copy(other.data, other.data + other.size, data);
    std::cout << "Copy constructor" << std::endl;
  }
  // 拷贝赋值运算符: 自身成员赋值与旧资源释放
  ResourceManager& operator=(const ResourceManager& other) {
    if (this != &other) { // 防止自我赋值
      int* new_data = new int[other.size];
      std::copy(other.data, other.data + other.size, new_data);
      delete[] data; // 释放旧资源
      data = new_data;
      size = other.size;
    }
    std::cout << "Copy operator =" << std::endl;
    return *this;
  }
  // 移动构造函数: 转移资源所有权, 标记为noexcept优化性能
  ResourceManager(ResourceManager&& other) noexcept: size(other.size), data(other.data) {
    other.data = nullptr; // 将原对象置于可析构的默认状态
    other.size = 0;
    std::cout << "Move constructor" << std::endl;
  }
  // 移动赋值运算符
  ResourceManager& operator=(ResourceManager&& other) noexcept {
    if (this != &other) {
      delete[] data; // 释放旧资源
      data = other.data; // 转移资源所有权
      size = other.size;
      other.data = nullptr;
      other.size = 0;
    }
    std::cout << "Move operator =" << std::endl;
    return *this;
  }
};

移动语义

为什么要移动? 拷贝涉及内存分配和数据复制 (昂贵), 而移动只需修改指针指向 (廉价).

‍

以上面的类进行以下测试, 观察显式对象移动的触发, 完成资源所有权转移

int main() {
  ResourceManager r1; // 普通构造
  ResourceManager r2(r1); // 拷贝构造
  ResourceManager r3(std::move(r1)); // 移动构造 (r1的资源被转移所有权, 转移之后不应该再使用r1)
  ResourceManager r4;
  r4 = r2; // 拷贝赋值运算
  ResourceManager r5;
  r5 = std::move(r3); // 移动赋值运算 (r3的资源所有权被转移)
  ResourceManager r6 = r4; // 依然是 拷贝构造, 这里要注意, 定义时的初始化不同于赋值运算
  return 0;
}

输出如下

Copy constructor
Move constructor
Copy operator =
Move operator =
Copy constructor

默认生成的函数与`=default`

一般来说, 当我们定义一个类但不声明任何构造和赋值运算符时, 编译器会生成默认的无参构造函数以及拷贝构造函数和拷贝赋值运算符

当我们定义一个带参构造函数时, 编译器又不会自动生成默认的无参构造函数

‍

我不喜欢去猜一个函数有没有自动生成, 我希望类的内容和行为是明确清晰的

‍

C++11允许我们更精确的控制自动生成的函数, 掌握类的行为, 让内存/资源的拷贝或转移都按照我们预想的执行

=default 显式声明需要默认生成的构造函数或者赋值运算符
=delete 显式声明禁止生成默认的构造函数或者赋值运算符

‍

如果没有明确声明"五法则"的每个函数, 一个类到底包含哪些构造函数和赋值运算, 其行为是怎样的, 完全不可控, 很难一眼看清

‍

这里用一个错误举例说明一下未定义和不可控的危害, 下面的Test类没有显式定义任何构造/赋值运算, 只有一个简单的析构

class Test {
public:
  size_t size = 0;
  int* data = nullptr;
public:
  ~Test() { delete[] data; }
};

int main() {
  Test t1;
  t1.size = 10;
  t1.data = new int[10];
  Test t2(t1);
  Test t3;
  t3 = t1;
  std::cout << t1.size << " " << t1.data << std::endl;
  std::cout << t2.size << " " << t2.data << std::endl;
  std::cout << t3.size << " " << t3.data << std::endl;
  return 0;
}

以上代码运行后会发现t1, t2, t3的data指针值一样, 并且同一个内存位置会被多次释放, 内存管理混乱

这是因为编译器帮我们生成了不符合规范的默认拷贝构造和

10 0x60bfb23b6eb0
10 0x60bfb23b6eb0
10 0x60bfb23b6eb0
free(): double free detected in tcache 2

‍

默认生成函数的行为

默认无参构造函数: 按照类成员顺序逐个初始化
- 如果是类类型成员, 则调用其默认构造函数初始化
- 如果有类内初始值, 则按照顺序使用给定的初始值初始化
- 内置类型(int, double等), 如果没有类内初始值, 也没有在构造函数中处理, 将被默认初始化 (可能是无意义的垃圾值)

默认的复制构造: 按照类成员顺序逐个拷贝, 如果是类类型成员, 则尝试拷贝构造

// 编译器生成的拷贝构造函数大致等同于:
    // DataBatch(const DataBatch& other) :
    //     id(other.id),
    //     name(other.name),
    //     scores(other.scores) {}
    DataBatch(const DataBatch&) = default;

默认的拷贝赋值运算: 按照类成员顺序逐个进行赋值运算 (拷贝赋值)

// 编译器生成的拷贝赋值运算符大致等同于:
    // DataBatch& operator=(const DataBatch& other) noexcept {
    //     id = other.id;
    //     name = other.name;
    //     scores = other.scores;
    //     return *this;
    // }
    DataBatch& operator=(const DataBatch&) = default;

默认的移动构造: 按照类成员顺序逐个进行移动构造

// 编译器生成的移动构造函数大致等同于:
    // DataBatch(const DataBatch& other) :
    //     id(std::move(other.id)),
    //     name(std::move(other.name)),
    //     scores(std::move(other.scores)) {}
    DataBatch(DataBatch&&) = default;

默认的移动赋值运算: 按照类成员顺序逐个进行移动赋值运算

// 编译器生成的移动赋值运算符大致等同于:
    // DataBatch& operator=(DataBatch&& other) noexcept {
    //     id = std::move(other.id);
    //     name = std::move(other.name);
    //     scores = std::move(other.scores);
    //     return *this;
    // }
    DataBatch& operator=(DataBatch&&) = default;

还是以上面的ResourceManager类来复用举例, 我们构建一个Test类并包含一个ResourceManager成员, “五法则"除了析构函数全用默认生成

class Test {
private:
  ResourceManager m;
public:
  Test() = default;
  Test(const Test& t) = default;
  Test(Test&& t) = default;
  Test& operator=(const Test& t) = default;
  Test& operator=(Test&& t) = default;
};

int main() {
  Test t1;
  Test t2(t1); // 逐个成员拷贝构造
  Test t3(std::move(t1)); // 逐个成员移动构造
  Test t4;
  t4 = t2; // 逐个成员拷贝赋值运算
  Test t5;
  t5 = std::move(t3); // 逐个成员移动赋值运算
  return 0;
}

得到如下输出, 在我们预期之中

Copy constructor
Move constructor
Copy operator =
Move operator =

`=default`默认函数与`{}`实现的区别

在自己明确知道=default干了什么的前提下, 可以尽量使用, 因为=default不仅显式标明了”该函数存在, 由编译器默认生成“的信息, 还可能有一些性能优化, 并且可自动推导noexcept

A. 琐碎性 (Triviality)

如果一个类所有的成员都有 “琐碎” 的构造函数 (比如全是基本类型 int, double 或指针), 那么 =default 生成的构造函数也是 Trivial (琐碎的)

琐碎函数: 编译器可以将其优化为极其高效的内存操作 (如 memcpy 或直接清零)
用户定义函数 {} : 一旦你写了 {}, 即使里面什么都没写, 这个函数也不再是 “琐碎” 的, 编译器必须像调用普通函数一样去执行它, 无法进行内存级别的压榨优化

B. 异常规格 (Exception Specification)

=default 函数会自动推导异常规格. 如果类的所有成员在拷贝时都不抛出异常, 编译器生成的函数会自动带上 noexcept. 而手动编写 {} 则需要你手动管理 noexcept, 否则可能导致容器性能下降

使用`=default`与`=delete`定制类的行为

如果一个类的资源(所有权)只允许被移动, 不允许被拷贝, 类似std::unique_ptr的行为, 可以按照以下示例处理

如果不小心进行了拷贝, 编译器会报错, 阻止不允许的操作

class Test {
private:
  ResourceManager m;
public:
  Test() = default;
  Test(const Test& t) = delete; // 阻止拷贝构造
  Test(Test&& t) = default;
  Test& operator=(const Test& t) = delete; // 阻止拷贝赋值运算
  Test& operator=(Test&& t) = default;
};

int main() {
  Test t1;
  // Test t2(t1); // 逐个成员拷贝构造 // 编译报错, 删除的操作
  Test t3(std::move(t1)); // 逐个成员移动构造
  Test t4;
  // t4 = t2; // 逐个成员拷贝赋值运算 // 编译报错, 删除的操作
  Test t5;
  t5 = std::move(t3); // 逐个成员移动赋值运算
  return 0;
}

同理, 我们可以自定义控制类的行为, 比如出只允许拷贝不允许移动的类

移动(move)和完美转发(forward)和引用折叠

`std::move`是无条件的右值转换

之前提过, std::move 并不移动任何数据, 它的唯一作用是: 无条件地将输入参数转换为右值引用

相当于告诉编译器, 这个对象我不再使用了, 可以随便转移对象中资源的所有权, 通常会触发目标的 移动构造函数 或 移动赋值运算符

‍

注意: 除非你确定该对象后续不再被使用, 否则不要随便 std::move. 移动后的对象处于 “有效但未定义” 的状态.

`std::forward`是有条件的完美转发

std::forward和引用折叠是紧密相关的概念, std::forward 必须配合 万能引用( T&& ) 使用

‍

作用是: 只有当原始参数是右值时, 才将其转换为右值; 否则保留其左值属性

template<typename T>
void wrapper(T&& arg) { // T&& 在这里是万能引用
    // 如果不加 forward, arg 永远以左值形式传递 (无论arg类型是左值还是右值)
    // 加上 forward, 依据引用折叠规则, 当arg是左值时调用左值引用函数; 当arg是右值时调用右值引用函数
    real_work(std::forward<T>(arg));
}

void real_work(int& x) { std::cout << "Left value" << std::endl; }
void real_work(int&& x) { std::cout << "Right value" << std::endl; }

int main() {
    int a = 10;
    wrapper(a);  // 传入左值, forward 转发为左值
    wrapper(20); // 传入右值, forward 转发为右值
}

引用折叠

为什么说T&&是"万能引用”? 这涉及到C++11中的引用折叠规则

‍

在C++中我们不能直接定义"引用的引用", 比如int& &&, 这种写法会导致编译错误

然而, 在模板参数推导, typedef, using别名, 以及decltype等场景下可能会间接出现这种情况

为了处理这些嵌套的引用, 编译器会应用"引用折叠"规则

原始定义类型	传入/合成T的类型	折叠后的最终类型
T& (左值引用)	& (左值)	T&
T& (左值引用)	&& (右值)	T&
T&& (右值引用)	& (左值)	T&
T&& (右值引用)	&& (右值)	T&&

示例1: typedef别名

typedef int&  Lref;
typedef int&& Rref;

int main() {
  int n = 0;
  Lref& r1 = n; // r1: Lref & -> int& & -> int&
  Lref&& r2 = n; // r2: Lref && -> int& && -> int&
  Rref& r3 = n; // r3: Rref & -> int&& & -> int&
  Rref&& r4 = std::move(n); // r4: Rref && -> int&& && -> int&&
  return 0;
}

注意: 这里的r4变量本身是左值, 再当作参数传递还是会匹配为左值引用参数

函数返回类对象

当函数返回一个局部对象时, 编译器会按照一定优先级顺序来优化这个过程

当你写 return obj; 时, 编译器并非直接选择拷贝, 而是遵循以下优先级:

返回值优化 (RVO/NRVO): 这是最高优先级. 编译器直接在调用者的内存栈上构造对象, 既不发生拷贝, 也不发生移动. 这是性能最优的方案.
隐式移动 (Implicit Move): 如果由于某些原因 (如复杂的条件分支) 无法进行 RVO, 编译器会自动将返回的局部变量视为右值, 尝试调用该类的 移动构造函数.
拷贝构造: 如果类没有定义移动构造函数, 编译器才会回退 (Fallback) 到传统的 拷贝构造.

性能最大化: 移动语义的开销远小于深拷贝. 这种自动尝试移动的机制让开发者无需手动编写 return std::move(obj); (事实上, 显式写 std::move 反而会破坏 RVO 优化, 导致性能下降).

‍

如果没有上述优化, 看看C++98/03时代的内存处理过程

class BigObject {
    // ... 包含拷贝构造函数和析构函数 ...
};

BigObject createObj() {
    BigObject temp; // 1. 构造局部对象
    return temp;    // 2. 拷贝构造到临时对象 (return slot)
                    // 3. 析构局部对象 temp
}

int main() {
    BigObject obj = createObj(); // 4. 拷贝构造到 obj
                                 // 5. 析构临时对象
}

理论上的开销：

构造局部对象.
拷贝构造临时对象（用于传出返回值）.
析构局部对象.
拷贝构造最终对象 obj.
析构临时对象.
(最终) 析构 obj.

这涉及了两次拷贝和两次额外的析构, 对于重量级对象（如大容器）, 性能损耗巨大

‍

RVO 通常特指 Unnamed Return Value Optimization (未命名返回值优化). 当函数直接返回一个临时对象（匿名对象）时触发

NRVO 指 Named Return Value Optimization (具名返回值优化). 当函数返回一个具名的局部变量时触发

‍

C++11 引入了移动语义 (Move Semantics). 编译器处理返回值的优先级变成了：

Tier 1: RVO/NRVO (最佳, 零拷贝).
Tier 2: Move Constructor (次佳, 资源转移).
Tier 3: Copy Constructor (最差, 深拷贝).

‍

现代C++11函数返回局部对象示例:

class Test {
private:
  int index = 0;
public:
  Test(int i) : index(i) { cout << "Test (" << index << "): Constructor" << endl; }
  Test() : Test(0) {}
  ~Test() { cout << "Test (" << index << "): Deconstructor" << endl; }
  Test(const Test&) { cout << "Test (" << index << "): Copy Constructor" << endl; }
  Test(Test&&) noexcept { cout << "Test (" << index << "): Move Constructor" << endl; }
  Test& operator=(const Test&) { cout << "Test (" << index << "): Copy operator=" << endl; return *this; }
  Test& operator=(Test&&) noexcept { cout << "Test (" << index << "): Move operator=" << endl; return *this; }
};

Test factory1() {
  return Test(111);
}

Test factory2() {
  Test t(222);
  return t;
}

Test factory3() {
  int seed = 333;
  if (rand() % 100 < 50) {
    Test a(seed);
    return a;
  } else {
    Test b(-seed);
    return b;
  }
}

int main() {
  srand(time(nullptr));
  {
    cout << "Case 1" << string(10, '=') << endl;
    Test s1 = factory1();
  }
  {
    cout << "Case 2" << string(10, '=') << endl;
    Test s2 = factory2();
  }
  {
    cout << "Case 3" << string(10, '=') << endl;
    Test s3 = factory3();
  }
  return 0;
}

源码输出

Case 1==========
Test (111): Constructor
Test (111): Deconstructor
Case 2==========
Test (222): Constructor
Test (222): Deconstructor
Case 3==========
Test (-333): Constructor
Test (0): Move Constructor
Test (-333): Deconstructor
Test (0): Deconstructor

用例说明

Case1: RVO优化, 直接原位构造, 仅构造一次, 零拷贝

机制: 编译器意识到该函数通过值返回, 它会直接将 main 函数中 s1 的内存地址隐式传递给 factory1(). factory1() 不再在自己的栈帧上创建临时对象, 而是直接在 s1 的地址上调用构造函数.
Case2: NRVO优化, 同样直接原位构造, 更复杂, 也是仅构造一次, 零拷贝

机制: 相比 RVO, NRVO 更难实现, 因为 t 作为一个局部变量, 在其生命周期内必须可见且可用. 编译器必须确保直接在调用者（main 中的 s2）的内存空间中构造 t, 并确保函数体内的任何操作都是直接针对该外部内存进行的.
Case3: 由于条件分支导致编译器无法进行RVO/NRVO, 编译器会自动将返回的局部变量视为右值, 尝试触发该类的 移动构造函数

可以看到, 在没有任何显式处理的情况下, 编译器已经依据情况做了最佳优化, 不必手动return std::move(t);, 仅当RVO/NRVO没有触发, 并且类没有实现移动构造时, 编译器才会不得已选择拷贝

noexcept

在之前的示例中我们已经多次见到noexcept关键字

noexcept 是 C++11 引入的一个重要关键字, 它本质上是一个 “性能契约” . 它告诉编译器和程序员: “这个函数保证不会抛出任何异常”.

1. noexcept 的基本含义与语法

noexcept 既是一个 说明符 (Specifier) , 也是一个 运算符 (Operator) .

作为说明符: 紧跟在函数参数列表后, 表示该函数是否会抛出异常.
作为运算符: 用于在编译期检查一个表达式是否可能抛出异常.

void fast_func() noexcept;          // 保证不抛出异常
void slow_func() noexcept(false);   // 可能会抛出异常 (等同于不写)

// 运算符用法
bool is_safe = noexcept(fast_func()); // 返回 true

2. 核心作用: 性能优化的 “绿灯”

noexcept 最主要的作用不是为了排版好看, 而是为了性能.

A. 编译器优化

在普通函数中, 编译器必须生成大量的额外代码来支持 栈回溯 (Stack Unwinding) . 万一异常发生, 程序需要知道如何按顺序销毁已构造的局部对象. 如果标注了 noexcept, 编译器就可以省去这些复杂的开销, 生成更小, 更快的机器码.

B. 容器搬运的效率 (以 std::vector 为例)

这是 noexcept 最具实战价值的场景. 当 std::vector 扩容需要将旧元素迁移到新内存时:

如果元素的 移动构造函数 是 noexcept 的, vector 会选择 移动 (Move) , 速度极快.
如果移动构造函数没有标注 noexcept, vector 为了保证 “强异常安全保证” (即移动一半出错了不能把原数据弄丢), 会被迫选择 拷贝 (Copy) .

3. 关键问题: 如果在 noexcept 函数中抛出了异常会怎样?

这是一个典型的 “破釜沉舟” 行为. 如果你承诺了不抛异常, 结果却在运行时从 noexcept 函数中甩出了一个异常:

立即调用 std::terminate() : 程序不会去寻找匹配的 catch 块.
不保证栈回溯: 在调用 std::terminate() 之前, 编译器 不保证 会销毁当前的局部对象. 这意味着你的析构函数可能不会执行, 资源可能泄露.
直接崩溃: 程序会直接挂掉, 没有任何商量的余地.

4. 什么时候该用 noexcept ?

虽然它能提速, 但也不要滥用. 以下是最佳实践:

必须加上: 析构函数 (默认就是 noexcept), 移动构造函数, 移动赋值运算符, 交换函数 (swap).
建议加上: 逻辑简单的叶子函数 (不调用别人, 且自己不 throw).
不要加上: 可能会向下调用第三方库或涉及 IO 操作, 内存申请 (可能抛出 std::bad_alloc) 的函数.

动态内存与智能指针

使用动态内存最安全的方式是用make_shared/make_unique方法

shared_ptr使用

shared_ptr 使用引用计数自动管理内存

#include <initializer_list>
#include <iostream>
#include <stdexcept>
#include <string>
#include <cstdint>
#include <memory>
#include <vector>


class StrBlob {
public:
  typedef std::vector<std::string>::size_type size_type;
  StrBlob();
  StrBlob(std::initializer_list<std::string> il);
  size_type size() const { return data->size(); }
  bool empty() const { return data->empty(); }
  // 增删元素
  void push_back(const std::string& t) { data->push_back(t); }
  void pop_back();
  // 元素访问
  std::string& front();
  std::string& back();
  // const访问器
  const std::string& front() const;
  const std::string& back() const;
private:
  std::shared_ptr<std::vector<std::string>> data;
  // 下标检查
  void check(size_type i, const std::string& msg) const;
};

StrBlob::StrBlob(): data(std::make_shared<std::vector<std::string>>()) {}
StrBlob::StrBlob(std::initializer_list<std::string> il):
  data(std::make_shared<std::vector<std::string>>(il)) {}
void StrBlob::check(size_type i, const std::string& msg) const {
  if (i >= data->size()) {
    throw std::out_of_range(msg);
  }
}
std::string& StrBlob::front() {
  check(0, "front on empty StrBlob");
  return data->front();
}
std::string& StrBlob::back() {
  check(0, "back on empty StrBlob");
  return data->back();
}
const std::string& StrBlob::front() const {
  check(0, "front on empty StrBlob");
  return data->front();
}
const std::string& StrBlob::back() const {
  check(0, "back on empty StrBlob");
  return data->back();
}
void StrBlob::pop_back() {
  check(0, "pop_back on empty StrBlob");
  data->pop_back();
}

int main() {
  int i = { 42 };
  std::cout << i << std::endl;
  StrBlob b1 = { "a", "b", "c" };
  {
    StrBlob b2 = b1;
    b2.push_back("d");
    std::cout << "b2 size: " << b2.size() << std::endl;
  }
  std::cout << "b1 size: " << b1.size() << std::endl;

  std::shared_ptr<std::vector<std::string>> pv =
    std::make_shared<std::vector<std::string>>(std::initializer_list<std::string>{"a", "b", "c"});
  pv.reset(); // 释放内存, 智能指针成为空指针
  // new和智能指针尽量不要一起用, 避免创建出指向同一内存区域的两个独立智能指针
  int* p = new int(22);
  {
    std::shared_ptr<int> p1(p);
    std::shared_ptr<int> p2(p); // 二次释放, 行为未定义
  }

  int* pn = new int(33);
  std::shared_ptr<int> p1(pn);
  p1.reset(new int(35)); // pn指向的内存被自动释放, p1指向位置变更
  std::shared_ptr<int> p2 = p1; // 正确, 指针拷贝, 引用计数+1
  // reset也常与unique一起使用
  std::string* name = new std::string("unique name");
  std::shared_ptr<std::string> ps(name);
  if (!ps.unique()) {
    ps.reset(new std::string(*ps)); // 不是唯一用户, 分配新的拷贝
  }
  return 0;
}

unique_ptr

与shared_ptr不同的是, unique_ptr拥有它指向的对象, 不支持普通的拷贝或者赋值

unique_ptr<int> p1(new int(12));
// unique_ptr<int> p2(p1); // 错误, 不支持拷贝
// unique_ptr<int> p3 = p2; // 错误, 不支持赋值

p1 = nullptr; // 释放对象, 指针置空
p1.reset(); // 释放对象, 指针置空
p1.reset(nullptr)
p1.reset(p5); // 释放原有对象, 指向新内存
p1.release(); // 释放控制权, 返回指针, 指针本身置空 (内存还在, 只是不再由智能指针管理)

// 移交所有权
unique_ptr<int> p2(p1.release());
unique_ptr<int> p3(new int());
p3.reset(p2.release()); // p3原本内存释放, p2将内存所有权移交到p3

不能拷贝unique_ptr的规则有一个例外：我们可以拷贝或赋值一个将要被销毁的unique_ptr (右值引用)

unique_ptr<int> clone() {
  return unique_ptr<int>(new int(6));
}

unique_ptr<int> clone(int i) {
  unique_ptr<int> ret(new int(i));
  return ret;
}

自定义删除器

shared_ptr与unique_ptr默认使用delete释放对象内存, 也可以在泛型参数第二个参数中传入自定义的删除器(指定类型的可调用对象)

void f(destination& d) {
  connection c = connect(&d);
  unique_ptr<connection, decltype(end_connection)*> p(&c, end_connection);
  // 当f退出时, 无论是否抛出异常, connection都会正确关闭
}

weak_ptr

weak_ptr不控制对象生命周期, 它指向一个shared_ptr管理的对象, weak_ptr绑定到shared_ptr不改变引用计数

weak_ptr<T> w;
w = p; // p可以是shared_ptr, 可以是weak_ptr, 赋值后共享对象
w.reset(); // w置空
w.use_count(); // 与w共享对象的shared_ptr数量
w.expired(); // 值为: w.use_count() == 0
w.lock(); // 若w.expired()为true则返回一个空的shared_ptr, 否则返回一个指向w对象的shared_ptr

if (shared_ptr<T> np = w.lock()) { ... } // 安全, 仅当返回指针非空时才进入语句体

new 与 delete

一般来说不直接使用new和delete, 也不要混合使用new/delete与智能指针, 也尽量不要使用智能指针的get方法访问原始指针, 最好全部使用智能指针和make_shared/make_unique管理动态内存

int *pi1 = new int; // 值未定义
int *pi2 = new int(); // 值初始化为0
int *pi3 = new int(1024); // 初始化为1024
string *ps1 = new string; // 默认初始化为空字符串
string *ps2 = new string(); // 值初始化为空字符串
string *ps3 = new string(10, '9'); // 初始化为"9999999999"
vector<int> *pv = new vector<int>{0, 1, 2, 3}; // 列表初始化

auto p1 = new auto(obj); // p1指向与obj类型相同的对象, 并且该对象使用obj进行初始化
// delete 省略

int *pi1 = nullptr;
double *pd1 = new double(33);
delete pi1; // 正确, 对空指针调用delete不会有问题
delete pd1; // 正确
delete pd1; // 未定义, 释放已经释放过的内存

数组

delete释放动态数组时必须加上方括号, 如果在释放数组时忘记加上方括号, 其行为是未定义的; 同理, 在普通动态对象delete时如果加上方括号, 其行为是未定义的

int* pia = new int[dynamic_size]; // 大小可以不是常量, 但必须是整数
typedef int arrT[42]; // arrT表示42个int的数组类型
int* p = new arrT; // 等价于 int* p = new int[42];
int* pia = new int[10]; // 10个未初始化的int
int* pia = new int[10](); // 10个值为0的int
string* psa = new string[10]; // 10个空字符串, 等价于 new string[10]();
int* pia = new int[10]{0, 1, 2, 3}; // 前4个列表初始化, 后面的为0
int* psa = new string[10]{"a", "the", string(10, 'x')};

char arr[0]; // 错误: 不能定义长度为0的数组
char* cp = new char[0]; // 正确: 非空指针, 但cp指向的位置无效

delete[] pia; // 释放动态数组时必须加上方括号, 如果在释放数组时忘记加上方括号, 其行为是未定义的

智能指针管理动态数组

unique_ptr可以管理动态数组, 但是模板类型必须为带方括号的数组类型

unique_ptr<int[]> up(new int[10]()); // up指向10个值为0的int
for (size_t i = 0; i < 10; ++i) {
  up[i] = i + 1;
}
up.reset(); // 自动调用delete[]释放数组, up置空
// *(up + 3) = 9; // 错误: 智能指针不支持指针算术运算

shared_ptr与unique_ptr不同, 它不直接支持动态数组管理, 若希望shared_ptr管理动态数组, 必须提供自定义的删除器

1
2
3

// shared_ptr管理动态数组必须提供自定义删除器
shared_ptr<int> sp(new int[10](), [](int* p) { delete[] p; });
sp.reset(); // 使用我们提供的lambda释放数组, 使用delete[]

shared_ptr不直接支持动态数组, 也未定义下标运算符, 也不支持指针算术运算

若需要动态访问数组内容, 可以使用get临时获得原始指针访问

内存耗尽

1
2

int *p1 = new int; // 若分配失败, new抛出std::bad_alloc
int *p2 = new (nothrow) int; // 若分配失败, new返回空指针

第二种形式的new被称为定位new, 定位new表达式允许传递额外的参数, nothrow是一个由标准库定义的对象, bad_alloc和nothrow都定义在头文件new中

allocator 更灵活的内存管理

new/delete与allocator

new: 内存分配 + 对象构造, 组合在一起

delete: 对象析构 + 内存释放, 组合在一起

分配单个对象时, new/delete比较方便, 但是分配一大块内存, 并需要按需构造对象时, 不方便

而且没有默认构造函数的类就不能new动态分配数组

allocator类

allocator是定义在memory头文件中的模板类, 它帮助我们将内存分配和对象构造分离开

allocator<T> a; // 定义一个allocator对象, 可以为类型为T的对象分配内存
a.allocate(n); // 分配一段原始的,未构造的内存, 用于保存n个T类型的对象
a.construct(p, args); // p必须是一个T*指针, 指向一块原始内存, args被传递给T的构造函数, 在p指向的内存上构造对象
a.destroy(p); // p为T*指针, 此算法为p所指向的对象执行析构函数

// 释放从T*指针p开始的内存, 这块内存包含n个T类型对象; p必须指向allocator分配的内存,n必须是创建内存时指定的大小
// 若p指向的内存上的对象已经构造过, 那么必须对应调用destroy进行析构后才可以释放内存
a.deallocate(p, n);

使用未初始化的内存是未定义行为

allocator<string> alloc;
auto const p = alloc.allocate(n);
auto q = p; // 指向最后构造的元素之后的位置
alloc.construct(q++); // 构造空字符串
alloc.construct(q++, 10, 'c'); // 构造10个c组成的字符串
alloc.construct(q++, "hi"); // 构造指定初始化的字符串

cout << *p << endl; // 正确
// cout << *q << endl; // 错误: 使用未初始化的内存是未定义的

while (q != p) {
  alloc.destroy(--q); // 析构真正构造的string
}

// 析构完成后可以释放内存
alloc.deallocate(p, n);

memory头文件中提供了allocator的两个伴随算法, 可在未初始化内存中创建对象

uninitialized_copy(b, e, p); // 从迭代器b和e指出的输入范围中,拷贝元素到p指定的原始内存中,内存容量需要足够大
uninitialized_copy_n(b, n, p); // 从迭代器b开始拷贝n个元素到p指定的原始内存中
uninitialized_fill(b, e, t); // 在迭代器b和e指出的原始内存范围内创建对象,对象值均为t的拷贝
uninitialized_fill_n(b, n, t); // 从迭代器b指向的原始内存开始创建n个对象,对象值均为t的拷贝

auto p = alloc.allocate(vi.size() * 2); // 分配比vi大一倍的内存空间
auto q = unitialized_copy(vi.begin(), vi.end(), p); // 从p开始将vi中的对象拷贝到内存中,q指向下一块未初始化的内存
uninitialized_fill_n(q, vi.size(), 42); // 将剩余一半元素初始化为42

IO

头文件istream, ostream, iostream, sstream

cin 一个istream对象, 从标准输入读取数据
cout 一个ostream对象, 向标准输出写入数据
cerr 一个ostream对象, 用于输出程序错误消息, 写入到标准错误
getline 函数, 从一个istream对象读取一行数据, 存入指定的string对象中
stringstream 内存流

IO对象无拷贝无赋值, 不支持对应操作

条件状态

s.eof(); // 若流s的eofbit置位,返回true,表示达到文件结束
s.fail(); // 若流s的failbit或badbit置位,返回true,表示有IO操作失败或者流已崩溃
s.bad(); // 若流s的badbit置位,返回true,表示流已崩溃
s.good(); // 若流s处于有效状态,返回true
s.clear(); // 将s中所有条件状态复位,流状态设置为有效

s.clear(flags); // 复位对应标志位,flas类型为strm::iostate,strm为IO类型
s.setstate(flags); // 设置对应标志位
s.rdstate(); // 返回s当前状态位,类型为strm::iostate

不同条件位含义

strm::badbit // 系统级错误,不可恢复的错误,一般badbit置位后流无法再使用了
strm::failbit // 通常可修正,比如期望数字却读取到字母,发生读取错误,但流还可以继续使用
strm::eofbit // 若到达文件结束位置,eofbit和failbit都会被置位
strm::goodbit // 值为0表示流未发生错误,若badbit/failbit/eofbit任意一个被置位,则状态条件失败

输出缓冲

每个输出流都有一个缓冲区, 用于保存程序写入的数据, 操作系统可以通过缓冲机制将程序多个输出操作组合成单一的系统级写操作, 提升性能

我们可以通过操纵符比如endl来显式刷新缓冲区

cout << "hi" << endl; // 输出hi和换行符,刷新缓冲区
cout << "hi" << flush; // 输出hi,刷新缓冲区
cout << "hi" << ends; // 输出hi和一个空字符,刷新缓冲区

cout << unitbuf; // 所有输出操作后立即刷新,无缓冲
cout << nounitbuf; // 恢复正常缓冲模式

当缓冲打开时, 若程序崩溃, 缓冲区不会被刷新, 输出可能丢失

文件输入输出

ifstream/ofstream基本用法

ifstream in(ifile); // 构建一个ifstream并打开指定文件
ofstream out; // 文件流未与任何文件关联
out.open(ifile + ".copy"); // 打开文件

if (out) { // open可能失败,失败时failbit会置位,检查open是否成功是好习惯
}

in.close(); // 关闭文件,关闭关联文件后才可以打开新文件
in.open(iflle + "2"); // 打开新文件,一个流只能关联到一个打开的文件,若尝试重复打开,则failbit置位,不再可用

文件模式(file mode)

in // 以读方式打开
out // 以写方式打开
app // 每次写操作前均定位到文件末尾
ate // 打开文件后立即定位到文件末尾
trunc // 截断文件,写文件时每次重新创建文件,不保留原本内容
binary // 以二进制进行IO

文件模式指定有以下限制

只可以对ofstream或fstream设定out模式
只可以对ifstream或fstream设定in模式
只有out模式被设定时才可以设定trunc模式
只要trunc模式没有设定, 就可以设定app模式, 在app模式下即使没有显式设定out模式, 文件也总是以输出模式打开
默认情况下, 即使没设定trunc, 以out模式打开的文件也会被截断, 为保留文件内容, 必须同时指定app
ate和binary可用于任何类型文件流, 可与其他任意模式组合使用

不同类型文件流都有默认模式, 未显式指定时, 则使用默认模式

ifstream关联文件默认以in模式打开
ofstream关联文件默认以out模式打开, 默认会丢弃已有数据
fstream关联文件默认以in和out模式打开

// file1都会被截断
ofstream file1("file1"); // 隐含out模式,并截断
ofstream file1("file1", ofstream::out); // 隐含截断
ofstream file1("file1", ofstream::out | ofstream::trunc); // 显式截断
// file2都不会截断
ofstream file2("file2", ofstream::app); // 隐含out模式
ofstream file2("file2", ofstream::out | ofstream::app);

string流

istringstream从string读数据, ostringstream向string写数据, stringstream可以从string读写数据

sstream strm; // sstream为某一种string流类型,构造一个未绑定的string流
sstream strm(s); // strm保存string s的拷贝,此构造函数为explicit
strm.str(); // 返回strm所保存的string拷贝
strm.str(s); // 将string s拷贝到strm中

strm >> persion.name; // 流输出
strm << " " << persion.age; // 流写入

一次读取所有文件内容

针对小文件一次读取所有文件内容

方法1: 文件缓冲流读取

std::ifstream ifile(path);
if (ifile.is_open()) {
  std::stringstream ss;
  ss << ifile.rdbuf(); // 不断从缓冲流中读取数据输入ss流, 直到遇到EOF
  std::cout << ss.str() << std::endl;
}

方法2: 流迭代器 (非常现代C++的方式)

1
2

std::ifstream iflie(path);
std::string content(std::istreambuf_iterator<char>(ifile), std::istreambuf_iterator<char>());

泛型算法

lambda表达式

auto f1 = [](const string& msg) {
  cout << msg << endl;
};
// 获取lambda表达式类型
decltype(f1)

lambda的捕获

捕获主要决定了 Lambda 内部如何访问外部作用域中的变量

变量捕获是在lambda对象创建时就完成的, 如果是值捕获, 那么其拷贝的副本就是创建lambda对象时捕获的值

值捕获: [v] 或 [=]（全捕获）外部变量的值会被拷贝一份到 Lambda 对象中

lambda默认不能修改捕获的副本, 除非加上mutable关键字; Lambda 内部修改变量不会影响外部, 但是会影响下次次的lambda调用

  int val = 30;
  auto f = [val]() mutable {
    std::cout << "lambda: " << val << std::endl;
    val = 99;
    std::cout << "lambda: " << val << std::endl;
  };
  std::cout << "main: " << val << std::endl; // 30
  f(); // 30 99
  val = 111;
  std::cout << "main: " << val << std::endl; // 111
  f(); // 99 99
  std::cout << "main: " << val << std::endl; // 111

引用捕获: [&v] 或 [&]（全捕获）外部变量改变时, Lambda 内部看到的是最新值；内部修改也会直接反映到外部

使用引用捕获时一定要注意: lambda对象的生命周期必须不超过捕获的局部变量

  int val = 30;
  auto f = [&val]() mutable {
    std::cout << "lambda: " << val << std::endl;
    val += 1;
    std::cout << "lambda: " << val << std::endl;
  };
  std::cout << "main: " << val << std::endl; // 30
  f(); // 30 31
  std::cout << "main: " << val << std::endl; // 31
  val = 111;
  std::cout << "main: " << val << std::endl; // 111
  f(); // 111 112

混合捕获: 指定默认的全捕获方式, 对特例变量特别处理

int a = 1, b = 2;
// 默认引用捕获, 但 a 使用值捕获
auto lambda = [&, a]() {
    // b 可以修改, a 不可以
};

this捕获: [this] 捕获当前对象的指针在类成员函数中使用 Lambda 时, 需要捕获 this 指针才能访问成员变量或成员函数

初始化捕获(C++14): 允许在捕获列表中定义新变量, 甚至可以使用 std::move, 对于只能移动的对象(std::unique_ptr)非常有用

auto ptr = std::make_unique<int>(100);
// 将外部 ptr 移动到 Lambda 内部的新变量 p 中
auto lambda = [p = std::move(ptr)]() {
    std::cout << *p;
};

algorithm & numeric

大多数算法定义在algorithm头文件中, numeric头文件中还定义了一些数值泛型算法

// find 查找std::vector<int>中的值
auto result = find(vec.cbegin(), vec.cend(), 42);
if (result == vec.cend()) // 未找到

// string list查找
auto result = find(lst.cbegin(), lst.cend(), std::string("a value"));

// 数组查找
int ia[] = {27, 210, 12, 47, 109, 83};
int val = 83;
int* result = find(begin(ia), end(ia), val); // 使用标准库中的begin和end获得数组的首元素指针和尾后指针(迭代器)
int* result = find(ia + 1, ia + 4, val); // 在ia[1]到ia[4]之间查找, 包括ia[1], 不包括ia[4]

只读算法

accumulate

// numeric中提供accumulate,用于求和
int sum = accumulate(vec.cbegin(), vec.cend(), 0); // 求和,初始值为0
string sum = accumulate(v.cbegin(), vec.cend(), string("")); // 第三个参数必须为string, 不能是const char*, 因为const char*没有对应的+运算符

// 只要可以用==来比较元素即可,roster1可以是vector<string>,roster2可以是list<const char*>
// equal假定第二个序列至少与第一个序列一样长,否测产生错误
bool result = equal(roster1.cbegin(), roster1.cend(), roster2.cbegin());

写容器元素

fill

1
2
3

fill(vec.begin(), vec.end(), 0); // 将vec所有元素填充为0
fill(vec.begin(), vec.begin() + vec.size() / 2, 10); // 将容器一个子序列填充为10
fill_n(vec.begin(), n, val); // 从vec.begin()开始,将n个元素设置为val,fill_n假定写入的元素是安全的

千万不要在空容器上调用fill_n, 函数会假定空间是安全的, 否则是未定义行为

可以使用insert iterator, 比如back_inserter, 通过迭代器向元素赋值, 元素将被添加到容器中

vector<int> vec; // 空容器
auto it = back_inserter(vec);
*it = 42; // 元素将被插入到容器中
*it = 33; // 元素继续插入到容器

vector<int> vec; // 空容器
fill_n(back_inserter(vec), 10, 0); // 添加10个元素到vec

copy

int a1[] = {0, 1, 2, 3, 4, 5};
int a2[sizeof(a1)/sizeof(*a1)]; // a2大小与a1一致
// ret指向拷贝到a2尾元素之后的位置
auto ret = copy(begin(a1), end(a1), a2); // 把a1的内容拷贝给a2

replace

1
2

replace(ilst.begin(), ilst.end(), 0, 33); //将ilst中所有的0元素修改为33
replace_copy(ilst.cbegin(), ilst.cend(), back_inserter(ivec), 0, 33); // ilst元素保持不变,替换后的序列填充到ivec

重排容器元素

sort(words.begin(), words.end()); // 按字典序排序words中的单词, 以便查找重复单词
// unique 重排输入范围,使得每个单词只出现一次,调用unique之前需要保证有序
// 不重复范围在前,返回指向不重复区域之后一个位置的迭代器
auto end_unique = unique(words.begin(), words.end());
// 删除重复单词
words.erase(end_unique, words.end());

算法在比较元素时默认使用<和==运算符, sort使用元素类型默认的<运算符, 比较运算可自定义

bool is_shorter(const string& s1, const string& s2) {
  return s1.size() < s2.size();
}

// 按照字符串长度由短到长排序
sort(words.begin(), words.end(), is_shorter);

// 按照长度由短到长排序,长度相同的字符串保持原有顺序
stable_sort(words.begin(), words.end(), is_shorter);

// 也可以使用lambda表达式
stable_sort(words.begin(), words.end(), [](const string& s1, const string& s2) { return a.size() < b.size() });

查找与遍历

find_if

`1`	`auto wc = find_if(words.begin(), words.end(), [sz](const string& a) { return a.size() >= sz; });`

可变参数模板

可变参数函数模板

// Args是一个模板参数包; rest是一个函数参数包
// Args表示0个或者多个模板类型参数
// rest表示0个或者多个函数参数
template<typename T, typename... Args>
void foo(const T& t, const Args& ... rest);

foo("hi"); // 空包
foo(s, 42, "hi"); // 包中包含2个参数

编译器从函数的实参推断模板参数类型和数量, 之后为模板函数实例化多个不同的版本 (不同参数类型数量组合)

sizeof...运算符获取包中的元素个数

template<typename ... Args> void g(Args ... args) {
  cout << sizeof...(Args) << endl; // 类型参数数目
  cout << sizeof...(args) << endl; // 函数参数数目
}

可变参函数的递归

可变参函数通常是递归的

// 用来终止递归并打印最后一个元素
// 此函数必须在可变参数版本之前定义
template<typename T>
ostream& print(ostream& os, const T& t) {
  return os << t << endl;
}
// 包中除了最后一个元素外的其他元素都会调用可变参数版本
template<typename T, typename ... Args>
ostream& print(ostream& os, const T& t, const Args& ... rest) {
  os << t << ", "; // 打印第一个实参
  return print(os, rest...); // 递归调用, 打印其他实参
}

print(std::cout, 1, 2, 3, "hi");

编译器会自动实现print的多个变种版本

包扩展

template<typename ... Args>
ostream& error_msg(ostream& os, const Args& ... rest) {
  // 相当于对包中每个参数调用debug_rep之后作为新的参数传入print中
  // print(os, debug_rep(rest1), debug_rep(rest2), debug_rep(rest3));
  return print(os, debug_rep(rest)...);
}

// 如果写成 debug_rep(rest...)
// 则相当于调用 debug_rep(rest1, rest2, rest3)

包参数转发

class StrVec {
public:
  template<typename ... Args> void emplace_back(Args&&...);
};

template<typename ... Args>
void StrVec::emplace_back(Args&& ... args) {
  // 使用allocator处理内存空间分配
  alloc.construct(first_free++, std::forward<Args>(args)...);
}

这里的传入参数是&&万能引用, 为了保证右值向下传递时保持右值, 我们使用std::forward进行转发

而std::forward<Args>(args)...会同时对Args和args进行扩展, 得到类似如下的形式

`1`	`alloc.construct(first_free++, std::forward<int>(10), std::forward<std::string>(s));`

总结

本文梳理了C++11现代化编程的部分内容, 这是我自己觉得重要的基础内容, 弄懂了上面这些内容再去查看STL中的容器, 或者了解智能指针的行为, 就相对简单很多了

关于容器, 智能指针, 泛型算法等, 文中没有全面说明的内容, 都可以去查阅对应的文档 (https://cppreference.com)

C++11还新增了线程std::thread, 时间std::chrono, 正则std::regex, 迭代器, 随机数等内容, 这篇文章尚未提及, 都是非常有用的工具

IEEE 浮点数结构

Sun, 25 Jan 2026 00:00:00 +0000

浮点数在内存中的存储结构

基础概念

十进制整数转二进制为除 2 取余, 逆序排列
十进制小数转二进制为乘 2 取整, 顺序排列
二进制转十进制是每位加权求和

$$ 11.1101_2=1\times2^1+1\times2^0+1\times2^{-1}+1\times2^{-2}+0\times2^{-3}+1\times2^{-4} $$

n 进制的科学计数法 $a*n^b$ ($0<|a|<n$) 其中 a 和 b 都是 n 进制数字, 类比十进制, b 表示 n 进制指数 (小数点移动的位数)

例: 二进制 $10000_2=1*2^{100_2}$, 指数相当于十进制的 4, 也就是小数点向右移动 4 位

浮点数国际标准 IEEE 754

国际标准 IEEE 754 标准使用一个三元组 ${S, E, M}$ 表示一个浮点数N

S 符号位, 0 和 1 分别表示正和负
E 阶码, 用移码表示
M 尾码, 按照 IEEE 754 标准存储浮点数需要先规格化, 最后的尾码一定是 $(1.xxxxx)_2$ 的二进制格式, 第一位一定是1, 因此尾码存储时舍去了第1位的1, 只保存了二进制小数部分, 这样可以多表示一位

浮点数的规格化

同一个浮点数的表示规格并不统一, 比如 $(1.11)_2\times 2^0 = (0.111)_2\times 2^1 = (0.0111)_2\times 2^2$.

为了数据的表示精度, 就必须充分利用尾码的有效位数, IEEE 754 标准中当尾码大小不是 $(1.xxxx)_2$ 格式时就左右移动小数点并同时修改阶码大小, 直到达到要求, 该过程称为浮点数规格化

浮点数的表示

浮点数中的指数 e 可能有正有负, 为了方便表示, 将 e 增加一个固定的偏移量得到移码 E 作为阶码

移码 E 在浮点数中是一段二进制的无符号整数, 依据二进制位计算出 E 的值再去掉固定偏移量, 即可得到指数 e 的值

平常使用最多的是单精度(32位)和双精度(64位)浮点数, 尾码部分默认小数点前的一位1省去了, 后面不再赘述

单精度浮点数

符号位(S) 1位, 阶码(E) 8位, 尾码(M) 23位

其中阶码偏移量为 127 (0x7F), 尾码仅表示小数部分, 前面的1和小数点省略

真值表示: $X=(-1)^S\times (1.M) \times 2^{E - 127}$ $e=E-127$

由于 $2^{23}=8388608$ 最大可表示精度为 7 位, 但不能表示所有的 7 位数, 可保证 6 位精度

双精度浮点数

符号位(S) 1位, 阶码(E) 11位, 尾码(M) 52位

其中阶码偏移量为 1023 (0x3FF), 尾码仅表示小数部分, 前面的1和小数点省略

真值表示: $X=(-1)^S\times (1.M) \times 2^{E - 1023}$ $e=E-1023$

由于 $2^{52}=4503599627370496$ 最大表示精度为 16 位, 不能表示所有 16 位数字, 保证精度为 15 位

特殊值

在特殊情况下, 浮点数的计算不再按照常规的方式计算, 而是直接表示特殊的真值, 以下对于单精度和双精度都一样

真值0: 当阶码E全0, 且尾数M全0时, 表示真值X为0, 由于符号位不同, 所以有正负0两种表示
无穷大: 当阶码E全1, 且尾码M全0时, 表示真值为无穷大, 符号位不同可以表示正负无穷大
NaN: 当阶码全1, 且尾码M非全0时, 全都表示NaN, NaN没有正负之分, 符号位0或1都是NaN

因为特殊值的存在, 所以浮点数在表示一般的数值时, 其实阶码E可用的范围需要去掉全0和全1的特殊情况, 在单精度浮点数中, 也就意味着E的取值范围是 [1, 254], 对应的指数 e 取值范围是 [-126, 127], 因此单精度浮点数表示范围为

$$ (-1)^1 \times (1.M_{max}) \times 2^{127} \approx -3.4028235 \times 10 ^ {38} $$

到

$$ (-1)^0 \times (1.M_{max}) \times 2^{127} \approx 3.4028235 \times 10 ^ {38} $$

在取最大/最小值时, 仅符号位不同, 尾码M为23位全1, 指数取最大127

当浮点数的绝对值非常小, 非常接近0, 连阶码取最小值都无法表达时, IEEE 754 允许它进入非规格化状态, 此时 $E = 0$, 并且默认隐含的最高位 1 变成了 0, 指数被固定为 -126, 此时的真值计算

$$ X = (-1)^S \times (0 + M) \times 2^{-126} $$

当 $E = 0$ 且 $M \neq 0$ 时, 则浮点数为非规格化表达, 默认隐含最高位为0

编码测试

编写一个函数, 用于将数值以二进制打印

const std = @import("std");

fn printBits(value: anytype) void {
    const T = @TypeOf(value);
    const bit_width = @bitSizeOf(T);
    const UnsignedT = std.meta.Int(.unsigned, bit_width);
    const bits: UnsignedT = @bitCast(value);
    std.debug.print("{d:<5} {s:<5}: ", .{ value, @typeName(T) });
    var i: usize = 0;
    while (i < bit_width) : (i += 1) {
        const ShiftType = std.math.Log2Int(UnsignedT);
        const shift_amt = @as(ShiftType, @intCast(bit_width - 1 - i));
        const bit = (bits >> shift_amt) & 1;
        std.debug.print("{d}", .{bit});
        // 每8位打印一个空格 (除了最后一位)
        if ((i + 1) % 8 == 0 and (i + 1) < bit_width) {
            std.debug.print(" ", .{});
        }
    }
    std.debug.print("\n", .{});
}

先看一下1.0的结果 printBits(@as(f32, 1.0))

输出为 1 f32 : 00111111 10000000 00000000 00000000

其中S=0, $E=(01111111)_2=127$, M=0

也就是 $1.0=(-1)^S\times (1.M) \times 2^{E-127}=1\times 1.0 \times 2^0$

再试试0.5, printBits(@as(f32, 0.5))

输出为 0.5 f32 : 00111111 00000000 00000000 00000000 与1.0的区别仅仅是阶码小了1

真值计算 $0.5=(-1)^(0)\times (1.0) \times 2^{126-127}=1\times 1.0 \times 2^{-1}$

用源码验证一下所有特殊值是否如我们所想

pub fn main() void {
    printBits(@as(f32, 0.0));
    printBits(-@as(f32, 0.0));
    printBits(@as(f32, 1.0));
    printBits(@as(f32, 0.5));
    const inf = std.math.inf(f32);
    printBits(inf);
    printBits(-std.math.inf(f32));
    printBits(std.math.nan(f32));
    printBits(-std.math.nan(f32));
    var nan_test = std.math.nan(f32);
    var nan_u32: u32 = @bitCast(nan_test);
    nan_u32 = (nan_u32 | (1 << 3));
    nan_test = @bitCast(nan_u32);
    printBits(nan_test);

    var inf_test: u32 = @bitCast(inf); // inf 按位转换为 u32, 方便位处理
    inf_test = (inf_test | (1 << 3));
    const value: f32 = @bitCast(inf_test); // 位处理之后转换回 f32
    printBits(value);
}

输出结果如下

0     f32  : 00000000 00000000 00000000 00000000
-0    f32  : 10000000 00000000 00000000 00000000
1     f32  : 00111111 10000000 00000000 00000000
0.5   f32  : 00111111 00000000 00000000 00000000
inf   f32  : 01111111 10000000 00000000 00000000
-inf  f32  : 11111111 10000000 00000000 00000000
nan   f32  : 01111111 11000000 00000000 00000000
-nan  f32  : 11111111 11000000 00000000 00000000
nan   f32  : 01111111 11000000 00000000 00001000
nan   f32  : 01111111 10000000 00000000 00001000

可以发现, 无穷大的阶码全1, 尾码全0, 改变符号位可得到正/负无穷大

NaN阶码全1, 尾码非0, 改变符号位依然是NaN

在NaN的基础上将尾码稍加改动, 只要不改为全0, 都是NaN (倒数第2行输出)

在无穷大的基础上, 将尾码倒数第4位(随机一位)设置为1, 输出为NaN, 符合预期 (最后一行输出)

归档

Tue, 28 May 2019 00:00:00 +0000

关于

Mon, 01 Jan 0001 00:00:00 +0000

一个爱折腾的技术宅垃圾佬, 像素画和2D游戏爱好者

以下是我个人技能与毕业后的社会经历

技术栈

Git 滚瓜烂熟倒背如流, 最熟悉最离不开的时光机
C/C++11 精通, 自2018年毕业至今主后端开发一直使用
Python 时常拿来用于编写易用脚本, 或者开发简单Web服务, 方便得爱不释手
Linux/Docker 最爱的东西! 经常玩NAS/捡垃圾/刷机, 随便来一个二手Android手机都能给它变成一台部署各种平台的专属服务器, Linux可太好玩了!
Godot/像素画 一直对像素风2D游戏开发感兴趣, 有时间就会学一学试一试. 而且意外发现游戏引擎才是最好的工具库, UI/纹理材质/渲染管线/动画/物理/数学计算/音频/视频/粒子特效等等, 无所不能, 而且Godot引擎本身也不太大, 直接拿来做桌面应用竟然是一个非常完美的选择
Buildroot/Yocto/嵌入式/OTA 公司嵌入式Linux缺人手, 被拉去硬顶, 期间强制学习了不少相关内容, 也算是完整跑了一遍嵌入式Linux的定制 - 交叉编译 - 烧录 - 开发板调测的全流程
AI Coding 如果说2023年的AI编程模型只能拿来做输入提示, 那么现在的AI编程可以完全当作一个开发助手了, 虽然时不时会有一些恼火的问题必须自己亲手解决, 但不可否认有了它可以极大程度的拓展能力边界. 在公司临时受命开发过两个Web应用, 我写后端, AI辅助写前端, 最后效果竟然出奇的好! 这样我也算是基于AI的全栈工程师了!
- 设备管理Web应用: 管理局域网内的设备, 支持设备列表展示(设备自动心跳上报信息), 支持设备控制(下发命令: 修改配置, 切换4G/以太网, 重启等), 支持用户鉴权/密码修改, 支持操作日志记录和展示, 基于SQLite + Mongoose (C, PReact, Tailcss)实现
- 在线OTA Web平台: 嵌入式设备信息管理, 固件包上传/下载/删除管理, 设备升级管理, 用户鉴权. 基于Python Flask + SQLite + Vue实现, Web服务实现MQTT + HTTP双协议, 设备通过MQTT定期上报状态信息, 服务将设备信息维护在数据库表中. 升级时服务向指定设备下发MQTT消息, 包含固件包下载URL, URL中包含token参数, 指定时间/使用次数内有效, 服务同时提供固件包下载HTTP服务, 在接口中获取token参数进行数据库校验, 校验通过则返回文件
Lua/C#/Web 以前有使用, 但时间久远, 捡起来需要再熟悉熟悉
Rust/Zig 现代化的C++/C语言, 保证性能的同时, 更安全, 抽象程度更高, 使用更简单, 值得关注和学习

经历

2018年毕业至今一直待在杭州, 主后端开发, 但也会参与到前端和其余领域的开发工作

初入社会, 加入棋牌游戏公司 (2018.07 - 2019.12)

第一家公司主营棋牌游戏, 入职时大约700人, 我是后端开发, C++游戏服务器, Cocos2D/Lua手机客户端, 维护游戏服务正常运行, 游戏活动功能开发, 在此期间使用过MySQL数据库, Redis热点数据缓存, RabbitMQ消息队列

离职前政策变更, 部分游戏玩法被定义为"协助赌博", 有一些管理/策划被关小黑屋, 公司分离风险业务到子公司, 给很多同事选择, 要么到子公司工作, 要么离职. 我觉得自己还年轻风险太大, 选择了离职并回了老家湖北一趟, 结果恰好碰到疫情封控, 直接在老家被封了好几个月

尝试去喜欢的游戏公司 (2020.04 - 2020.05)

封控到2020年4月中旬已经陆陆续续开放, 回到杭州的我感觉既熟悉又陌生, 我喜欢玩游戏, 对游戏开发也很感兴趣, 想着找一家游戏公司, 最好产品是ARPG/策略/MMO/沙盒类型游戏的, 一方面自己比较喜欢这类, 一方面不想再接触棋牌类游戏(怕有风险).

但事实是残酷的, 精心筛选的游戏公司, 大大小小都试过投递, 很多简历都石沉大海, 连什么原因被拒都不知道.

后面自己猜测可能经历不符合, 棋牌游戏使用的技术和其他类型游戏还是有很大区别的, 看到很多游戏公司都要求会Unity引擎, 但是我都没有摸过, 我花了一段时间边学习边实践, 用Unity复刻了一个复古的Tank2D游戏, 之后融入自己对网络知识的理解, 加入了本地网络多人游戏支持, 加入了Android+PC版本支持, 移动端自动展示虚拟摇杆和操控按钮, PC端则使用键盘+鼠标操控, 并且支持移动端与PC端联机.

虽然只有几个关卡, 可能还有Bug, 但是还比较有成就感, UI/关卡生成/玩家控制/敌人生成/简单敌人AI/碰撞检测/道具生成/关卡结算/动画/音效等, 各方面内容均有实际编码成果.

但是在简历上加上这个花了一个月时间完成的项目后, 也并未带来多少改观, 现实是冰冷的, 生活开支压力加上找工作的挫折, 让我深感沮丧和焦虑.

我修改简历和求职信息, 全部改为C++后端开发, 还没开始投递多少公司, 立即就收到了多个面试邀约和猎头推荐, 我不知道是否应该开心.

加入稍大的公司, 在稳定的工作中焦虑和自我怀疑 (2020.06 - 2022.09)

第二家公司做工业自动化, 四千多人的企业, 我进的虚拟软件部, C++后端服务器, C#(WPF)前端PC客户端, 主要做各种化工设备的模拟/工况模拟/数据对点, 做过对点服务器的功能开发和性能优化, 易用性工具开发(一键启动, 一键备份/还原)方便规模化部署, 用于演示和教学

在这家公司做的工作比较杂, 但比较平稳. 除了主要的C++服务开发维护, 还需要开发各种应对特定项目的定制工具, 客户现场情况各不相同, 有一些出差, 设备模拟器代码有上古遗留, 里面写死一堆的十六进制魔法数字完全不敢动

公司是按年份晋升的制度, 一个萝卜一个坑, 能力业绩再好, 也还得年份足够高. 当时的我觉得这非常离谱, 在这种制度下, 作为新来的年轻人, 不管我怎样努力奋斗学习提升, 向继续上升都是熬时间, 这不是让人失去冲劲了吗? 但后来意识到, 这也算是一种多相对公平的制度, 至少它一视同仁, 而且给了能力一般的同事上升的机会. 并不是每个人都适合开发, 有的同事还面临巨大的家庭压力, 没有多少精力去学习深造, 在这里待着能完成任务, 还能得到上升机会, 也挺好. 如果觉得自己学习能力比较好, 还有很高可塑性, 那就不应该待在这里消磨时间.

失败的考研尝试 (2022.09 - 2023.04)

我在纠结中选择了辞职考研, 一直觉得自己学习新知识挺快的, 或许我更适合学术路线, 去做一些前沿的算法研究, 认认真真准备了半年, 考试之前学校通知参加考试必须有3天以内的核酸检测阴性证明, 考试两天去做核酸检测, 结果当天就被感染阳了, 明显感到不适, 第二天高烧头晕呕吐下不了床, 躺了一个星期.

翻看自己的学习笔记, 觉得像是命运的玩笑.

学术之路在毕业那一刻就已经结束, 现在已经是这样的现状, 再纠结下去也只是浪费时间, 这段时间就当自己复习了以前的基础课程, 特别是数学知识, 也不是完全浪费时间.

收拾好心情就应该继续出发, 既然不喜欢大公司的稳定, 或许我应该找一个小一点的地方, 做更考验能力的事情, 得到更多的锻炼, 获取更多的机会.

“小公司机会多”, 我带着这样的想法去了第三家公司.

低空经济小公司 (2023.05 - 2026.01)

初入公司

这是一个50人的小公司, 所在领域是低空安全, 主要研究无人机反制技术, 在无人机技术发展迅速的今天, 这毫无疑问是一个新兴领域, 刚刚起步大家都在摸索的方向, 来试一试吧!

刚入公司时, 觉得这个新型的技术方向很不错, 面试时说"年终奖依据公司业绩决定", 我也只是稍稍犹豫就答应了, 一方面对自己的技术能力有信心, 一方面觉得这个方向也应该是蒸蒸日上, 日子会越来越好的.

努力工作期望回报

我施展浑身解数, 能力尽显, 仅用两周熟悉公司业务逻辑和源码框架并参与正式开发任务, 学会飞无人机, 学会调测公司设备, 入职一个月就出差项目现场, 负责项目实施落地

入职半年, 深入理解各设备工作方式和协同工作原理, 重构软件平台核心系统模块, 总结封装常用的系统策略, 让软件平台从过去的"配置/参数调整"的工作模式升级为可以通过简单切换系统策略一键配置好预定的工作参数和逻辑, 不仅方便使用, 更避免了配置与参数的错误配套. 改动比较大, 好在测试时没有大问题, 自此该特性分支成为主分支, 其余的所有功能/定制均基于此分支

之后对系统中诸多问题进行了修复和优化, 包括频率单位的统一, 底层工具库/网络库中的大小问题修复, 内存泄露/栈内存破坏等排查, 忙标记错误修复等

公司领导对我的工作给予了认可和表扬, 但仅此而已, 精神鼓励固然鼓舞人心, 但是对于一个缺钱的年轻人来说, 只有精神慰藉难以维持持久的动力

消失的年终奖一票否决的调薪

2023年结束, 第一年的我问心无愧. 年终会议上, 老板很高兴, 说今年的合同额远超去年, 让各部门主管猜测今年业绩相比去年提升多少, “猜错了, 是去年的10倍!”, 能看得出来老板真的很开心, 大家都很开心, 有同事已经在讨论今年年终奖会不会是一辆车了

结果年会开完了, 春节放假了, 大家依然没有看到任何年终奖的通知, 大家忍不住去问情况, “合同额大, 款没收上来”, “研发投入大”, “以后会有的”, 员工无法获取公司真实财务状况, 这些话语就想万用理由, 不知道真假也无法反驳, 业绩翻10倍, 但没有年终奖

想着没有年终奖, 我应该至少去争取个调薪, 开年来我尝试去提调薪请求, 第一次提大概是2-3月, 领导(部门主管)对我的工作和能力表达了肯定, 然后说我入职还不满1年, 满1年了可以再提调薪; 我等到5月, 入职的时间, 第二次提出请求, 领导告诉我, 一般公司涨薪申请集中在7月处理, 已经5月这个时间了, 可以再等等, 7月再提; 等到7月, 第三次提请求, 领导同意了, 让我写申请, 走流程, 我很开心, 去准备了材料, 领导说他帮忙提交了流程(我不可见), 让我等一个月. 到8月, 问了下情况说还没处理完, 到9月又问了下, 被告知"流程都走完了, 被老板一票否决了", 我希望要一个说法, HR过来回应我了, 上来就是官话套话, “你凭什么说你觉得自己能力好”/“你说做出了业绩, 那它在公司实际的那些项目中有什么具体的体现”, 部门主管看出我情绪不对, 帮我解围, 说我工作确实还行的, HR立马换了说辞, “哦, 是这样啊, 现在的调薪窗口关闭了, 没说什么时候再开放”, “大家来这里都是看中行业未来发展潜力, 等这个行业发展起来, 福利待遇自然都会好起来, 不用在乎这短期的得失”, 后面还说的什么我已经不太记得

不争气的眼泪思想的觉悟

我知道自己不擅长表达, 不太会应对这些说辞, 我点点头之后回去工位了, 回想一下忽然很想哭, 捏拳努力控制, 还是流下不争气的眼泪, 我慌乱的擦干净, 假装眼睛有沙子不舒服, 生怕被人发现

大概是心里有些冷, 我不再像以前一样充满工作动力, 在那之后我非常想离职, 我家人劝我不要轻易变动, 现在的经济形势非常严峻, 我想了想, 假如离职, 我也不知道接下来应该去哪里, 从棋牌游戏到工业自动化再到低空安全, 我的简历是一张大花脸, 不同的色块组合再一起, 像个小丑

接下来在这里我见识到了更多的令我惊叹的事情: 第二年没有年终奖在意料之中, 公司发通知春节假后准时上班的同事有惊喜, 以为是开工红包, 和家人打赌不超过50, 我按时去了, 但是看到门口桌子上摆放的牛奶和面包, 然后看到群通知"公司为准时上班的同事准备了营养早餐, 分量有限, 先到先得", 笑饱了, 没有去领, 公司一共才50人; 中秋节到了, 我猜测公司不会发月饼了, 没想到又猜错了, 公司将供应商拿来的盒装月饼拆散了放在桌子上, 群通知"分量有限, 先到先得", 月饼袋子上的别家公司商标真刺眼; 有同事的劳动合同到期了, 被直接告知不用来上班了, 没有任何商量. 他继续来打卡, 公司将他从打卡机系统删除了. 他拍照留证, 咨询律师, 找HR谈判, 公司又想给他放无薪假, “为方便您找到新工作, 公司特许20天无薪假”. 后面还有很多操作, 像把竞业协议揉进保密协议中要求签署, 不同意赔偿已经经过劳动局认定的工伤赔偿等等.

忽然间我有些不想找工作了, 以前一直想着换工作换公司, 但是看了这家公司的操作之后, 有些失望的明悟 – 寄人篱下, 就必须入乡随俗. 看不惯这家公司的风俗习惯, 换一家公司也还是可能碰到同样的情况. 可能还是存在氛围和福利都不错的公司, 但是不知道怎么去找, 而且自己的大花脸简历又不知道怎么拿得出手. “工作是穷人的选择, 打工工作也就是比破产强点而已”, 在这里让我厌倦了打工, 原本极度想离职换工作的心也瞬间稳下来了, 或许我应该想办法展现自己, 表达自己, 多看看别的出路

总结

写到这里, 发现自己的语言里对现在的公司有很多不满, 不知不觉写了那么一堆, 字里行间充满嘲讽和戾气, 这是不对的, 哈哈哈, 自己读一遍有点好笑, 真不应该这样, 无论经历怎样路都是自己选的, 人不可以一边走自己选的路一边不停抱怨这个路怎样怎样不好走, 不删了就留着吧, 还可以加一个分段标题, 有一点"莫欺少年穷, 莫欺中年穷"的那味了, 放这里告诫自己

要么适应环境, 要么改变环境, 如果都不能, 那就换一个环境. 抱怨并不能有任何改变, 而且抱怨的背后是服从, 越是抱怨的凶, 越是严格的服从. 对现状不满, 那就努力提升自己, 不管是想做游戏还是想做自媒体, 都尽早行动起来, 只想不做都是问题, 做起来才有答案!

愿自己多一些行动和实践, 少一些埋怨和拖延, 早点找到属于自己的道! 与君共勉!

搜索