李慕然的一天

C++ 20 jthread 使用与底层设计实现

Wed, 28 Jan 2026 21:56:27 +0800

C++20 引入的 std::jthread 是对原 std::thread 的一次升级。

它的出现主要为了解决 std::thread 的两个痛点：

没有 RAII：std::thread 在析构时如果仍然是 joinable 的（即没调用 join() 或 detach()），会直接导致程序崩溃（调用 std::terminate）。
缺乏线程停止机制：在 C++20 之前，要让一个线程中途停止，通常需要自己手动实现。

`std::jthread` 的核心特性

std::jthread 遵循 RAII 原则。当 std::jthread 对象离开作用域时，其析构函数会自动做两件事：

调用 request_stop()（请求停止线程）。
调用 join()（等待线程结束）。

std::jthread 支持向线程函数传递一个 std::stop_token，线程函数内部可以通过这个 token 检查是否收到了停止请求。

示例

 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


#include <iostream>
#include <thread>
#include <chrono>

using namespace std::chrono_literals;

// 线程函数接收 stop_token 作为第一个参数
void worker(std::stop_token st, int id) {
 while (!st.stop_requested()) { // 检查是否有人要求停止
 std::cout << "Worker " << id << " is running...\n";
 std::this_thread::sleep_for(1s);
 }
 std::cout << "Worker " << id << " received stop signal, exiting.\n";
}

int main() {
 std::jthread t(worker, 1);

 std::this_thread::sleep_for(3s);

 // 显式请求停止（可选，因为析构函数也会自动调用）
 // t.request_stop();

 std::cout << "Main thread leaving scope...\n";
 // t 离开作用域：
 // 1. t.request_stop() 被调用
 // 2. t.join() 被调用，主线程在此等待 worker 结束
}

使用自己的 stop_source：

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


void worker(std::stop_token st, int id) {
 while (!st.stop_requested()) {
 std::cout << "Worker " << id << " is running...\n";
 std::this_thread::sleep_for(200ms);
 }
 std::cout << "Worker " << id << " received stop signal, exiting.\n";
}

int main() {
 // 1. 创建一个独立的停止源
 std::stop_source my_source;

 // 2. 获取 token
 std::stop_token my_token = my_source.get_token();
 // 3. 启动线程，传入自己的 token
 // 注意：这里没有使用 jthread 自动生成的 token，而是传了自己的
 std::jthread t(worker, my_token, 1);

 std::this_thread::sleep_for(1s);
 std::cout << "Main: Stopping via external source...\n";
 // 4. 通过外部源停止线程
 my_source.request_stop();
}

[!NOTE]

示例一使用的是 jthread 自身内部的 stop_source，所以调用 jthread.request_stop() 停止，而示例二是采用的外部传入的 stop_source，调用 jthread.request_stop() 是无法成功停止的，因为不是同一个 stop_token ，需要使用 stop_source.request_stop()

取消多个线程：

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


void worker(std::stop_token st, int id) {
 while (!st.stop_requested()) {
 std::cout << "Worker " << id << " is running...\n";
 std::this_thread::sleep_for(200ms);
 }
 std::cout << "Worker " << id << " received stop signal, exiting.\n";
}

int main() {
 std::stop_source my_source;
 std::stop_token my_token = my_source.get_token();

 std::jthread t1(worker, my_token, 1);
 std::jthread t2(worker, my_token, 2);

 std::this_thread::sleep_for(1s);
 std::cout << "Main: Stopping via external source...\n";
 // 停止所有线程
 my_source.request_stop();
}

stop_callback 使用：

 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


int main() {
 std::jthread t([](std::stop_token st) {
 // 注册一个回调：一旦有人请求停止，会立即在发出停止信号的线程中执行回调
 std::stop_callback cb(st, []{
 std::cout << "Callback: Stop requested!\n";
 });

 // 模拟一个耗时操作
 for (int i = 0; i < 10; ++i) {
 if (st.stop_requested()) break;

 std::cout << "Thread: Processing " << i << "...\n";
 std::this_thread::sleep_for(200ms);
 }
 });
 std::this_thread::sleep_for(600ms);
 std::cout << "Main: Requesting stop!\n";
 t.request_stop(); // 此时会触发子线程内部注册的回调

 std::cout << "Main thread: " << std::this_thread::get_id() << "\n";
 // 在构造函数注册之前已经请求了停止，则回调函数将在构造的当前线程中被立即调用。
 std::stop_callback callback_after_stop(t.get_stop_token(), [] {
 std::cout << "Stop callback executed by thread: "
 << std::this_thread::get_id() << '\n';
 });
}

底层原理

std::jthread 的停止机制基于一套**共享状态（Shared State）**模型实现的。这套机制由三个核心组件构成：

std::stop_source：停止信号的发出者（遥控器）。
std::stop_token：停止信号的接收者/观察者（信号灯）。
std::stop_callback：停止信号发出时的回调注册者。

std::stop_source

作用：用于发起停止请求。
原理：它持有一个指向共享状态的引用。当调用 request_stop() 时，它会触发所有注册的回调函数。
在 jthread 中：std::jthread 内部包含一个 std::stop_source 成员变量。

std::stop_token

作用：用于查询停止状态。
原理：它也持有指向同一个共享状态的引用，但它只有读权限。
API：
- stop_requested(): 检查共享状态中的值是否为 true。
- stop_possible(): 检查是否还有关联的 stop_source 存在（如果源头都销毁了，就不可能停止了）。
在 jthread 中：当 jthread 启动线程时，它会从内部的 stop_source 生成一个 stop_token (source.get_token()) 并传递给线程函数。

std::stop_callback

作用：收到停止信号时执行的回调。
原理：这是一个 RAII 对象。它为关联的 std::stop_token 对象注册一个回调函数，当 std::stop_token 的关联 std::stop_source 请求停止时，将调用该回调函数。

架构图解

可以将它们的关系想象成 std::shared_ptr。它们都指向堆上的同一个控制块（Control Block）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


[ std::jthread / std::stop_source ] [ std::stop_token ]
 | |
 | (拥有) | (观察)
 v v
 +-------------------------------------------------------+
 | Shared Stop State (堆内存) |
 |-------------------------------------------------------|
 | 1. Atomic Bool: stop_requested (是否已请求停止) |
 | 2. Thread ID: requester_id (谁请求的) |
 | 3. Callback List: 注册的 stop_callback 链表 |
 +-------------------------------------------------------+

[!NOTE] 仅供理解，实际有差异。

`std::jthread` 内部实现逻辑

std::jthread 的简化版源码：

 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


class jthread {
private:
 thread _thread; // 底层的 thread
 stop_source _ssource; // 控制停止的stop_source

public:
 // 构造函数
 template <class _Fn, class... _Args>
 requires (!is_same_v<remove_cvref_t<_Fn>, jthread>)
 explicit jthread(_Fn&& func, _Args&&... args) {
 // 1. 检查 func 是否接受 stop_token 作为第一个参数调用
 if constexpr (is_invocable_v<decay_t<_Fn>, stop_token, decay_t<_Args>...>) {
 // 2. 接受，从 source 获取 token 并传递进去
 _thread._Start(_STD forward<_Fn>(func), _ssource.get_token(), _STD forward<_Args>(args)...);
 } else {
 // 3. 不接受，以普通 thread 启动
 _thread._Start(_STD forward<_Fn>(func), _STD forward<_Args>(args)...);
 }
 }

 // 获取内部的 stop_source
 std::stop_source get_stop_source() noexcept {
 return _ssource;
 }

 // 获取对应的 token
 std::stop_token get_stop_token() noexcept {
 return _ssource.get_token();
 }

 // 请求停止
 bool request_stop() noexcept {
 return _ssource.request_stop();
 }

 ~jthread() {
 if (_thread.joinable()) {
 request_stop(); // A. 先请求停止
 _thread.join(); // B. 再等待结束
 }
 }

 // ... 移动构造、赋值等 ...
};

需要特别说明的是：

1

if constexpr (is_invocable_v<decay_t<_Fn>, stop_token, decay_t<_Args>...>)

是在判断传进来的函数 _Fn，是否可以使用指定的参数调用。

即：

1
2
3
4
5
6
7


void worker(std::stop_token st, int x) { ... }
// 判断worker()签名是否为(std::stop_token, int)
bool r = std::is_invocable_v<decltype(worker), std::stop_token, int>; // true

// 没有 stop_token的签名
void worker(int x) { ... }
bool r = std::is_invocable_v<decltype(worker), std::stop_token, int>; // false

注意 decay_t<_Args>...>，如果自己传入了 stop_token，那么展开后为：

1

std::is_invocable_v<decltype(worker), std::stop_token, std::stop_token, int>;

与 worker(std::stop_token, int) 签名不匹配，所以进入 else 分支：

1

_Impl._Start(_STD forward<_Fn>(func), _STD forward<_Args>(args)...);

stop_source

stop_source 管理一个共享的停止状态（_Stop_state），通过引用计数实现资源共享和生命周期管理。

 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


class stop_source {
public:
 stop_source() : _State{new _Stop_state} {}
 explicit stop_source(nostopstate_t) noexcept : _State{} {}
 stop_source(const stop_source& _Other) noexcept : _State{_Other._State} {
 const auto _Local = _State;
 if (_Local != nullptr) {
 // `fetch_add(2)` 而非1
 // 原因：`_Stop_sources`的最低位用于标记，实际计数是 `值/2`
 _Local->_Stop_sources.fetch_add(2, memory_order_relaxed);
 }
 }

 stop_source(stop_source&& _Other) noexcept : _State{ exchange(_Other._State, nullptr)} {}
 stop_source& operator=(const stop_source& _Other) noexcept {
 stop_source{_Other}.swap(*this);
 return *this;
 }

 stop_source& operator=(stop_source&& _Other) noexcept {
 stop_source{move(_Other)}.swap(*this);
 return *this;
 }

 ~stop_source() {
 const auto _Local = _State;
 if (_Local != nullptr) {
 // 1. source计数-1（实际-2）
 // 右移1位忽略标志位，2>>1 == 1说明是最后一个
 if ((_Local->_Stop_sources.fetch_sub(2, memory_order_acq_rel) >> 1) == 1) {
 if (_Local->_Stop_tokens.fetch_sub(1, memory_order_acq_rel) == 1) {
 // 2. 最后一个source，尝试释放token计数
 delete _Local;
 }
 }
 }
 }

 stop_token get_token() const noexcept {
 const auto _Local = _State;
 if (_Local != nullptr) {
 _Local->_Stop_tokens.fetch_add(1, memory_order_relaxed);
 }

 return stop_token{_Local};
 }
 bool stop_requested() const noexcept {
 const auto _Local = _State;
 return _Local != nullptr && _Local->_Stop_requested();
 }

 bool stop_possible() const noexcept {
 return _State != nullptr;
 }

 bool request_stop() noexcept {
 const auto _Local = _State;
 return _Local && _Local->_Request_stop();
 }

private:
 _Stop_state* _State; // 指向共享停止状态的指针
};

stop_token

 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


class stop_token {
 friend stop_source;
 friend _Stop_callback_base;

public:
 stop_token() noexcept : _State{} {}
 stop_token(const stop_token& _Other) noexcept : _State{_Other._State} {
 const auto _Local = _State;
 if (_Local != nullptr) {
 _Local->_Stop_tokens.fetch_add(1, memory_order_relaxed);
 }
 }

 stop_token(stop_token&& _Other) noexcept : _State{exchange(_Other._State, nullptr)} {}
 stop_token& operator=(const stop_token& _Other) noexcept {
 stop_token{_Other}.swap(*this);
 return *this;
 }

 stop_token& operator=(stop_token&& _Other) noexcept {
 stop_token{move(_Other)}.swap(*this);
 return *this;
 }

 ~stop_token() {
 const auto _Local = _State;
 if (_Local != nullptr) {
 if (_Local->_Stop_tokens.fetch_sub(1, memory_order_acq_rel) == 1) {
 delete _Local;
 }
 }
 }

 bool stop_requested() const noexcept {
 const auto _Local = _State;
 return _Local != nullptr && _Local->_Stop_requested();
 }

 bool stop_possible() const noexcept {
 const auto _Local = _State;
 return _Local != nullptr && _Local->_Stop_possible();
 }

private:
 explicit stop_token(_Stop_state* const _State_) : _State{_State_} {}

 _Stop_state* _State;
};

stop_state

 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


struct _Stop_state {
 atomic<uint32_t> _Stop_tokens = 1; // plus one shared by all stop_sources
 atomic<uint32_t> _Stop_sources = 2; // plus the low order bit is the stop requested bit
 _Locked_pointer<_Stop_callback_base> _Callbacks; // 存储所有注册的停止回调
 // always uses relaxed operations; ordering provided by the _Callbacks lock
 // (atomic just to get wait/notify support)
 atomic<const _Stop_callback_base*> _Current_callback = nullptr; // 当前执行的回调
 _Thrd_id_t _Stopping_thread = 0; // 停止线程ID

 bool _Stop_requested() const noexcept {
 return (_Stop_sources.load() & uint32_t{1}) != 0;
 }

 bool _Stop_possible() const noexcept {
 return _Stop_sources.load() != 0;
 }

 bool _Request_stop() noexcept {
 // Attempts to request stop and call callbacks, returns whether request was successful
 // 原子地设置停止位，检查是否首次请求
 if ((_Stop_sources.fetch_or(uint32_t{1}) & uint32_t{1}) != 0) {
 // another thread already requested
 return false;
 }

 // 记录停止线程
 _Stopping_thread = _Thrd_id();
 // 执行所有回调
 for (;;) {
 auto _Head = _Callbacks._Lock_and_load();
 _Current_callback.store(_Head, memory_order_relaxed);
 _Current_callback.notify_all();
 if (_Head == nullptr) {
 _Callbacks._Store_and_unlock(nullptr);
 return true; // 所有回调已执行完
 }

 const auto _Next = _STD exchange(_Head->_Next, nullptr);
 _STL_INTERNAL_CHECK(_Head->_Prev == nullptr);
 if (_Next != nullptr) {
 _Next->_Prev = nullptr;
 }

 _Callbacks._Store_and_unlock(_Next); // unlock before running _Head so other registrations
 // can detach without blocking on the callback
 _Head->_Fn(_Head); // might destroy *_Head
 }
 }
};

_Stop_state 内部主要维护两个原子计数器和一个链表：

_Stop_sources: source 引用计数（实际值/2）（位运算技巧，同时存储两个信息）
_Stop_tokens: token 引用计数（实际值/1）
_Callbacks：stop_callback 链表

1
2
3
4


atomic<uint32_t> _Stop_sources = 2;
// 二进制: ...00000010
// 第0位(LSB): 停止请求标志位
// 第1-31位: 实际的source引用计数

_Stop_sources 用一个 32 位整数同时存储两个信息：是否请求停止，source 引用数

1

atomic<uint32_t> _Stop_tokens = 1;

所有stop_source共享一个"虚拟token"

总结

通过 jthread 的源码探究，能够更好的把握 jthread，在日常开发中能够避免踩坑，同时源码能体现出标准库的设计哲学，职责分离，可以学到很多。

C++20 指定初始化器：现代结构体初始化

Fri, 16 Jan 2026 22:20:00 +0800

C++20 引入了指定初始化器（Designated Initializers），这是一个借鉴自 C99 的特性，允许你通过显式指定成员变量名来初始化结构体。这极大地提高了代码的可读性和可维护性。

基本概念

指定初始化器使用 .成员名 = 值 的语法来明确指定要初始化的成员。

传统初始化（C++20 之前）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


struct Point {
 int x;
 int y;
 int z;
};

// 必须按声明顺序，容易出错
Point p1 = {1, 2, 3}; // 哪个是 x，y，z？

// 添加成员需要更新所有初始化代码
Point p2 = {1, 2}; // z 为 0，但不明显

指定初始化器（C++20）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


struct Point {
 int x;
 int y;
 int z;
};

// 清晰明确
Point p1 = {.x = 1, .y = 2, .z = 3};

// 可以跳过某些成员（未指定的成员会零初始化）
Point p2 = {.x = 1, .z = 3}; // y = 0

重要规则

必须按声明顺序

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


struct Person {
 std::string name;
 int age;
 std::string city;
};

// ✅ 正确：按声明顺序
Person p1 = {
 .name = "Alice",
 .age = 30,
 .city = "北京"
};

// ❌ 错误：违反声明顺序
Person p2 = {
 .age = 30, // age 在 name 之后
 .name = "Bob", // 编译错误: “name”: 指示符必须按类“Person”的成员声明顺序显示
 .city = "上海"
};

可以跳过成员

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


struct Person {
 std::string name;
 int age;
 std::string city;
};

Person p1 = {
 .name = "Alice",
 .age = 30,
};

Person p1 = {
 .age = 30
};

不能混用初始化方式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


struct Point {
 int x, y, z;
};

// ❌ 错误：不能混用
Point p = {1, .y = 2, .z = 3}; // 编译错误！

// ✅ 正确：统一使用一种方式
Point p1 = {1, 2, 3}; // 位置初始化
Point p2 = {.x = 1, .y = 2, .z = 3}; // 指定初始化

每个成员只能初始化一次

1
2
3
4
5
6
7
8
9


struct Point {
 int x, y, z;
};

// ❌ 错误：重复初始化
Point d = {
 .x = 10,
 .x = 20 // 错误！
};

不能用于数组元素的指示符

1
2
3
4
5
6
7
8


struct Point {
 int coords[3];
};

 // ✅ 可以对数组本身
Point p = {.coords = {1, 2, 3}};
// ❌ 不能这样做（与 C99 不同）
Point p1 = {.coords[0] = 1, .coords[1] = 2}; // C++ 中错误！

只适用于聚合类型

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


// ✅ 聚合类型：无用户定义的构造函数
struct Aggregate {
 int x;
 double y;
};

Aggregate a = {.x = 1, .y = 2.0}; // 正确

// ❌ 非聚合类型：有构造函数
struct NonAggregate {
 int x;
 double y;

 NonAggregate(int x, double y) : x(x), y(y) {}
};

NonAggregate na = {.x = 1, .y = 2.0}; // 错误！指定的初始化仅可用于初始化聚合类类型

示例

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


struct ServerConfig {
 std::string host = "localhost";
 int port = 8080;
 int timeout = 30;
 bool useSSL = false;
 int maxConnections = 100;
};

// 清晰地创建不同配置
ServerConfig devConfig = {
 .port = 3000,
 .timeout = 60
};

ServerConfig prodConfig = {
 .host = "api.example.com",
 .port = 443,
 .useSSL = true,
 .maxConnections = 1000
};

嵌套结构：

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


struct Address {
 std::string street;
 std::string city;
};

struct Employee {
 std::string name;
 Address address;
 double salary;
};

// 嵌套指定初始化
Employee emp = {
 .name = "Job",
 .address = {
 .street = "Street 1",
 .city = "US",
 },
 .salary = 75000.0
};

与 C99 的比较

C++ 的指定初始化器相比 C99 有一些限制：

特性	C99	C++20
乱序初始化	✅ 允许	❌ 必须按顺序
数组的指示符	✅ `[index]`	❌ 不支持
嵌套指定器	✅ `.a.b`	❌ 必须嵌套大括号
混合初始化	✅ 允许	❌ 不允许

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 乱序
struct Point p1 = {.y = 2, .x = 1}; // C99 可以，C++20 错误

// 数组指定器
int arr[5] = {[0] = 1, [4] = 5}; // C99 可以，C++20 错误

// 嵌套指定器
struct S {
 struct { int x, y; } point;
};
struct S s = {.point.x = 1}; // C99 可以，C++20 错误

https://en.cppreference.com/w/cpp/language/aggregate_initialization

P0329R4: Designated Initialization

https://open-std.org/JTC1/SC22/WG14/www/docs/n494.pdf

https://en.cppreference.com/w/c/language/struct_initialization.html

C++20 三路比较运算符（宇宙飞船运算符）使用指南

Fri, 16 Jan 2026 20:00:00 +0800

C++20 引入的三路比较运算符（three-way comparison operator），也被称为"宇宙飞船运算符"（spaceship operator），写作 <=>。用于简化和统一比较操作。

基本概念

<=> 运算符一次性完成两个值的比较，返回三种可能的结果：

小于（less）- (a <=> b) < 0 if a < b
等于（equal）- (a <=> b) == 0 if a and b are equal/equivalent.
大于（greater）- (a <=> b) > 0 if a > b

返回类型

它返回一个表示比较结果的值，可以直接用于排序和相等性判断。

<=> 返回以下三种类型之一：

std::strong_ordering - 强排序
- 值：less, equal, greater
- 适用于：整数、指针等
std::weak_ordering - 弱排序
- 值：less, equivalent, greater
- 适用于：大小写不敏感的字符串比较
std::partial_ordering - 偏序
- 值：less, equivalent, greater, unordered
- 适用于：浮点数（因为有 NaN）

动机

当第一次接触到<=> 运算符时，大概会比较困惑，它的作用到底是什么？使用场景又是什么？等等一系列问题。

在C++ 20之前，我们如果要比较自定义类型，通常需要这样做：

 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


struct Point {
 int x, y;

 bool operator==(const Point& rhs) const {
 return x == rhs.x && y == rhs.y;
 }

 bool operator!=(const Point& rhs) const {
 return !(*this == rhs);
 }

 bool operator<(const Point& rhs) const {
 if (x != rhs.x)
 return x < rhs.x;
 return y < rhs.y;
 }

 bool operator<=(const Point& rhs) const {
 return !(rhs < *this);
 }

 bool operator>(const Point& rhs) const {
 return rhs < *this;
 }

 bool operator>=(const Point& rhs) const {
 return !(*this < rhs);
 }
};

int main() {
 Point p1{1, 2}, p2{1, 3};

 std::cout << std::boolalpha << (p1 < p2) << '\n'; // true
 std::cout << std::boolalpha << (p1 == p2) << "\n"; // false
}

即，需要实现 6 个比较运算符，才能进行自定义类型的比较。而定义一个 <=> 运算符后，编译器会自动生成所有六个比较运算符（<, <=, >, >=, ==, !=）

基本用法

基本类型比较：

1
2
3
4
5
6
7
8


int main() {
 int a = 5, b = 10;
 std::strong_ordering result = a <=> b;

 if (result < 0) {
 std::cout << "a < b\n";
 }
}

自定义类型比较：

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


#include <compare>
#include <iostream>

struct Point {
 int x, y;

 // 只需定义 <=> 运算符
 auto operator<=>(const Point& other) const = default;
};

int main() {
 Point p1{1, 2}, p2{1, 3};

 if (p1 < p2) {
 std::cout << "p1 < p2\n";
 }

 return 0;
}

自定义比较逻辑：

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


struct Person
{
 std::string name;
 int age;

 // 先比较年龄，相同再按姓名
 auto operator<=>(const Person& rhs) const
 {
 if (auto cmp = age <=> rhs.age; cmp != 0)
 return cmp;
 return name <=> rhs.name;
 }

 // 仍需显式定义 ==
 bool operator==(const Person& rhs) const = default;
};

Person p1{"Alice", 30}, p2{"Bob", 25};
std::cout << std::boolalpha << (p1 >= p2) << '\n'; // true (30 > 25)
std::cout << std::boolalpha << (p1 == p2) << '\n'; // false (30 != 25)

[!note] 当自定义了 operator<=> 后，需要显示定义 opretor== 运算符，因为 operator<=> 不会自动生成 operator==，主要是为了性能考虑，<=> 可能做了不必要的排序比较，而 == 只需要判断相等即可。

官方解释：

类型有了 <=> 之后，== 是从 <=> 生成的。对于字符串，== 通常通过首先比较大小来优化：如果字符数不同，则字符串不相等。从 <=> 生成的 == 则必须读取足够的字符串以确定它们的词典顺序，那开销就会大得多了。经过长时间的讨论，我们决定不从 <=> 生成 ==。 - 源自《C++ 白皮书》

总结

简化代码：定义一个 <=> 运算符后，编译器自动生成所有六个比较运算符（<, <=, >, >=, ==, !=）
性能优化：一次比较得到完整的排序关系，避免多次比较
默认实现：使用 = default 可以让编译器自动生成按成员字典序比较的实现

https://www.stroustrup.com/hopl20main-p5-p-bfc9cd4--final.pdf

https://github.com/Cpp-Club/Cxx_HOPL4_zh

浏览器301重定向响应流程分析

Sat, 20 Dec 2025 18:58:37 +0800

浏览器在访问 HTTP 协议非 HTTPS 的站点时，通常会发生 301 重定向，那么整个请求响应流程是怎样的？接下来我们深入分析一下。

分析

首先，我们明白，这是一个 HTTP 层面的行为，底层依赖 TCP 协议进行可靠传输。

[!tips] 前置知识 HTTP 端口为 80，HTTPS 端口为 443 301 是 HTTP 响应状态码，表示永久重定向，即请求的资源已永久移动到新的位置。

理论分析

一、初始请求阶段

1

用户输入URL → DNS解析 → TCP三次握手 → 发送HTTP请求

用户输入 URL：用户在浏览器地址栏输入一个 URL（比如 http://example.com ）并按下回车。
DNS 解析：浏览器解析 URL 中的域名，通过 DNS 获取对应的 IP 地址。如果涉及到重定向，可能在 DNS 层面就有 CNAME 等记录。
建立 TCP 连接：浏览器根据 IP 地址和端口 (默认 80 或 443）与服务器建立 TCP 连接。这一步是 TCP 协议的工作，包括三次握手。
发送 HTTP 请求：通过已建立的 TCP 连接，浏览器发送 HTTP 请求。例如，一个 GET 请求到根路径/。

客户端请求报文示例：

1
2


GET / HTTP/1.1
Host: example.com

二、服务器响应阶段

1

服务器处理 → 判断需重定向 → 生成301响应 → 通过TCP回传

服务器处理请求：服务器收到请求后，判断是否需要重定向到新的 URL。
服务器发送一个 HTTP 响应，状态码为 301，并在响应头中包含 Location: https://example.com（假设跳转到 HTTPS)。

服务器响应示例：

1
2
3
4


HTTP/1.1 301 Moved Permanently
Location: https://example.com/
Content-Type: text/html
Content-Length: ...

服务器是如何判断的呢？以 Nginx 为例：

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


server {
 listen 80;
 server_name example.com;

 # 对HTTP请求重定向到HTTPS
 return 301 https://$server_name$request_uri;
}

server {
 listen 443 ssl;
 server_name example.com;

 ssl_certificate /path/to/cert;
 ssl_certificate_key /path/to/key;

 location / {
 root html;
 index index.html;
 }
}

三、浏览器处理阶段

1

收到301响应 → 解析新URL → (可能的新TCP连接) → 发送新请求

浏览器处理重定向：浏览器收到 301 响应后，会从响应头中读取 Location 字段，获取新的 URL，然后自动向这个新 URL 发起新的请求。注意：对于 301 状态码，浏览器通常会缓存重定向信息，下次访问原 URL 时直接跳转到新 URL，而不必再向原 URL 发送请求。
向新 URL 发起请求：浏览器使用新 URL，可能重新进行 DNS 解析（如果域名变了）、建立 TCP 新连接（如果需要），然后发送 HTTP 请求。
服务器响应新请求：服务器返回正常的 200 状态码响应和网页内容。
浏览器渲染：浏览器收到响应后，渲染页面。

如果是 HTTP 到 HTTPS 的重定向：

1

http://example.com:80 → 301 → https://example.com:443

必然会新建 TCP 连接，增加 TLS 握手。

TCP 协议层的分析

TCP 连接管理分析

sequenceDiagram
Client->>Server: SYN (原始请求连接)
Server->>Client: SYN-ACK
Client->>Server: ACK + HTTP请求
Server->>Client: 301响应
alt 同一主机/端口
Client->>Server: 重用连接发送新请求
else 不同主机/端口
Client->>Server: FIN (关闭连接)
Client->>NewServer: 新建TCP连接
end

另外，顺便一提，对性能的影响：

额外 RTT：每次新建 TCP 连接增加 1 个 RTT（三次握手）
TLS 成本：HTTPS 重定向增加 TLS 握手（2-3 个 RTT）

调试分析

我们可以使用工具，进行直观的分析。

使用 cURL 工具追踪

1

curl -v -L http://example.com # -L自动跟随重定向

输出显示 TCP 连接建立、请求响应全过程。

这里以访问 baidu.com 为例：

 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


curl -v -L http://baidu.com
* Host baidu.com:80 was resolved.
* IPv6: (none)
* IPv4: 110.242.74.102, 124.237.177.164, 111.63.65.247, 111.63.65.103
* Trying 110.242.74.102:80...
* Established connection to baidu.com (110.242.74.102 port 80) from 192.168.68.228 port 12061
* using HTTP/1.x
> GET / HTTP/1.1
> Host: baidu.com
> User-Agent: curl/8.16.0
> Accept: */*
>
* Request completely sent off
< HTTP/1.1 301 Moved Permanently
< Location: http://www.baidu.com/
< Date: Sat, 20 Dec 2025 10:15:39 GMT
< Content-Length: 56
< Content-Type: text/html; charset=utf-8
* Ignoring the response-body
* setting size while ignoring
<
* Connection #0 to host baidu.com:80 left intact
* Issue another request to this URL: 'http://www.baidu.com/'
* Host www.baidu.com:80 was resolved.
* IPv6: (none)
* IPv4: 220.181.111.232, 220.181.111.1
* Trying 220.181.111.232:80...
* Established connection to www.baidu.com (220.181.111.232 port 80) from 192.168.68.228 port 12064
* using HTTP/1.x
> GET / HTTP/1.1
> Host: www.baidu.com
> User-Agent: curl/8.16.0
> Accept: */*
>
* Request completely sent off
< HTTP/1.1 200 OK
< Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform
< Content-Length: 2381
< Content-Type: text/html
< Pragma: no-cache
< Server: bfe
< Set-Cookie: BDORZ=27315; max-age=86400; domain=.baidu.com; path=/
< Date: Sat, 20 Dec 2025 10:15:39 GMT
<
<!DOCTYPE html>
<!--STATUS OK--><html> <head><meta http-equiv=content-type content=text/html;charset=utf-8><meta http-equiv=X-UA-Compatible content=IE=Edge><meta content=always name=referrer><link rel=stylesheet type=text/css href=http://s1.bdstatic.com/r/www/cache/bdorz/baidu.min.css><title>百度一下，你就知道</title> </html>
* Connection #1 to host www.baidu.com:80 left intact

Chrome DevTools 观察

Network 面板查看“状态”一列显示 HTTP 状态码，“连接 ID"字段查看 TCP 连接重用情况。

总结

通过分析 HTTP 301 重定向流程，我们进一步了解 HTTP 通信交互流程，HTTP 协议基于请求-响应模式，底层基于 TCP 协议提供可靠性的通信。理解和掌握这些机制，能帮助我们遇到问题时，能有一个清晰的解决方向。

U盘打不开提示格式化如何恢复

Wed, 17 Dec 2025 23:37:51 +0800

背景

在使用优盘的过程中，将优盘插入电脑尝试打开时，有时会遇到以下问题：“使用驱动器 E: 中的光盘之前需要将其格式化。是否要将其格式化?”或者“无法访问 E:\。此卷不包含可识别的文件系统。请确定所有请求的文件系统驱动程序已加载，且此卷未损坏。”等信息。

让人措手不及，优盘无法使用，且里面数据无法读取。如果含有重要数据，那就很糟糕了。遇到这种情况，千万不要轻易选择格式化。

问题解决

排除电脑问题

首先，应该检查一下优盘的连接问题。重新插拔一次，确保优盘完全插入，然后尝试连接其他的USB接口，排除接触不良、电脑接口问题的可能性。

如果尝试之后，还是不行。那么进行以下操作。

恢复优盘

这里需要使用到一个工具 DiskGenius，打开DiskGenius，选中优盘，查看右侧的分区参数，如下：

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


接口类型: USB
序列号: C0BA8AF2
型号: GenericFlashDisk
分区表类型: MBR
MBR签名: 00000000
属性: 可移动磁盘
柱面数: 3824
磁头数: 255
每道扇区数: 63
总容量: 29.3GB
总字节数: 31457280000
总扇区数: 61440000
扇区大小: 512
附加扇区数: 7440
物理扇区大小: 512

空间类型: 空闲空间
总容量: 29.3GB
总字节数: 31457280000
总扇区数: 61440000
起始扇区号: 0

可以分析得出：

MBR签名全为0：这是主引导记录损坏的明显标志
整个磁盘显示为“空闲空间”：分区表丢失，系统无法识别分区
容量正常显示：存储芯片本身可能没有物理损坏

接下来，使用DiskGenius的"搜索已丢失分区"功能：

选中U盘（磁盘级别）
点击菜单栏"工具" → “搜索已丢失分区（重建分区表）”
搜索范围选择"整个磁盘"
搜索方式选择"自动"（对于大多数情况有效）或"高级"
点击“开始搜索”
如果找到分区，选择"保留"

当能看到正常的卷标名称时，且能够浏览里面的文件，那么说明，优盘已经恢复了。保存分区表更改，确认保存分区表更改，优盘就修复好了。

重新拔插一下U盘，就能正常识别了。

预防措施：避免再次发生

良好使用习惯

安全弹出硬件：永远使用系统托盘中的“安全删除硬件”功能
避免在传输过程中拔插：文件传输完成后再移除U盘
定期备份重要数据：不要把U盘作为唯一存储位置
使用可靠品牌的U盘：质量差的U盘更容易出问题

硬盘打不开提示格式化？恢复硬盘数据修复硬盘这样做

C++ vector 翻倍扩容策略是错误的认知

Sat, 20 Sep 2025 22:47:44 +0800

C++ 中，std::vector 是一个动态数组，它能够在运行时根据需要自动调整其容量。许多初学者会认为 std::vector 的容量增长策略是简单的“翻倍”（即每次扩容为原来的 2 倍），但事实并非如此。

事实是，C++ 标准并没有规定 std::vector 的具体扩容策略。不同编译器（如 MSVC， GCC， Clang）的标准库实现可以自由选择它们认为最优的扩容策略。

我们通过代码验证一下，最简例子：

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


#include <iostream>
#include <vector>

int main()
{
 std::vector<int> vec;

 for (int i = 0; i < 100; i++) {
 vec.emplace_back(i);
 std::cout << "i:" << i << " size:" << vec.size() << " capacity:" << vec.capacity() << std::endl;
 }
 return 0;
}

这段代码在 MSVC 上的输出（输出简化）：

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


i:0 size:1 capacity:1
i:1 size:2 capacity:2
i:2 size:3 capacity:3
i:3 size:4 capacity:4
i:4 size:5 capacity:6
i:5 size:6 capacity:6
i:6 size:7 capacity:9
i:8 size:9 capacity:9
i:9 size:10 capacity:13
i:12 size:13 capacity:13
i:13 size:14 capacity:19
i:18 size:19 capacity:19
i:19 size:20 capacity:28
i:27 size:28 capacity:28
i:28 size:29 capacity:42
i:41 size:42 capacity:42
i:42 size:43 capacity:63
i:62 size:63 capacity:63
i:63 size:64 capacity:94
i:93 size:94 capacity:94
i:94 size:95 capacity:141
i:99 size:100 capacity:141

可以看到，std::vector 实例化后，容量（capacity）默认为 0，前四次追加都是扩容 1，第五次时，扩容 2，第七次时，扩容 3；4，6，9，14，21，31，47，非 2 倍扩容策略。

在 GCC 或 Clang 上输出：

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


i:0 size:1 capacity:1
i:1 size:2 capacity:2
i:2 size:3 capacity:4
i:3 size:4 capacity:4
i:4 size:5 capacity:8
i:7 size:8 capacity:8
i:8 size:9 capacity:16
i:15 size:16 capacity:16
i:16 size:17 capacity:32
i:31 size:32 capacity:32
i:32 size:33 capacity:64
i:63 size:64 capacity:64
i:64 size:65 capacity:128
i:99 size:100 capacity:128

GCC/Clang 为 2 倍扩容策略。

以上为观测现象，接下来从源码实现角度分析。

MSVC 源码：

 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


 _CONSTEXPR20 pointer _Emplace_reallocate(const pointer _Whereptr, _Valty&&... _Val) {
 // reallocate and insert by perfectly forwarding _Val at _Whereptr
 _Alty& _Al = _Getal();
 auto& _My_data = _Mypair._Myval2;
 pointer& _Myfirst = _My_data._Myfirst;
 pointer& _Mylast = _My_data._Mylast;

 _STL_INTERNAL_CHECK(_Mylast == _My_data._Myend); // check that we have no unused capacity

 const auto _Whereoff = static_cast<size_type>(_Whereptr - _Myfirst);
 const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);

 if (_Oldsize == max_size()) {
 _Xlength();
 }

 const size_type _Newsize = _Oldsize + 1;
 size_type _Newcapacity = _Calculate_growth(_Newsize);

 const pointer _Newvec = _STD _Allocate_at_least_helper(_Al, _Newcapacity);
 ...
 }

 _CONSTEXPR20 size_type _Calculate_growth(const size_type _Newsize) const {
 // given _Oldcapacity and _Newsize, calculate geometric growth
 const size_type _Oldcapacity = capacity();
 const auto _Max = max_size();

 if (_Oldcapacity > _Max - _Oldcapacity / 2) {
 return _Max; // geometric growth would overflow
 }

 // 计算新容量
 const size_type _Geometric = _Oldcapacity + _Oldcapacity / 2;

 if (_Geometric < _Newsize) {
 return _Newsize; // geometric growth would be insufficient
 }

 return _Geometric; // geometric growth is sufficient
 }

GCC 源码：

 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
122
123
124
125
126


#if __cplusplus >= 201103L
 template<typename _Tp, typename _Alloc>
 template<typename... _Args>
#if __cplusplus > 201402L
 _GLIBCXX20_CONSTEXPR
 typename vector<_Tp, _Alloc>::reference
#else
 void
#endif
 vector<_Tp, _Alloc>::
 emplace_back(_Args&&... __args)
 {
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
 {
 _GLIBCXX_ASAN_ANNOTATE_GROW(1);
 _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
 std::forward<_Args>(__args)...);
 ++this->_M_impl._M_finish;
 _GLIBCXX_ASAN_ANNOTATE_GREW(1);
 }
 else
 _M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
 return back();
#endif
 }
#endif

#if __cplusplus >= 201103L
 template<typename _Tp, typename _Alloc>
 template<typename... _Args>
 _GLIBCXX20_CONSTEXPR
 void
 vector<_Tp, _Alloc>::
 _M_realloc_insert(iterator __position, _Args&&... __args)
#else
 template<typename _Tp, typename _Alloc>
 void
 vector<_Tp, _Alloc>::
 _M_realloc_insert(iterator __position, const _Tp& __x)
#endif
 {
 // 计算新容量
 const size_type __len =
 _M_check_len(size_type(1), "vector::_M_realloc_insert");
 pointer __old_start = this->_M_impl._M_start;
 pointer __old_finish = this->_M_impl._M_finish;
 const size_type __elems_before = __position - begin();
 pointer __new_start(this->_M_allocate(__len));
 pointer __new_finish(__new_start);
 __try
 {
 // The order of the three operations is dictated by the C++11
 // case, where the moves could alter a new element belonging
 // to the existing vector. This is an issue only for callers
 // taking the element by lvalue ref (see last bullet of C++11
 // [res.on.arguments]).
 _Alloc_traits::construct(this->_M_impl,
 __new_start + __elems_before,
#if __cplusplus >= 201103L
 std::forward<_Args>(__args)...);
#else
 __x);
#endif
 __new_finish = pointer();

#if __cplusplus >= 201103L
 if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
 {
 __new_finish = _S_relocate(__old_start, __position.base(),
 __new_start, _M_get_Tp_allocator());

 ++__new_finish;

 __new_finish = _S_relocate(__position.base(), __old_finish,
 __new_finish, _M_get_Tp_allocator());
 }
 else
#endif
 {
 __new_finish
 = std::__uninitialized_move_if_noexcept_a
 (__old_start, __position.base(),
 __new_start, _M_get_Tp_allocator());

 ++__new_finish;

 __new_finish
 = std::__uninitialized_move_if_noexcept_a
 (__position.base(), __old_finish,
 __new_finish, _M_get_Tp_allocator());
 }
 }
 __catch(...)
 {
 if (!__new_finish)
 _Alloc_traits::destroy(this->_M_impl,
 __new_start + __elems_before);
 else
 std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
 _M_deallocate(__new_start, __len);
 __throw_exception_again;
 }
#if __cplusplus >= 201103L
 if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
 std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
 _GLIBCXX_ASAN_ANNOTATE_REINIT;
 _M_deallocate(__old_start,
 this->_M_impl._M_end_of_storage - __old_start);
 this->_M_impl._M_start = __new_start;
 this->_M_impl._M_finish = __new_finish;
 this->_M_impl._M_end_of_storage = __new_start + __len;
 }

 _GLIBCXX20_CONSTEXPR
 size_type
 _M_check_len(size_type __n, const char* __s) const
 {
 if (max_size() - size() < __n)
 __throw_length_error(__N(__s));

 // 新容量 = 当前大小 + max(当前大小, 1)
 const size_type __len = size() + (std::max)(size(), __n);
 return (__len < size() || __len > max_size()) ? max_size() : __len;
 }

从源码得知，MSVC 采用近似 1.5 倍 的增长策略，GCC 和 Clang 通常采用**翻倍（2 倍）**策略。

综上，std::vector 的扩容策略完全取决于编译器实现，对于 GCC/Clang 来说，翻倍策略是正确的，但在 MSVC 上，则不是如此。

此外，与 Modern C++ 标准无关， 11/23 均是如此。

由此还可得出，在只插入少量数据时，对性能影响反而更大，内存重新分配频次高，最佳实践是对于少量数据，提前分配空间，减少扩容导致的内存分配开销。

Visual Studio 远程调试

Sat, 23 Aug 2025 18:07:16 +0800

简介

Visual Studio 支持远程调试。即本机调试远程计算机程序。

这在某些场景很实用，其中一个场景为输入框调试时，焦点会转移到VS上，导致无法按预期调试。那么采用远程调试的方式，就能避免这个问题了。

准备远程调试

在测试机器（或虚拟机）上安装 Visual Studio 远程调试工具 (Remote Tools for Visual Studio)，版本必须和你开发机上的 VS 对应（比如 VS 2022 要下 VS 2022 Remote Tools）。

本地搜索 msvsmon.exe，选择对应架构的文件夹，将此文件夹拷贝到测试机（或虚拟机）

比如：

1
2
3


Program Files\Microsoft Visual Studio 17.0\Common7\IDE\Remote Debugger\x64\msvsmon.exe

Program Files\Microsoft Visual Studio 17.0\Common7\IDE\Remote Debugger\x86\msvsmon.exe

或者官网下载 Remote Tools 安装包，下载地址：微软官方 Remote Tools

在测试机（或者虚拟机）里打开 msvsmon.exe 程序，首次启动时会有配置弹窗：

然后，在菜单栏-工具-选项，选择无身份验证（测试环境方便）或配置 Windows 身份验证。

部署调试版本程序

在开发机上将 Debug 版本对应的可执行文件（包括 exe、dll、pdb 文件）拷贝到测试机（或者虚拟机），确保能够正常运行。

配置远程调试

方法一

右键单击项目并选择属性。打开调试选项卡。

将“要启动的调试器”更改为“远程 Windows 调试器”。

配置相关属性：

远程命令：填入测试机（或虚拟机）可执行文件路径。如 C:\Users\Leo\Desktop\remote_test\VirtualMemory.exe
工作目录：填入测试机（或虚拟机）可执行文件所在目录。如：C:\Users\Leo\Desktop\remote_test
远程服务器名称：目标机器名称。msvsmon.exe 日志显示的名称，如 DESKTOP-RNT4TEI。这里也可以 IP+端口形式连接
连接方式：选择不带身份验证的远程访问，与填入测试机（或虚拟机）msvsmon.exe 一致
调试器类型：仅限本机
部署目录：自动部署可执行文件（可选）。比如填 C:\Users\Leo\Desktop\remote_test

当你配置了部署目录，可在配置管理器里，将部署勾选上。

之后即可启动调试。将会自动连接并调试测试机（或虚拟机）的程序。

连接成功后，测试机（或虚拟机）msvsmon.exe 会显示对应日志。

[!tip]

还可配置自动部署，修改代码后自动部署到测试机（或虚拟机）进行远程调试。

方法二

通过附加到进程的方式进行调试。

在开发机 VS ，菜单栏-调试-附加到进程，连接类型选“远程（Windows - 无身份验证）”，然后查找，顺利的话，将会显示对应的远程调试目标。

连接成功后，再选择对应进程，附加到该进程上：

之后即可开始调试。

[!tip]

确认模块是否加载：

附加成功后，在 VS - 调试 - 窗口 - 模块 (Modules) 查看对应目标是否已加载。如果可执行文件路径正确，VS 会自动匹配 PDB 并绑定断点。

https://learn.microsoft.com/zh-cn/visualstudio/debugger/remote-debugging?view=vs-2022

https://learn.microsoft.com/zh-cn/troubleshoot/developer/visualstudio/debuggers/troubleshooting-remote-debugging?toc=%2Fvisualstudio%2Fdebugger%2Ftoc.json&view=vs-2022

LeetCode 75系列 - 1448. 统计二叉树中好节点的数目

Wed, 16 Jul 2025 22:50:00 +0800

题目描述

给你一棵根为 root 的二叉树，请你返回二叉树中好节点的数目。

「好节点」X 定义为：从根到该节点 X 所经过的节点中，没有任何节点的值大于 X 的值。

示例 1：

1
2
3
4
5
6
7


输入：root = [3,1,4,3,null,1,5]
输出：4
解释：图中蓝色节点为好节点。
根节点 (3) 永远是个好节点。
节点 4 -> (3,4) 是路径中的最大值。
节点 5 -> (3,4,5) 是路径中的最大值。
节点 3 -> (3,1,3) 是路径中的最大值。

示例 2：

1
2
3


输入：root = [3,3,null,4,2]
输出：3
解释：节点 2 -> (3, 3, 2) 不是好节点，因为 "3" 比它大。

示例 3：

1
2
3


输入：root = [1]
输出：1
解释：根节点是好节点。

提示：

二叉树中节点数目范围是 [1, 10^5] 。
每个节点权值的范围是 [-10^4, 10^4] 。

题解

使用DFS（深度优先遍历），记录从根节点到当前节点的路径上所有节点的最大值，若当前节点的值大于等于该最大值，则认为当前节点是好节点，数目加一，最后返回总数目。

 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


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode() : val(0), left(nullptr), right(nullptr) {}
 * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
 int goodNodes(TreeNode* root) {
 if (root == nullptr)
 return 0;

 dfs(root, root->val);
 return num;
 }

private:
 void dfs(TreeNode* root, int val) {
 if (root == nullptr)
 return;

 if (root->val >= val) {
 num++;
 val = root->val;
 }

 dfs(root->left, val);
 dfs(root->right, val);
 }

private:
 int num{};
};

LeetCode 75系列 - 872. 叶子相似的树

Tue, 15 Jul 2025 22:40:00 +0800

题目描述

请考虑一棵二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。

举个例子，如上图所示，给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。

如果有两棵二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。

如果给定的两个根结点分别为 root1 和 root2 的树是叶相似的，则返回 true；否则返回 false 。

示例 1：

1
2


输入：root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
输出：true

示例 2：

1
2


输入：root1 = [1,2,3], root2 = [1,3,2]
输出：false

提示：

给定的两棵树结点数在 [1, 200] 范围内
给定的两棵树上的值在 [0, 200] 范围内

题解

可以采用DFS（深度优先搜索），判断当前节点是否为叶节点，如果是就存起来。然后两个数组进行比较。

 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


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode() : val(0), left(nullptr), right(nullptr) {}
 * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
 bool leafSimilar(TreeNode* root1, TreeNode* root2) {
 std::vector<int> vec1;
 std::vector<int> vec2;

 dfs(root1, vec1);
 dfs(root2, vec2);
 return vec1 == vec2;
 }

private:
 void dfs(TreeNode* root, std::vector<int>& vec) {
 if (root == nullptr)
 return;
 if (root->left == nullptr && root->right == nullptr) {
 vec.push_back(root->val);
 } else {
 dfs(root->left, vec);
 dfs(root->right, vec);
 }
 }
};

Qt 不同容器探究

Wed, 09 Jul 2025 14:45:22 +0800

前言

Qt 库提供了一组基于模板的通用容器类，与 STL 容器相比，这些容器类更轻便、更安全、更易用。容器类是隐式共享的，它们是可重入的，而且它们经过了优化，速度快、内存消耗低、内联代码扩展最少，因此可执行文件更小。此外，在所有用于访问它们的线程都将它们用作只读容器的情况下，它们是线程安全的。

本文重点探讨不同容器在 Qt 5 和 Qt 6 中的实现差异，揭示底层设计变化对性能和使用的影响。通过源码分析，我们将理解 Qt 容器设计的演进逻辑。

Qt 5 版本

QQueue

基于 QList 的队列，继承了 QList。在 QList 基础上中增加了几个方法：

enqueue() → 调用 QList::append()
dequeue() → 调用 QList::takeFirst()
head() → 调用 QList::first()

qt-everywhere-src-5.15.2\qtbase\src\corelib\tools\qqueue.h 源码：

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


template <class T>
class QQueue : public QList<T>
{
public:
 // compiler-generated special member functions are fine!
 inline void swap(QQueue<T> &other) noexcept { QList<T>::swap(other); } // prevent QList<->QQueue swaps
#if QT_DEPRECATED_SINCE(5, 14) && !defined(Q_QDOC)
 // NOT using QList<T>::swap; it would make swap(QList&) available.
 QT_DEPRECATED_VERSION_X_5_14("Use swapItemsAt(i, j) instead")
 inline void swap(int i, int j) { QList<T>::swapItemsAt(i, j); }
#endif
 inline void enqueue(const T &t) { QList<T>::append(t); }
 inline T dequeue() { return QList<T>::takeFirst(); }
 inline T &head() { return QList<T>::first(); }
 inline const T &head() const { return QList<T>::first(); }
};

QStack

基于 QVector 的栈，继承了 QVector。在 QVector 基础上增加了几个方法：push ()、pos ()、top ()。

pop() 直接操作内存索引（非简单调用 takeLast()）
top() 调用 detach() 确保写时复制

qt-everywhere-src-5.15.2\qtbase\src\corelib\tools\qstack.h 源码：

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


template<class T>
class QStack : public QVector<T>
{
public:
 // compiler-generated special member functions are fine!
 inline void swap(QStack<T> &other) noexcept { QVector<T>::swap(other); } // prevent QVector<->QStack swaps
 inline void push(const T &t) { QVector<T>::append(t); }
 T pop();
 T &top();
 const T &top() const;
};

template<class T>
inline T QStack<T>::pop()
{ Q_ASSERT(!this->isEmpty()); T t = this->data()[this->size() -1];
 this->resize(this->size()-1); return t; }

template<class T>
inline T &QStack<T>::top()
{ Q_ASSERT(!this->isEmpty()); this->detach(); return this->data()[this->size()-1]; }

template<class T>
inline const T &QStack<T>::top() const
{ Q_ASSERT(!this->isEmpty()); return this->data()[this->size()-1]; }

QSet

QSet 是基于 QHash 实现的集合，值部分使用空结构体。

qt-everywhere-src-5.15.2\qtbase\src\corelib\tools\qset.h 源码

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


template <class T>
class QSet
{
 typedef QHash<T, QHashDummyValue> Hash;

public:
 inline QSet() noexcept {}
 inline QSet(std::initializer_list<T> list)
 : QSet(list.begin(), list.end()) {}
 template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator> = true>
 inline QSet(InputIterator first, InputIterator last)
 {
 QtPrivate::reserveIfForwardIterator(this, first, last);
 for (; first != last; ++first)
 insert(*first);
 }

private:
 Hash q_hash;
};

Qt 6 版本

在 Qt 6 之后，容器底层发生了变化。

QVector

QVector 在 Qt 6 版本中，是 QList 的别名。

Qt\6.8.2\msvc2022_64\include\QtCore\qcontainerfwd.h 源码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#ifndef Q_QDOC
template<typename T> using QVector = QList<T>;
using QStringList = QList<QString>;
class QByteArray;
using QByteArrayList = QList<QByteArray>;
#else
template<typename T> class QVector;
class QStringList;
class QByteArrayList;
#endif

QList

在 Qt 6 中，QList 和 QVector 被统一了。这意味着 QList 并非以链表形式实现，现在是一个提供动态数组的模板类，它将项目存储在相邻的内存位置，并提供基于索引的快速访问。因此如果您需要在常量时间内进行插入、删除、追加或前置操作，请考虑使用 std::list

QStack

在 Qt 6 之后，QStack 实质上是继承 QList 了

Qt\6.8.2\msvc2022_64\include\QtCore\qstack.h 源码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


template<class T>
class QStack : public QList<T>
{
public:
 // compiler-generated special member functions are fine!
 void swap(QStack<T> &other) noexcept { QList<T>::swap(other); } // prevent QList<->QStack swaps
 void push(const T &t) { QList<T>::append(t); }
 T pop() { return QList<T>::takeLast(); }
 T &top() { return QList<T>::last(); }
 const T &top() const { return QList<T>::last(); }
};

总结

容器底层的实现替换，通常是无感的，但是理解这些底层变化，将是有帮助的，可以在日常开发中写出更高效的代码。

Container Classes | Qt Core | Qt 6.9.1

LeetCode 75系列 - 104. 二叉树的最大深度

Sun, 06 Jul 2025 19:30:00 +0800

题目描述

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

1
2


输入：root = [3,9,20,null,null,15,7]
输出：3

示例 2：

1
2


输入：root = [1,null,2]
输出：2

提示：

树中节点的数量在 [0, 104] 区间内。
-100 <= Node.val <= 100

题解

最大深度就是根节点到「最远」叶子节点的最长路径上的节点数。

1
2
3
4
5
6
7


class Solution {
public:
 int maxDepth(TreeNode* root) {
 if (root == nullptr) return 0;
 return max(maxDepth(root->left), maxDepth(root->right)) + 1;
 }
};

LeetCode 75系列 - 2130. 链表最大孪生和

Tue, 01 Jul 2025 17:50:00 +0800

题目描述

在一个大小为 n 且 n 为偶数的链表中，对于 0 <= i <= (n / 2) - 1 的 i ，第 i 个节点（下标从 0 开始）的孪生节点为第 (n-1-i) 个节点。

比方说，n = 4 那么节点 0 是节点 3 的孪生节点，节点 1 是节点 2 的孪生节点。这是长度为 n = 4 的链表中所有的孪生节点。

孪生和 定义为一个节点和它孪生节点两者值之和。

给你一个长度为偶数的链表的头节点 head ，请你返回链表的 最大孪生和 。

示例 1：

1
2
3
4
5
6


输入：head = [5,4,2,1]
输出：6
解释：
节点 0 和节点 1 分别是节点 3 和 2 的孪生节点。孪生和都为 6 。
链表中没有其他孪生节点。
所以，链表的最大孪生和是 6 。

示例 2：

1
2
3
4
5
6
7


输入：head = [4,2,2,3]
输出：7
解释：
链表中的孪生节点为：
- 节点 0 是节点 3 的孪生节点，孪生和为 4 + 3 = 7 。
- 节点 1 是节点 2 的孪生节点，孪生和为 2 + 2 = 4 。
所以，最大孪生和为 max(7, 4) = 7 。

示例 3：

1
2
3
4


输入：head = [1,100000]
输出：100001
解释：
链表中只有一对孪生节点，孪生和为 1 + 100000 = 100001 。

提示：

链表的节点数目是 [2, 105] 中的偶数。
1 <= Node.val <= 105

题解

解法一

直接使用数组存储对应节点的数据，然后再找最大孪生和。

 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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 int pairSum(ListNode* head) {
 int sum{};
 ListNode* current = head;
 std::vector<int> vec;

 while (current) {
 vec.push_back(current->val);
 current = current->next;
 }
 int n = vec.size();
 for (int i = 0; i < n; i++) {
 auto re = vec[i] + vec[n - 1 - i];

 sum = std::max(sum, re);
 }
 return sum;
 }
};

解法二

快慢指针 + 反转链表

 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


class Solution {
public:
 int pairSum(ListNode* head) {
 ListNode* slow = head;
 ListNode* fast = head->next;
 while (fast->next) {
 slow = slow->next;
 fast = fast->next->next;
 }
 // 反转链表
 ListNode* last = slow->next;
 while (last->next) {
 ListNode* cur = last->next;
 last->next = cur->next;
 cur->next = slow->next;
 slow->next = cur;
 }
 int ans = 0;
 ListNode* x = head;
 ListNode* y = slow->next;
 while (y) {
 ans = max(ans, x->val + y->val);
 x = x->next;
 y = y->next;
 }
 return ans;
 }
};

LeetCode 75系列 - 206. 反转链表

Mon, 30 Jun 2025 15:50:00 +0800

题目描述

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

1
2


输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

1
2


输入：head = [1,2]
输出：[2,1]

示例 3：

1
2


输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

题解

假设链表为 1→2→3→∅，我们想要把它改成 ∅←1←2←3。

在遍历链表时，将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

 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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* reverseList(ListNode* head) {
 ListNode* slow = nullptr;
 ListNode* current = head;

 while (current) {
 ListNode* next = current->next;
 current->next = slow;
 slow = current;
 current = next;
 }
 return slow;
 }
};

LeetCode 75系列 - 328. 奇偶链表

Thu, 26 Jun 2025 21:00:00 +0800

题目描述

给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别分组，保持它们原有的相对顺序，然后把偶数索引节点分组连接到奇数索引节点分组之后，返回重新排序的链表。

第一个节点的索引被认为是奇数， 第二个节点的索引为偶数，以此类推。

请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。

你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。

示例 1:

1
2


输入: head = [1,2,3,4,5]
输出: [1,3,5,2,4]

示例 2:

1
2


输入: head = [2,1,3,5,6,4,7]
输出: [2,3,6,7,1,5,4]

提示:

n == 链表中的节点数
0 <= n <= 104
-106 <= Node.val <= 106

题解

解法一

通过遍历，构造奇偶链表，最终合并两个链表。

 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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* oddEvenList(ListNode* head) {
 ListNode* odd = new ListNode(-1);
 ListNode* node = odd;
 ListNode* even = new ListNode(-1);
 ListNode* even_head = even;

 int i{1};
 while (head) {
 ListNode* n = new ListNode(head->val);
 if (i % 2 == 0) {
 even->next = n;
 even = even->next;
 } else {
 odd->next = n;
 odd = odd->next;
 }
 head = head->next;
 i++;
 }
 odd->next = even_head->next;
 return node->next;
 }
};

解法二

维护两个指针 odd 和 even 分别指向奇数节点和偶数节点，初始时 odd = head，even = head->next。通过迭代的方式将奇数节点和偶数节点分离成两个链表，每一步首先更新奇数节点，然后更新偶数节点。

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


class Solution {
public:
 ListNode* oddEvenList(ListNode* head) {
 if (head == nullptr)
 return nullptr;

 ListNode* odd = head;
 ListNode* even = head->next;
 ListNode* even_head = even;

 while (even && even->next) {
 odd->next = even->next;
 odd = odd->next;
 even->next = odd->next;
 even = even->next;
 }
 odd->next = even_head;
 return head;
 }
};

LeetCode 75系列 - 2095. 删除链表的中间节点

Thu, 26 Jun 2025 20:50:00 +0800

题目描述

给你一个链表的头节点 head 。删除链表的 中间节点 ，并返回修改后的链表的头节点 head 。

长度为 n 链表的中间节点是从头数起第 ⌊n / 2⌋ 个节点（下标从 0 开始），其中 ⌊x⌋ 表示小于或等于 x 的最大整数。

对于 n = 1、2、3、4 和 5 的情况，中间节点的下标分别是 0、1、1、2 和 2 。

示例 1：

1
2
3
4
5
6


输入：head = [1,3,4,7,1,2,6]
输出：[1,3,4,1,2,6]
解释：
上图表示给出的链表。节点的下标分别标注在每个节点的下方。
由于 n = 7 ，值为 7 的节点 3 是中间节点，用红色标注。
返回结果为移除节点后的新链表。

示例 2：

1
2
3
4
5


输入：head = [1,2,3,4]
输出：[1,2,4]
解释：
上图表示给出的链表。
对于 n = 4 ，值为 3 的节点 2 是中间节点，用红色标注。

示例 3：

1
2
3
4
5
6


输入：head = [2,1]
输出：[2]
解释：
上图表示给出的链表。
对于 n = 2 ，值为 1 的节点 1 是中间节点，用红色标注。
值为 2 的节点 0 是移除节点 1 后剩下的唯一一个节点。

提示：

链表中节点的数目在范围 [1, 105] 内
1 <= Node.val <= 105

题解

快慢指针解法：使用两个指针 fast 和 slow 对链表进行遍历，其中快指针 fast 每次前进两步，慢指针 slow 每次前进一步。这样在快指针遍历完链表时，慢指针就恰好在链表的中间位置。

注意：当链表中只有一个节点时，我们会删除这个节点并返回空链表。但这个节点不存在前一个节点，即 current 是没有意义的，因此我们可以在遍历前进行特殊判断，直接返回空指针作为答案。

 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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* deleteMiddle(ListNode* head) {
 if (head->next == nullptr) {
 return nullptr;
 }

 ListNode* slow = head;
 ListNode* fast = head;
 ListNode* current{};

 while (fast != nullptr && fast->next != nullptr) {
 fast = fast->next->next;
 current = slow;
 slow = slow->next;
 }

 current->next = current->next->next;

 return head;
 }
};

为什么慢指针最终指向中点? 设链表长度为 n（节点索引从 0 开始计数，头节点索引为 0）。慢指针移动速度为 1 节点/步，快指针移动速度为 2 节点/步。经过 k 次迭代（即慢指针移动了 k 步），慢指针位于索引 k，快指针位于索引 2k。

C++ IO 缓冲区

Thu, 12 Jun 2025 21:29:06 +0800

前言

在C++中，输入输出流（IO流）是程序与外部设备（如屏幕、文件）交互的桥梁。为了提高效率，输出流通常会使用缓冲区暂存数据，避免每次输出都直接访问设备带来的性能开销。

正文

输出缓冲区的作用与刷新机制

每个输出流对象都维护一个缓冲区，用于暂存待输出的数据。程序执行输出语句时，数据首先写入缓冲区，而非立即写入设备或文件。缓冲区的存在显著提升了程序性能，减少了对硬件设备的频繁访问。

缓冲区何时被刷新（即数据真正写到输出设备或文件）？

主要有以下几种情况：

程序正常结束（如main函数返回）时，系统自动刷新缓冲区。
缓冲区满时，自动触发刷新。
使用特定操纵符显式刷新，如endl、flush和ends。
通过unitbuf操纵符设置流的状态，使每次输出后自动刷新。
输入流与输出流关联时，读取输入流会先刷新关联的输出流缓冲区。

刷新输出缓冲区

刷新操纵符：

endl：输出换行符并刷新缓冲区。
flush：仅刷新缓冲区，不输出额外字符。
ends：输出空字符并刷新缓冲区。

示例：

1
2
3


cout << "hello" << endl; // 输出hello和换行，刷新缓冲区
cout << "hello" << flush; // 输出hello，刷新缓冲区但不换行
cout << "hello" << ends; // 输出hello和空字符，刷新缓冲区

unitbuf操纵符

通过unitbuf可以设置流为“每次输出后立即刷新缓冲区”的模式，适合需要实时输出的场景。对应的nounitbuf则恢复默认的缓冲策略。

1
2
3


cout << unitbuf; // 开启自动刷新
cout << "data"; // 输出后立即刷新
cout << nounitbuf; // 恢复默认缓冲

需要注意的是，标准错误流cerr默认启用了unitbuf，保证错误信息及时输出。

[!note]

如果程序异常终止（崩溃），缓冲区不会被刷新，可能导致部分输出丢失。

总结

输出缓冲区是C++ IO库中提升性能的重要机制，但合理管理缓冲区的刷新同样关键。通过使用endl、flush、ends等操纵符，或利用unitbuf设置自动刷新，可以确保程序输出及时、准确。

《C++ Primer》

LeetCode 75系列 - 649. Dota2 参议院

Tue, 10 Jun 2025 18:50:00 +0800

题目描述

Dota2 的世界里有两个阵营：Radiant（天辉）和 Dire（夜魇）

Dota2 参议院由来自两派的参议员组成。现在参议院希望对一个 Dota2 游戏里的改变作出决定。他们以一个基于轮为过程的投票进行。在每一轮中，每一位参议员都可以行使两项权利中的一项：

禁止一名参议员的权利：参议员可以让另一位参议员在这一轮和随后的几轮中丧失 所有的权利 。
宣布胜利：如果参议员发现有权利投票的参议员都是 同一个阵营的 ，他可以宣布胜利并决定在游戏中的有关变化。

给你一个字符串 senate 代表每个参议员的阵营。字母 'R' 和 'D'分别代表了 Radiant（天辉）和 Dire（夜魇）。然后，如果有 n 个参议员，给定字符串的大小将是 n。

以轮为基础的过程从给定顺序的第一个参议员开始到最后一个参议员结束。这一过程将持续到投票结束。所有失去权利的参议员将在过程中被跳过。

假设每一位参议员都足够聪明，会为自己的政党做出最好的策略，你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。输出应该是 "Radiant" 或 "Dire" 。

示例 1：

1
2
3
4
5
6


输入：senate = "RD"
输出："Radiant"
解释：
第 1 轮时，第一个参议员来自 Radiant 阵营，他可以使用第一项权利让第二个参议员失去所有权利。
这一轮中，第二个参议员将会被跳过，因为他的权利被禁止了。
第 2 轮时，第一个参议员可以宣布胜利，因为他是唯一一个有投票权的人。

示例 2：

1
2
3
4
5
6
7


输入：senate = "RDD"
输出："Dire"
解释：
第 1 轮时，第一个来自 Radiant 阵营的参议员可以使用第一项权利禁止第二个参议员的权利。
这一轮中，第二个来自 Dire 阵营的参议员会将被跳过，因为他的权利被禁止了。
这一轮中，第三个来自 Dire 阵营的参议员可以使用他的第一项权利禁止第一个参议员的权利。
因此在第二轮只剩下第三个参议员拥有投票的权利,于是他可以宣布胜利

提示：

n == senate.length
1 <= n <= 104
senate[i] 为 'R' 或 'D'

题解

 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


class Solution {
public:
 string predictPartyVictory(string senate) {
 bool radiant = true;
 bool dire = true;
 int radiantNum = 0; // Radiant 有投票权但还没有行使投票权的人
 int direNum = 0; // Dire 有投票权但还没有行使投票权的人
 while (radiant && dire) {
 radiant = false;
 dire = false;
 for (int i = 0; i < senate.size(); i++) {
 if (senate[i] == 'R') {
 if (direNum > 0) {
 senate[i] = '0'; // Dire方消耗了一个投票权
 direNum--;
 } else {
 radiant = true; // Radiant方增加了一个投票权
 radiantNum++;
 }
 } else if (senate[i] == 'D') {
 if (radiantNum > 0) {
 senate[i] = '0';
 radiantNum--;
 } else {
 dire = true;
 direNum++;
 }
 }
 }
 }
 return radiant ? "Radiant" : "Dire";
 }
};

LeetCode 75系列 - 933. 最近的请求次数

Fri, 30 May 2025 22:30:00 +0800

题目描述

写一个 RecentCounter 类来计算特定时间范围内最近的请求。

请你实现 RecentCounter 类：

RecentCounter() 初始化计数器，请求数为 0 。
int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。

保证每次对 ping 的调用都使用比之前更大的 t 值。

示例 1：

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


输入：
["RecentCounter", "ping", "ping", "ping", "ping"]
[[], [1], [100], [3001], [3002]]
输出：
[null, 1, 2, 3, 3]

解释：
RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1); // requests = [1]，范围是 [-2999,1]，返回 1
recentCounter.ping(100); // requests = [1, 100]，范围是 [-2900,100]，返回 2
recentCounter.ping(3001); // requests = [1, 100, 3001]，范围是 [1,3001]，返回 3
recentCounter.ping(3002); // requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3

提示：

1 <= t <= 109
保证每次对 ping 调用所使用的 t 值都 严格递增
至多调用 ping 方法 104 次

题解

这道题可以使用队列存储，然后将大于3000毫秒的移除，从而始终存放过去3000毫秒内的数据。

 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 RecentCounter {
public:
 RecentCounter() {}

 int ping(int t) {
 q.push(t);
 num = q.front();
 while (t - num > 3000) {
 q.pop();
 num = q.front();
 }

 return q.size();
 }

private:
 int num{};
 std::queue<int> q;
};

/**
 * Your RecentCounter object will be instantiated and called as such:
 * RecentCounter* obj = new RecentCounter();
 * int param_1 = obj->ping(t);
 */

LeetCode 75系列 - 394. 字符串解码

Thu, 29 May 2025 23:18:00 +0800

题目描述

给定一个经过编码的字符串，返回它解码后的字符串。

编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。

你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。

此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。

示例 1：

1
2


输入：s = "3[a]2[bc]"
输出："aaabcbc"

示例 2：

1
2


输入：s = "3[a2[c]]"
输出："accaccacc"

示例 3：

1
2


输入：s = "2[abc]3[cd]ef"
输出："abcabccdcdcdef"

示例 4：

1
2


输入：s = "abc3[cd]xyz"
输出："abccdcdcdxyz"

提示：

1 <= s.length <= 30
s 由小写英文字母、数字和方括号 '[]' 组成
s 保证是一个有效的输入。
s 中所有整数的取值范围为 [1, 300]

题解

核心思路：

数字栈（nums）：存储遇到的重复次数
字符串栈（chars）：存储当前已解码的字符串
遇到 [ 时：将当前字符串和数字分别压栈，并重置临时变量
遇到 ] 时：弹出栈顶数字（重复次数）和字符串（前缀），进行字符串拼接

 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


class Solution {
public:
 string decodeString(string s) {
 stack<string> chars;
 stack<int> nums;
 string res;
 int num = 0;

 for (char c : s) {
 if (isdigit(c)) // 或者c<='9' && c>='0
 {
 num = num * 10 + c - '0'; // 拼接多位数（如 "23" -> 2→20+3=23）
 } else if (isalpha(c)) {
 res += c;
 } else if (c == '[') {
 chars.push(res);
 nums.push(num);
 res = "";
 num = 0;
 } else if (c == ']') {
 string tmp = res;
 res = chars.top(); // 弹出栈顶字符串（前缀）
 chars.pop();
 int repeat = nums.top();
 nums.pop();
 while (repeat-- > 0) {
 res += tmp; // 重复拼接子串（如 "abc"×2 → "abcabc"）
 }
 }
 }
 return res;
 }
};

LeetCode 75系列 - 735. 小行星碰撞

Thu, 22 May 2025 22:50:00 +0800

题目描述

给定一个整数数组 asteroids，表示在同一行的小行星。数组中小行星的索引表示它们在空间中的相对位置。

对于数组中的每一个元素，其绝对值表示小行星的大小，正负表示小行星的移动方向（正表示向右移动，负表示向左移动）。每一颗小行星以相同的速度移动。

找出碰撞后剩下的所有小行星。碰撞规则：两个小行星相互碰撞，较小的小行星会爆炸。如果两颗小行星大小相同，则两颗小行星都会爆炸。两颗移动方向相同的小行星，永远不会发生碰撞。

示例 1：

1
2
3


输入：asteroids = [5,10,-5]
输出：[5,10]
解释：10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。

示例 2：

1
2
3


输入：asteroids = [8,-8]
输出：[]
解释：8 和 -8 碰撞后，两者都发生爆炸。

示例 3：

1
2
3


输入：asteroids = [10,2,-5]
输出：[10]
解释：2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。

提示：

2 <= asteroids.length <= 104
-1000 <= asteroids[i] <= 1000
asteroids[i] != 0

题解

碰撞条件 只有当：
- 当前小行星向左（aster < 0）
- 栈顶小行星向右（st.back() > 0）
- 栈不为空时才会发生碰撞。
碰撞处理
- 如果栈顶小行星的绝对值小于当前小行星（st.back() < -aster），栈顶小行星爆炸，当前小行星还活着（alive = true），继续和下一个栈顶比较。
- 如果栈顶小行星的绝对值等于当前小行星（st.back() == -aster），两者都爆炸（alive = false），栈顶弹出。
- 如果栈顶小行星的绝对值大于当前小行星（st.back() > -aster），当前小行星爆炸（alive = false），栈顶不变。
存活判断 如果当前小行星在碰撞后还活着（alive == true），就入栈。

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


class Solution {
public:
 vector<int> asteroidCollision(vector<int>& asteroids) {
 vector<int> st; // 保存当前还未爆炸的小行星
 for (auto aster : asteroids) {
 bool alive = true;
 while (alive && aster < 0 && !st.empty() && st.back() > 0) {
 alive = st.back() < -aster; // aster 是否存在
 if (st.back() <= -aster) { // 栈顶行星爆炸
 st.pop_back();
 }
 }
 if (alive) {
 st.push_back(aster);
 }
 }
 return st;
 }
};

LeetCode 75系列 - 2390. 从字符串中移除星号

Mon, 12 May 2025 22:50:00 +0800

题目描述

给你一个包含若干星号 * 的字符串 s 。

在一步操作中，你可以：

选中 s 中的一个星号。
移除星号左侧最近的那个 非星号 字符，并移除该星号自身。

返回移除所有星号之后的字符串**。**

注意：

生成的输入保证总是可以执行题面中描述的操作。
可以证明结果字符串是唯一的。

示例 1：

1
2
3
4
5
6
7


输入：s = "leet**cod*e"
输出："lecoe"
解释：从左到右执行移除操作：
- 距离第 1 个星号最近的字符是 "leet**cod*e" 中的 't' ，s 变为 "lee*cod*e" 。
- 距离第 2 个星号最近的字符是 "lee*cod*e" 中的 'e' ，s 变为 "lecod*e" 。
- 距离第 3 个星号最近的字符是 "lecod*e" 中的 'd' ，s 变为 "lecoe" 。
不存在其他星号，返回 "lecoe" 。

示例 2：

1
2
3


输入：s = "erase*****"
输出：""
解释：整个字符串都会被移除，所以返回空字符串。

提示：

1 <= s.length <= 105
s 由小写英文字母和星号 * 组成
s 可以执行上述操作

题解

从左到右依次遍历每个字符。如果是英文字母，则加入到 string 中。如果是*，则删除 string 中最后一个字母。

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


class Solution {
public:
 string removeStars(string s) {
 std::string word;
 for (const auto& c : s) {
 if (c == '*' && !word.empty()) {
 word.pop_back();
 } else {
 word.push_back(c);
 }
 }

 return word;
 }
};

LeetCode 75系列 - 2352. 相等行列对

Sun, 11 May 2025 17:50:00 +0800

题目描述

给你一个下标从 0 开始、大小为 n x n 的整数矩阵 grid ，返回满足 Ri 行和 Cj 列相等的行列对 (Ri, Cj) 的数目*。*

如果行和列以相同的顺序包含相同的元素（即相等的数组），则认为二者是相等的。

示例 1：

1
2
3
4


输入：grid = [[3,2,1],[1,7,6],[2,7,7]]
输出：1
解释：存在一对相等行列对：
- (第 2 行，第 1 列)：[2,7,7]

示例 2：

1
2
3
4
5
6


输入：grid = [[3,1,2,2],[1,4,4,5],[2,4,2,2],[2,4,2,2]]
输出：3
解释：存在三对相等行列对：
- (第 0 行，第 0 列)：[3,1,2,2]
- (第 2 行, 第 2 列)：[2,4,2,2]
- (第 3 行, 第 2 列)：[2,4,2,2]

提示：

n == grid.length == grid[i].length
1 <= n <= 200
1 <= grid[i][j] <= 105

题解

解法一

暴力解法：对每一行进行遍历，然后当前行与每一列进行比较，如果相等，则二者相等。

 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 Solution {
public:
 int equalPairs(vector<vector<int>>& grid) {
 int res = 0, n = grid.size();
 for (int row = 0; row < n; row++) {
 for (int col = 0; col < n; col++) {
 if (equal(row, col, grid)) {
 res++;
 }
 }
 }
 return res;
 }

 bool equal(int row, int col, vector<vector<int>>& grid) {
 int n = grid.size();
 for (int i = 0; i < n; i++) {
 if (grid[row][i] != grid[i][col]) {
 return false;
 }
 }
 return true;
 }
};

解法二

首先将矩阵的行放入哈希表中统计次数，哈希表的键可以是将行拼接后的字符串，也可以用各语言内置的数据结构，然后分别统计每一列相等的行有多少，求和即可。

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


class Solution {
public:
 int equalPairs(vector<vector<int>>& grid) {
 int n = grid.size();
 map<vector<int>, int> count;
 // 将每行数据放入map
 for (const auto& row : grid) {
 count[row]++;
 }

 int res = 0;
 for (int j = 0; j < n; j++) {
 vector<int> arr;
 for (int i = 0; i < n; i++) {
 arr.emplace_back(grid[i][j]);
 }
 if (count.find(arr) != count.end()) {
 res += count[arr];
 }
 }
 return res;
 }
};

LeetCode 75系列 - 1657. 确定两个字符串是否接近

Sat, 10 May 2025 22:50:00 +0800

题目描述

如果可以使用以下操作从一个字符串得到另一个字符串，则认为两个字符串接近：

操作 1：交换任意两个现有字符。
- 例如，abcde -> aecdb
操作 2：将一个现有字符的每次出现转换为另一个现有字符，并对另一个字符执行相同的操作。
- 例如，aacabb -> bbcbaa（所有 a 转化为 b ，而所有的 b 转换为 a ）

你可以根据需要对任意一个字符串多次使用这两种操作。

给你两个字符串，word1 和 word2 。如果 word1 和 word2 接近，就返回 true ；否则，返回 false 。

示例 1：

1
2
3
4
5


输入：word1 = "abc", word2 = "bca"
输出：true
解释：2 次操作从 word1 获得 word2 。
执行操作 1："abc" -> "acb"
执行操作 1："acb" -> "bca"

示例 2：

1
2
3


输入：word1 = "a", word2 = "aa"
输出：false
解释：不管执行多少次操作，都无法从 word1 得到 word2 ，反之亦然。

示例 3：

1
2
3
4
5
6


输入：word1 = "cabbba", word2 = "abbccc"
输出：true
解释：3 次操作从 word1 获得 word2 。
执行操作 1："cabbba" -> "caabbb"
执行操作 2："caabbb" -> "baaccc"
执行操作 2："baaccc" -> "abbccc"

提示：

1 <= word1.length, word2.length <= 105
word1 和 word2 仅包含小写英文字母

题解

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


class Solution {
public:
 bool closeStrings(string word1, string word2) {
 vector<int> count1(26), count2(26);
 for (char c : word1) {
 count1[c - 'a']++;
 }
 for (char c : word2) {
 count2[c - 'a']++;
 }
 for (int i = 0; i < 26; i++) {
 if (count1[i] > 0 && count2[i] == 0 || count1[i] == 0 && count2[i] > 0) {
 return false;
 }
 }
 sort(count1.begin(), count1.end());
 sort(count2.begin(), count2.end());
 return count1 == count2;
 }
};

LeetCode 75系列 - 1207. 独一无二的出现次数

Thu, 08 May 2025 22:50:00 +0800

题目描述

给你一个整数数组 arr，如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。

示例 1：

1
2
3


输入：arr = [1,2,2,1,1,3]
输出：true
解释：在该数组中，1 出现了 3 次，2 出现了 2 次，3 只出现了 1 次。没有两个数的出现次数相同。

示例 2：

1
2


输入：arr = [1,2]
输出：false

示例 3：

1
2


输入：arr = [-3,0,1,-3,1,1,1,-3,10,0]
输出：true

提示：

1 <= arr.length <= 1000
-1000 <= arr[i] <= 1000

题解

通过 map 容器记录每个数字的出现次数，然后利用 set 容器记录不同的出现次数，之后比较 map 与 set 的 size 即可得出是否为独一无二的次数。

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


class Solution {
public:
 bool uniqueOccurrences(vector<int>& arr) {
 map<int, int> m;
 for (auto i : arr) {
 m[i]++;
 }
 set<int> s;
 for (auto [k, v] : m) {
 s.insert(v);
 }
 return m.size() == s.size();
 }
};

LeetCode 75系列 - 2215. 找出两数组的不同

Wed, 07 May 2025 22:50:00 +0800

题目描述

给你两个下标从 0 开始的整数数组 nums1 和 nums2 ，请你返回一个长度为 2 的列表 answer ，其中：

answer[0] 是 nums1 中所有不存在于 nums2 中的不同整数组成的列表。
answer[1] 是 nums2 中所有不存在于 nums1 中的不同整数组成的列表。

**注意：**列表中的整数可以按任意顺序返回。

示例 1：

1
2
3
4
5


输入：nums1 = [1,2,3], nums2 = [2,4,6]
输出：[[1,3],[4,6]]
解释：
对于 nums1 ，nums1[1] = 2 出现在 nums2 中下标 0 处，然而 nums1[0] = 1 和 nums1[2] = 3 没有出现在 nums2 中。因此，answer[0] = [1,3]。
对于 nums2 ，nums2[0] = 2 出现在 nums1 中下标 1 处，然而 nums2[1] = 4 和 nums2[2] = 6 没有出现在 nums2 中。因此，answer[1] = [4,6]。

示例 2：

1
2
3
4
5


输入：nums1 = [1,2,3,3], nums2 = [1,1,2,2]
输出：[[3],[]]
解释：
对于 nums1 ，nums1[2] 和 nums1[3] 没有出现在 nums2 中。由于 nums1[2] == nums1[3] ，二者的值只需要在 answer[0] 中出现一次，故 answer[0] = [3]。
nums2 中的每个整数都在 nums1 中出现，因此，answer[1] = [] 。

提示：

1 <= nums1.length, nums2.length <= 1000
-1000 <= nums1[i], nums2[i] <= 1000

题解

通过 set 容器进行去重，然后利用 set 容器的find()或者count()函数判断是否存在该元素，不存在则放入vector 中。

 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


class Solution {
public:
 vector<vector<int>> findDifference(vector<int>& nums1, vector<int>& nums2) {
 set<int> s1;
 set<int> s2;
 vector<int> r1;
 vector<int> r2;
 for (int i = 0; i < nums1.size(); ++i) {
 s1.insert(nums1[i]);
 }
 for (int i = 0; i < nums2.size(); ++i) {
 s2.insert(nums2[i]);
 }
 for (int num : s1) {
 if (s2.count(num) == 0) {
 r1.push_back(num);
 }
 }
 for (int num : s2) {
 if (s1.count(num) == 0) {
 r2.push_back(num);
 }
 }

 return {r1, r2};
 }
};

LeetCode 75系列 - 724. 寻找数组的中心下标

Tue, 06 May 2025 21:50:00 +0800

题目描述

给你一个整数数组 nums ，请计算数组的 中心下标 。

数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。

如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。

如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。

示例 1：

1
2
3
4
5
6


输入：nums = [1, 7, 3, 6, 5, 6]
输出：3
解释：
中心下标是 3 。
左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，
右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。

示例 2：

1
2
3
4


输入：nums = [1, 2, 3]
输出：-1
解释：
数组中不存在满足此条件的中心下标。

示例 3：

1
2
3
4
5
6


输入：nums = [2, 1, -1]
输出：0
解释：
中心下标是 0 。
左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），
右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。

提示：

1 <= nums.length <= 104
-1000 <= nums[i] <= 1000

题解

解法一

这题可以采取暴力求解法，通过遍历计算左侧数之和与右侧数之和进行比较得出中心下标。

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


class Solution {
public:
 int pivotIndex(vector<int>& nums) {
 int size = nums.size();
 int leftSum{};

 for (int i = 0; i < size; ++i) {
 leftSum += nums[i];
 int rightSum{};
 for (int j = i; j < size; ++j) {
 rightSum += nums[j];
 }
 if (leftSum == rightSum)
 return i;
 }
 return -1;
 }
};

解法二

可以基于解法一进行优化，优化后的解法通过 前缀和 的思想，避免了嵌套循环，从而将时间复杂度从 O(n^2) 降低到 O(n)。

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


class Solution {
public:
 int pivotIndex(vector<int>& nums) {
 int size = nums.size();
 int leftSum{};
 int sum{};
 for (int i = 0; i < size; ++i) {
 sum += nums[i];
 }
 for (int i = 0; i < size; ++i) {
 leftSum += nums[i];
 if (leftSum == sum - leftSum + nums[i])
 return i;
 }
 return -1;
 }
};

LeetCode 75系列 - 1732. 找到最高海拔

Sun, 27 Apr 2025 22:40:00 +0800

题目描述

有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。

给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 <= i < n）。请你返回 最高点的海拔 。

示例 1：

1
2
3


输入：gain = [-5,1,5,0,-7]
输出：1
解释：海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。

示例 2：

1
2
3


输入：gain = [-4,-3,-2,-1,4,3,2]
输出：0
解释：海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。

提示：

n == gain.length
1 <= n <= 100
-100 <= gain[i] <= 100

题解

累计海拔高度：
- 初始海拔为 0，每次根据 gain[i] 更新当前海拔高度。
- 累计海拔高度公式：sum[i] = sum[i-1] + gain[i-1]。
最高海拔：
- 在每次更新累计海拔高度后，检查当前海拔是否为最高值。
- 使用 std::max 函数动态更新最高海拔。

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


class Solution {
public:
 int largestAltitude(vector<int>& gain) {
 int re{}; // 记录骑行过程中到达的最高海拔
 int sum{}; // 记录当前的累计海拔高度
 for (int x: gain) {
 sum += x;
 re = std::max(re, sum);
 }
 return re;
 }
};

LeetCode 75系列 - 1493. 删掉一个元素以后全为 1 的最长子数组

Sat, 26 Apr 2025 22:00:00 +0800

题目描述

给你一个二进制数组 nums ，你需要从中删掉一个元素。

请你在删掉元素的结果数组中，返回最长的且只包含 1 的非空子数组的长度。

如果不存在这样的子数组，请返回 0 。

提示 1：

1
2
3


输入：nums = [1,1,0,1]
输出：3
解释：删掉位置 2 的数后，[1,1,1] 包含 3 个 1 。

示例 2：

1
2
3


输入：nums = [0,1,1,1,0,1,1,0,1]
输出：5
解释：删掉位置 4 的数字后，[0,1,1,1,1,1,0,1] 的最长全 1 子数组为 [1,1,1,1,1] 。

示例 3：

1
2
3


输入：nums = [1,1,1]
输出：2
解释：你必须要删除一个元素。

提示：

1 <= nums.length <= 105
nums[i] 要么是 0 要么是 1 。

题解

核心问题为「以第 i−1 位结尾的最长连续全 1 子数组」和「以第 i+1 位开头的最长连续全 1 子数组」的长度。

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


class Solution {
public:
 int longestSubarray(vector<int>& nums) {
 int n = nums.size();
 vector<int> pre(n), suf(n);
 pre[0] = nums[0];
 suf[n - 1] = nums[n - 1];

 // 顺序
 for (int i = 1; i < n; ++i) {
 // index 为 i 时，当前顺序全1长度
 pre[i] = nums[i] ? pre[i - 1] + 1 : 0;
 }

 // 逆序
 for (int i = n - 2; i >= 0; --i) {
 // index 为 i 时，当前逆序全1长度
 suf[i] = nums[i] ? suf[i + 1] + 1 : 0;
 }

 int sum{};
 for (int i = 0; i < n; ++i) {
 // 删除位置 i 后，左侧连续 1 的长度
 int preSum = i == 0 ? 0 : pre[i - 1];
 // 删除位置 i 后，右侧连续 1 的长度
 int sufSum = i == n - 1 ? 0 : suf[i + 1];
 // 将 preSum 和 sufSum 相加，表示删除位置 i 后，左右两侧连续 1 的总长度。
 sum = std::max(sum, preSum + sufSum);
 }
 return sum;
 }
};

Qt QDialog 源码解析 - open()、exec() 和 show() 方法的区别

Wed, 12 Mar 2025 22:11:39 +0800

前言

在 Qt 框架中，QDialog 用于创建对话框。它提供了三种主要的显示方法：open()、exec() 和 show()。这些方法虽然都能显示对话框，但在行为和使用场景上有很大区别。本文将通过分析 QDialog 源码，深入理解这三个方法的区别及其适用场景。

QDialog 的显示方法简述

首先，让我们简要了解这三种方法：

show()：非模态显示对话框
open()：窗口模态显示对话框，立即返回
exec()：模态显示对话框，阻塞直到用户关闭

show () 方法解析

show() 是 QWidget 的方法，QDialog 继承了此方法：

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


void QWidget::show()
{
 Qt::WindowState defaultState = QGuiApplicationPrivate::platformIntegration()->defaultWindowState(data->window_flags);
 if (defaultState == Qt::WindowFullScreen)
 showFullScreen();
 else if (defaultState == Qt::WindowMaximized)
 showMaximized();
 else
 setVisible(true); // Don't call showNormal() as not to clobber Qt::Window(Max/Min)imized
}

void QWidget::setVisible(bool visible)
{
 if (testAttribute(Qt::WA_WState_ExplicitShowHide) && testAttribute(Qt::WA_WState_Hidden) == !visible)
 return;

 // Remember that setVisible was called explicitly
 setAttribute(Qt::WA_WState_ExplicitShowHide);

 Q_D(QWidget);
 d->setVisible(visible);
}

特点：

非模态显示（默认情况下）
立即返回，不阻塞调用线程
用户可以与应用程序的其他窗口交互
不会自动创建事件循环

示例：

1
2
3


QDialog *dialog = new QDialog(this);
// 设置对话框内容...
dialog->show();

open () 方法解析

open() 是 Qt 4.5 引入的方法，用于显示窗口模态对话框：

 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


void QDialog::open()
{
 Q_D(QDialog);

 // 获取对话框当前的窗口模态类型
 Qt::WindowModality modality = windowModality();
 // 然后检查是否已经是窗口模态（Qt::WindowModal）。如果不是窗口模态，则修改当前的模态设置
 if (modality != Qt::WindowModal) {
 // 保存原来的模态类型
 d->resetModalityTo = modality;
 // 记录WA_SetWindowModality属性是否被设置
 d->wasModalitySet = testAttribute(Qt::WA_SetWindowModality);
 setWindowModality(Qt::WindowModal);
 // 清除WA_SetWindowModality属性，表示这个模态状态不是由用户显式设置的
 setAttribute(Qt::WA_SetWindowModality, false);
#ifdef Q_OS_MAC
 // 在 macOS 上，对话框被设置为 Sheet 样式，这是 macOS 特有的窗口模态对话框视觉样式。
 setParent(parentWidget(), Qt::Sheet);
#endif
 }

 // 将对话框结果重置为0
 setResult(0);
 show();
}

特点：

窗口模态显示（阻止与父窗口的交互）
立即返回，不阻塞调用线程
保存原有模态状态，然后设置为窗口模态
异步操作，适合基于信号-槽的事件处理

示例：

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


QDialog *dialog = new QDialog(this);
// 设置对话框内容...
// 关联信号槽
connect(dialog, &QDialog::finished, this, &MyWidget::handleDialogResult);
dialog->open();


MyWidget::handleDialogResult(int result)
{
 if (result == QDialog::Accepted)
 // ...
 else if (result == QDialog::Rejected)
 // ...
}

exec () 方法解析

exec() 是最传统的对话框显示方法，用于显示模态对话框：

 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


int QDialog::exec()
{
 Q_D(QDialog);

 // 检测是否发生了递归调用 exec()。如果对话框已经有一个事件循环在运行（即 d->eventLoop 不为空），则发出警告并返回 -1。
 if (Q_UNLIKELY(d->eventLoop)) {
 qWarning("QDialog::exec: Recursive call detected");
 return -1;
 }

 // 保存并暂时禁用 Qt::WA_DeleteOnClose 属性，确保对话框在关闭时不会被自动删除
 bool deleteOnClose = testAttribute(Qt::WA_DeleteOnClose);
 setAttribute(Qt::WA_DeleteOnClose, false);

 // 重置由 open() 方法设置的模态性设置
 d->resetModalitySetByOpen();

 // 记录并设置 Qt::WA_ShowModal 属性，表明这是一个模态对话框
 bool wasShowModal = testAttribute(Qt::WA_ShowModal);
 setAttribute(Qt::WA_ShowModal, true);
 // 将对话框结果重置为 0
 setResult(0);

 // 显示对话框并创建事件循环
 show();

 QPointer<QDialog> guard = this;
 // 检查是否使用本地对话框实现：
 // - 如果使用本地对话框，调用平台辅助对象的 exec()
 // - 否则，创建并执行一个本地事件循环，这会阻塞当前线程，直到调用 QEventLoop::exit() 或 QEventLoop::quit()
 if (d->nativeDialogInUse) {
 d->platformHelper()->exec();
 } else {
 QEventLoop eventLoop;
 d->eventLoop = &eventLoop;
 // 使用标志 QEventLoop::DialogExec，这是专门为对话框执行设计的模式。
 (void) eventLoop.exec(QEventLoop::DialogExec);
 }
 if (guard.isNull())
 return QDialog::Rejected;
 d->eventLoop = nullptr;

 // 恢复状态
 setAttribute(Qt::WA_ShowModal, wasShowModal);

 int res = result();
 if (d->nativeDialogInUse)
 d->helperDone(static_cast<QDialog::DialogCode>(res), d->platformHelper());
 if (deleteOnClose)
 delete this;
 return res;
}

特点：

模态显示（默认为应用程序模态）
阻塞调用线程，直到对话框关闭
创建并执行本地事件循环
返回对话框的结果代码（QDialog::Accepted 或 QDialog::Rejected）
支持防止递归调用的检测
可以防止对话框在显示期间被删除

示例：

1
2
3
4
5
6
7


QDialog dialog(this);
// 设置对话框内容...
if (dialog.exec() == QDialog::Accepted) {
 // 处理接受的情况
} else {
 // 处理拒绝的情况
}

最佳实践建议

在源码中，Qt 官方明确推荐使用 open() 而非 exec()：

\note Avoid using this function; instead, use \c{open()}. Unlike exec(), open() is asynchronous, and does not spin an additional event loop. This prevents a series of dangerous bugs from happening (e.g. deleting the dialog’s parent while the dialog is open via exec()). When using open() you can connect to the finished() signal of QDialog to be notified when the dialog is closed.

虽然官方推荐使用 open()，但是需要注意的是，在 macOS 平台上，会启用 Sheet 样式，会有系统默认遮罩。如果项目自身实现了遮罩，会和系统默认遮罩叠加，还会有窗口闪烁的情况。

而 exec() 存在无法从 DialogA 里再创建一个 DialogB 时，先隐藏 DialogA，当 DialogB 完成时，再将 DialogA 显示出来的问题。

结论

通过对 QDialog 源码的分析，我们深入理解了 open()、exec() 和 show() 三种方法的工作原理和区别，从而在实际工程使用时，能够合理选择不同的方法。

在C++中实现Rust风格的Result类型

Tue, 25 Feb 2025 11:29:06 +0800

前言

Rust 的 Result 类型是一种优雅的错误处理机制，它强制开发者显式处理成功和失败两种状态，避免了未检查异常带来的不确定性。在 C++中，虽然可以通过异常或错误码实现类似功能，但 Result 类型提供了一种更结构化的方式，尤其适用于需要明确错误路径的项目。

本文介绍一个基于 C++的 Result 实现，其设计灵感来自 Rust。

Rust 的 Result 类型分析

在 Rust 语言中，Result 是一种非常重要的类型，用于表示函数执行的结果，它允许开发者优雅地处理成功和失败的情况，同时避免了传统编程语言中常见的错误处理问题。

它是一个带有变体的枚举，Ok(T) 表示成功并包含一个值，而 Err(E) 表示错误并包含一个错误值。

1
2
3
4


enum Result<T, E> {
 Ok(T),
 Err(E),
}

在 Rust 中，通常这样使用：

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


fn divide(a: i32, b: i32) -> Result<i32, String> {
 if b == 0 {
 Err(String::from("Cannot divide by zero"))
 } else {
 Ok(a / b)
 }
}

fn main() {
 let result = divide(10, 2);
 match result {
 Ok(value) => println!("Result: {}", value),
 Err(err) => println!("Error: {}", err),
 }
}

除了使用 match 匹配，还有几个主要的方法：

1
2


let result = divide(10, 2);
println!("Result: {}", result.unwrap()); // 输出：Result: 5

unwrap() 方法：如果 Result 是 Ok，则返回内部的值；如果是 Err，则会触发 panic。

1
2


let result = divide(10, 0);
println!("Result: {}", result.unwrap_or(-1)); // 输出：Result: -1

unwrap_or() 方法：如果 Result 是 Ok，则返回内部的值；如果是 Err，则返回一个默认值。

C++的 Rust 实现

Rust 中的 Result 的 Ok(T) 和 Err(E) 是一个范型，最初的实现尝试使用 std::variant<T, E> 存储结果，但遇到了一个关键问题：当 T 和 E 类型相同时，std::variant 无法区分成功和错误值。例如，对于 Result<int, int>，std::variant<int, int> 的两个备选项类型相同，导致无法明确赋值来源。为此，改用 std::any 存储值。

 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


// Result type, similar to Rust Result

#pragma once
#include <any>
#include <iostream>
#include <stdexcept>
#include <string>

// custom exception（optional）
class ResultException final : public std::runtime_error {
 public:
 explicit ResultException(const std::string& message) : std::runtime_error(message) {}
};

template <typename T, typename E = std::string>
class Result {
 private:
 // Using variant is actually better, but when T and E are of the same type, it can cause ambiguity.
 // std::variant<T, E> data;
 std::any ok_;
 std::any err_;

 public:
 // Construct a successful Result
 static Result Ok(T value) {
 Result result;
 result.ok_ = std::move(value);
 return result;
 }

 // Construct a wrong Result
 static Result Err(E error) {
 Result result;
 result.err_ = std::move(error);
 return result;
 }

 // Check if successful
 [[nodiscard]] bool is_ok() const { return ok_.has_value(); }

 // Check if error
 [[nodiscard]] bool is_err() const { return err_.has_value(); }

 // Get the successful value and throw an exception if it is an error
 T unwrap() const {
 if (is_err()) {
 throw ResultException("Unwrapped an Err value");
 }
 return std::any_cast<T>(ok_);
 }

 // Get the error value and throw an exception if successful
 E unwrap_err() const {
 if (is_ok()) {
 throw ResultException("Unwrapped_err on an Ok value");
 }
 return std::any_cast<E>(err_);
 }

 // Get values safely, provide default values
 T unwrap_or(T default_value) const { return is_ok() ? std::any_cast<T>(ok_) : default_value; }

 // Pattern matching style processing
 template <typename OkFunc, typename ErrFunc>
 auto match(OkFunc ok_func, ErrFunc err_func) const {
 if (is_ok()) {
 return ok_func(std::any_cast<T>(ok_));
 } else {
 return err_func(std::any_cast<E>(err_));
 }
 }
};

这里实现一个简洁版本，只保留基本功能，足够简单，不会出错。

实现解析

核心结构：

1
2
3
4
5
6
7


template <typename T, typename E = std::string>
class Result {
 private:
 std::any ok_;
 std::any err_;
 // ...
};

ok_ 和 err_ 分别存储成功值和错误值，通过 has_value() 判断状态。

关键方法：

构造方法

1
2


static Result Ok(T value); // 构造成功结果
static Result Err(E error); // 构造错误结果

状态检查

1
2


[[nodiscard]] bool is_ok() const;
[[nodiscard]] bool is_err() const;

值提取
- unwrap()：返回成功值，若为错误则抛出 ResultException。
- unwrap_err()：返回错误值，若为成功则抛出异常。
- unwrap_or(T default_value)：安全提取值，提供默认回退。

模式匹配

1
2


template <typename OkFunc, typename ErrFunc>
auto match(OkFunc ok_func, ErrFunc err_func) const;

根据状态调用对应的函数，类似于 Rust 的 match 语法。

用法

用法也很简单：

 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


#include <print> // C++ 23

Result<int, std::string> divide(int numerator, int denominator) {
 if (denominator == 0) {
 return Result<int, std::string>::Err("Division by zero");
 }
 return Result<int, std::string>::Ok(numerator / denominator);
}

int main() {
 // success
 auto success_result = divide(10, 2);
 success_result.match(
 [](int value) { std::println("Success: {}", value); },
 [](const std::string& err) { std::println("Error: {}", err); }
 );
 std::println("is_ok:{} is_err:{} unwrap:{}", success_result.is_ok(), success_result.is_err(),
 success_result.unwrap());
 // wrong
 auto error_result = divide(10, 0);
 error_result.match(
 [](int value) { std::println("Success: {}", value); },
 [](const std::string& err) { std::println("Error: {}", err); }
 );
 std::println("is_ok:{} is_err:{} unwrap_err:{}", error_result.is_ok(), error_result.is_err(),
 error_result.unwrap_err());

 // methond 2
 if(auto result = divide(10, 2); re.is_ok()) {
 std::println("Success: {}", re.unwrap());
 }
 else {
 std::println("Error: {}", re.unwrap_err());
 }
 return 0;
}

总结

Rust 的 Result 是一个不错的类型，可以有效解决返回值的问题，能够携带正确值或者错误信息。这里通过 std::any 实现的 Result 类型提供了一种灵活的错误处理机制，尤其适用于 T 和 E 类型可能相同的场景。

更新：好消息是在 C++23 中，增加了 std::expected 类型，这是官方实现的类似 Rust 的 Result 类型。相关用法也是一样：

 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


enum class parse_error
{
 invalid_input,
 overflow
};

auto parse_number(std::string_view& str) -> std::expected<double, parse_error>
{
 const char* begin = str.data();
 char* end;
 double retval = std::strtod(begin, &end);

 if (begin == end)
 return std::unexpected(parse_error::invalid_input);
 else if (std::isinf(retval))
 return std::unexpected(parse_error::overflow);

 str.remove_prefix(end - begin);
 return retval;
}

int main()
{
 auto process = [](std::string_view str)
 {
 std::cout << "str: " << std::quoted(str) << ", ";
 if (const auto num = parse_number(str); num.has_value())
 std::cout << "value: " << *num << '\n';
 // If num did not have a value, dereferencing num
 // would cause an undefined behavior, and
 // num.value() would throw std::bad_expected_access.
 // num.value_or(123) uses specified default value 123.
 else if (num.error() == parse_error::invalid_input)
 std::cout << "error: invalid input\n";
 else if (num.error() == parse_error::overflow)
 std::cout << "error: overflow\n";
 else
 std::cout << "unexpected!\n"; // or invoke std::unreachable();
 };

 for (auto src : {"42", "42abc", "meow", "inf"})
 process(src);
}

https://zh.cppreference.com/w/cpp/utility/variant

https://zh.cppreference.com/w/cpp/utility/any

https://github.com/oktal/result

Windows 包管理利器：winget 快速入门指南

Sat, 15 Feb 2025 21:23:07 +0800

什么是 winget

winget 是微软官方推出的 Windows 包管理工具。

通过简单的命令即可实现：

✅ 快速搜索/安装软件 ✅ 批量管理应用程序 ✅ 自动升级所有程序

相比传统安装方式，具有以下优势：

避免浏览器搜索下载的繁琐流程
支持静默安装（无界面干扰）
方便系统管理员批量部署
完全免费且官方维护软件源

类似 Linux 的 apt/yum，macOS 的 brew，是提升 Windows 生产力的必备工具

注意：WinGet 命令行工具仅在 Windows 10 1709（版本 16299）或更高版本上受支持。

查看本机是否存在 winget：

1

winget --version

快速入门

以安装 PowerToys 为例：

先搜索 PowerToys：

1
2
3
4
5
6
7


$➜ winget search powertoys
名称 ID 版本 匹配 源
--------------------------------------------------------------------------------------------------
Microsoft PowerToys XP89DCGQ3K6VLD Unknown msstore
PowerToys Microsoft.PowerToys 0.88.0 winget
EverythingPowerToys lin-ycv.EverythingPowerToys 0.88.0 Tag: powertoys winget
PowerToys-Run-Currency-Converter advaith.CurrencyConverterPowerToys 1.5.2 Tag: PowerToys winget

安装

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 通过ID安装
winget install Microsoft.PowerToys

# 根据显式指定 ID 安装相应应用程序
winget install --id Microsoft.PowerToys

# 安装特定版本
winget install powertoys --version 0.15.2

# 静默安装（无确认提示）
winget install -h Microsoft.PowerToys --silent

升级：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


winget upgrade PowerShell

#升级特定版本的应用程序
winget upgrade powertoys --version 0.15.2

# 根据应用程序 ID 升级相应的应用程序
winget upgrade --id Microsoft.PowerToys

# 升级所有应用
winget upgrade --all

list 命令可查看已安装的、具有可用更新的应用：

1
2


# 列出所有安装的程序
winget list

列出特定的应用程序

1

winget list --name git

按 ID 列出来自特定源的所有应用程序：

1

 winget list --id Git.Git --source winget

show 命令显示指定应用程序的详细信息，包括有关该应用程序的源以及与该应用程序关联的元数据的详细信息。

基础命令速查表

命令	功能	示例
`winget search <软件名>`	搜索软件	`winget search chrome`
`winget install <ID>`	安装软件	`winget install 7zip.7zip`
`winget upgrade`	查看可升级软件	`winget upgrade`
`winget upgrade --all`	升级所有软件	需要管理员权限
`winget uninstall <ID>`	卸载软件	`winget uninstall Spotify.Spotify`
`winget list`	查看已安装软件	支持导出为 JSON/CSV
`winget show <ID>`	显示软件详情	查看版本/描述信息

使用 WinGet 安装和管理应用程序 | Microsoft Learn

C++ std::async 异步编程深入剖析

Thu, 16 Jan 2025 23:00:26 +0800

前言

在现代 C++ 编程中，异步编程是一个不可或缺的组成部分，它能够显著提升程序的性能。std::async 作为 C++ 标准库中实现异步操作的重要函数模板，为开发者提供了一种简洁而强大的方式来运行异步任务。本文将深入探讨 std::async 的功能、用法以及不同编译器实现之间的差异，更好地理解和使用这一强大的工具。

`std::async` 基础用法

std::async 定义在 <future> 头文件中，其基本功能是异步地运行一个函数，并返回一个 std::future 对象，该对象保存函数调用返回的结果。

std::async 的声明：

1
2
3
4
5
6
7


template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
 async(Fn&& fn, ArgTypes&&... args);

template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
 async(launch policy, Fn&& fn, ArgTypes&&... args);

在第二个声明中，可以指定启动策略。std::launch 是一个枚举类。

launch::defered：表明函数调用延迟到 wait () 或 get () 函数调用时才执行。
launch::async：表明函数在新的独立线程上执行。（这个新线程可能是从线程池中获取的，也可能是新创建的，具体取决于编译器的实现。）
launch::deferred | launch::async：std::async 的默认参数，系统会自行决定异步（创建新线程）还是同步（不创建新线程）方式运行。

基本用法如下：

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


int foo(int a) {
 return a;
}

int main() {
 // 默认策略
 std::future<int> f = std::async(&foo, 10);

 // 新线程启动
 std::future<int> f1 = std::async(std::launch::async, []() { return 0; });

 // 延迟调用
 std::future<int> f2 = std::async(std::launch::deferred, []() { return 0; });

 std::println("result is: {}", f.get());
 std::println("result is: {}", f1.get());
 std::println("result is: {}", f2.get());
 return 0;
}

基本用法不做过多描述，接下来重点分析 std::async 细节部分。

`std::async` 策略深入分析

C++ 标准并没有明确规定 std::async 的默认策略，但大多数编译器实现（如 GCC、LLVM 和 MSVC）都选择了 std::launch::async | std::launch::deferred 作为默认策略。那么，不同平台的默认策略，最终是执行的什么策略呢？

GCC 平台

在 GCC 中，默认选项是 launch::async|launch::deferred:

1
2
3
4
5
6
7
8
9


/// async, potential overload
template<typename _Fn, typename... _Args>
 _GLIBCXX_NODISCARD inline future<__async_result_of<_Fn, _Args...>>
 async(_Fn&& __fn, _Args&&... __args)
 {
 return std::async(launch::async|launch::deferred,
 std::forward<_Fn>(__fn),
 std::forward<_Args>(__args)...);
 }

实际上，选择的策略将是 launch::async：

 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


 /// async
 template<typename _Fn, typename... _Args>
 _GLIBCXX_NODISCARD future<__async_result_of<_Fn, _Args...>>
 async(launch __policy, _Fn&& __fn, _Args&&... __args)
 {
 std::shared_ptr<__future_base::_State_base> __state;
 if ((__policy & launch::async) == launch::async)
 {
 __try
 {
 __state = __future_base::_S_make_async_state(
 std::thread::__make_invoker(std::forward<_Fn>(__fn),
 std::forward<_Args>(__args)...)
 );
 }
#if __cpp_exceptions
 catch(const system_error& __e)
 {
 if (__e.code() != errc::resource_unavailable_try_again
 || (__policy & launch::deferred) != launch::deferred)
 throw;
 }
#endif
 }
 if (!__state)
 {
 __state = __future_base::_S_make_deferred_state(
 std::thread::__make_invoker(std::forward<_Fn>(__fn),
 std::forward<_Args>(__args)...));
 }
 return future<__async_result_of<_Fn, _Args...>>(__state);
 }

LLVM

LLVM 对于默认选项有一个特别的启动策略 launch::any ：

1
2
3
4
5
6
7
8


template <class _Fp, class... _Args>
_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
async(_Fp&& __f, _Args&&... __args)
{
 return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f),
 _VSTD::forward<_Args>(__args)...);
}

实际上，就是 launch::async 和 launch::deferred 的组合。

1
2
3
4
5
6


enum class launch
{
 async = 1,
 deferred = 2,
 any = async | deferred
};

而 LLVM 实际选择的策略将是 launch::async ：

 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


template <class _Fp, class... _Args>
_LIBCPP_NODISCARD_AFTER_CXX17
future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
async(launch __policy, _Fp&& __f, _Args&&... __args)
{
 typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF;
 typedef typename _BF::_Rp _Rp;

#ifndef _LIBCPP_NO_EXCEPTIONS
 try
 {
#endif
 if (__does_policy_contain(__policy, launch::async))
 return _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
 __decay_copy(_VSTD::forward<_Args>(__args))...));
#ifndef _LIBCPP_NO_EXCEPTIONS
 }
 catch ( ... ) { if (__policy == launch::async) throw ; }
#endif

 if (__does_policy_contain(__policy, launch::deferred))
 return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
 __decay_copy(_VSTD::forward<_Args>(__args))...));
 return future<_Rp>{};
}

MSVC

对于 MSVC 的默认选项，也是 launch::async | launch::deferred：

1
2
3
4
5
6


_EXPORT_STD template <class _Fty, class... _ArgTypes>
_NODISCARD_ASYNC future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(
 _Fty&& _Fnarg, _ArgTypes&&... _Args) {
 // manages a callable object launched with default policy
 return _STD async(launch::async | launch::deferred, _STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...);
}

而选择的策略，即 launch::async ：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


template <class _Ret, class _Fty>
_Associated_state<typename _P_arg_type<_Ret>::type>* _Get_associated_state(launch _Psync, _Fty&& _Fnarg) {
 // construct associated asynchronous state object for the launch type
 switch (_Psync) { // select launch type
 case launch::deferred:
 return new _Deferred_async_state<_Ret>(_STD forward<_Fty>(_Fnarg));
 case launch::async: // TRANSITION, fixed in vMajorNext, should create a new thread here
 default:
 return new _Task_async_state<_Ret>(_STD forward<_Fty>(_Fnarg));
 }
}

`std::launch::async` 深入分析

我们知道，std::launch::async 表明函数在新的独立线程上执行。但是，C++ 标准没有指定线程是新线程还是从线程池中重用的线程。

GCC

GCC 调用 __future_base::_S_make_async_state ，这会创建一个 _Async_state_impl 的实例。它的构造函数启动一个新的 std::thread：

 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


// Shared state created by std::async().
// Starts a new thread that runs a function and makes the shared state ready.
template<typename _BoundFn, typename _Res>
 class __future_base::_Async_state_impl final
 : public __future_base::_Async_state_commonV2
 {
 public:
 explicit
 _Async_state_impl(_BoundFn&& __fn)
 : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
 {
 _M_thread = std::thread{ [this] {
 __try
 {
 _M_set_result(_S_task_setter(_M_result, _M_fn));
 }
 __catch (const __cxxabiv1::__forced_unwind&)
 {
 // make the shared state ready on thread cancellation
 if (static_cast<bool>(_M_result))
 this->_M_break_promise(std::move(_M_result));
 __throw_exception_again;
 }
 } };
 }

LLVM

LLVM 调用 _VSTD::__make_async_assoc_state ，同样的，也是启动一个新的 std::thread：

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


template <class _Rp, class _Fp>
future<_Rp>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__make_async_assoc_state(_Fp&& __f)
#else
__make_async_assoc_state(_Fp __f)
#endif
{
 unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count>
 __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
 _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
 return future<_Rp>(__h.get());
}

MSVC

最有趣的地方来了！MSVC 创建了一个 _Task_async_state 的实例，它创建了一个并发任务并传递了一个可调用函数：

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


// CLASS TEMPLATE _Task_async_state
template <class _Rx>
class _Task_async_state : public _Packaged_state<_Rx()> {
 // class for managing associated synchronous state for asynchronous execution from async
public:
 using _Mybase = _Packaged_state<_Rx()>;
 using _State_type = typename _Mybase::_State_type;

 template <class _Fty2>
 _Task_async_state(_Fty2&& _Fnarg) : _Mybase(_STD forward<_Fty2>(_Fnarg)) {
 _Task = ::Concurrency::create_task([this]() { // do it now
 this->_Call_immediate();
 });

 this->_Running = true;
 }

::Concurrency::create_task 是微软并行模式库的一部分。根据 MSDN 文档， task 类从 Windows ThreadPool 获取线程，而不是创建一个新线程。

所以这里需要注意一点，基于 ThreadPool 的实现，不能保证线程完成时会销毁 thread_local 变量。因为从线程池获取的线程不会销毁。所以，你会发现，使用了std::async后，线程并未销毁释放。这里相当于是从系统线程池借入了一个线程，会计算到用户线程数量中，而这个线程并未释放，导致的现象是使用std::async越多，线程越多。

std::async 执行的并发线程数限制为 Windows 线程池默认值，即 500 个线程。

`std::async` 返回的 `std::future` 深入分析

在 cppreference 中：

如果从 std::async 获得的 std::future 没有被移动或绑定到引用，那么在完整表达式结尾， std::future 的析构函数将阻塞到异步计算完成，实质上令如下代码同步：
1
2
std::async(std::launch::async, []{ f(); }); // 临时量的析构函数等待 f()
std::async(std::launch::async, []{ g(); }); // f() 完成前不开始
注意：以调用 std::async 以外的方式获得的 std::future 的析构函数不会阻塞。

即 std::async 返回的 std::future 在调用其析构函数时的行为与从 std::promise 获得的 std::future 不同。当这些 std::future 销毁时，会调用 std::future 的析构函数，会执行 wait() 函数，使得创建时生成的线程汇入主线程。

这里以 MSVC 代码为例：

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


~_Task_async_state() noexcept override {
 _Wait();
}

void _Wait() override { // wait for completion
 _Task.wait();
}

void WaitUntilStateChangedTo(_TaskCollectionState _State)
{
 ::std::unique_lock<::std::mutex> _Lock(_M_Cs);

 while(_M_State < _State)
 {
 _M_StateChanged.wait(_Lock);
 }
}

_Task_async_state 析构时，会调用 wait()，最终堆栈到 _M_StateChanged.wait(_Lock);，这是条件变量的wait()。

不同平台实现方式不同，GCC 和 LLVM 中：

1
2
3
4
5


 ~_Async_state_impl()
 {
if (_M_thread.joinable())
 _M_thread.join();
 }

析构时，在等待线程join()执行结束。

总结

std::async 是 C++ 标准库中一个线程高级抽象工具，它简化了异步操作的实现，并使代码更加简洁。然而，由于不同编译器实现之间的差异，开发者在使用时需要谨慎考虑这些因素，以避免潜在的问题。特别需要注意 thread_local 和返回的std::future。

Implementations of std::async and how they might Affect Applications | Dmitry Danilov

functions | Microsoft Learn

std::async - cppreference.com

《Asynchronous Programming with C++》

LeetCode 75系列 - 1004. 最大连续1的个数 III

Mon, 04 Nov 2024 22:50:00 +0800

题目描述

给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数 。

示例 1：

1
2
3
4


输入：nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
解释：[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 6。

示例 2：

1
2
3
4


输入：nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出：10
解释：[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 10。

提示：

1 <= nums.length <= 105
nums[i] 不是 0 就是 1
0 <= k <= nums.length

题解

这道题的思路是使用滑动窗口，然后寻找最长为1的子数组，同时需要考虑为0的时候可以反转为1，也就是当0的个数在k以内，可以算在最长为1的数组里。

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


class Solution {
public:
 int longestOnes(vector<int>& nums, int k) {
 int max = {};
 int left{};
 int num{};
 for (int right = 0; right < nums.size(); ++right) {
 // 当前位置为0时，记录0的个数
 if (nums[right] == 0) {
 num++;
 }
 // 当0的个数超过k时，移动left位置，同时判断当前位置是否为0，如果是，则减一
 if (num > k) {
 if (nums[left++] == 0)
 num--;
 }
 // right - left + 1为最长为1的长度（含k个0）
 max = std::max(max, right - left + 1);
 }
 return max;
 }
};

LeetCode 75系列 - 1456. 定长子串中元音的最大数目

Sun, 03 Nov 2024 22:40:00 +0800

题目描述

给你字符串 s 和整数 k 。

请返回字符串 s 中长度为 k 的单个子字符串中可能包含的最大元音字母数。

英文中的 元音字母 为（a, e, i, o, u）。

示例 1：

1
2
3


输入：s = "abciiidef", k = 3
输出：3
解释：子字符串 "iii" 包含 3 个元音字母。

示例 2：

1
2
3


输入：s = "aeiou", k = 2
输出：2
解释：任意长度为 2 的子字符串都包含 2 个元音字母。

示例 3：

1
2
3


输入：s = "leetcode", k = 3
输出：2
解释："lee"、"eet" 和 "ode" 都包含 2 个元音字母。

示例 4：

1
2
3


输入：s = "rhythms", k = 4
输出：0
解释：字符串 s 中不含任何元音字母。

示例 5：

1
2


输入：s = "tryhard", k = 4
输出：1

提示：

1 <= s.length <= 10^5
s 由小写英文字母组成
1 <= k <= s.length

题解

思路：使用滑动窗口，依次遍历，然后取得最大值。

解法一：

 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 Solution {
public:
 int maxVowels(string s, int k) {
 // 创建映射表，便于以logn的复杂度查找
 std::set<char> vowel{'a', 'e', 'i', 'o', 'u'};
 int begin{};
 int end = k;
 int max{};

 while (end <= s.size()) {
 int num{};
 for (int i = begin; i < end; ++i) {
 if (auto it = vowel.find(s[i]); it != vowel.end()) {
 num++;
 }
 }
 begin++;
 end++;
 if (num > max)
 max = num;
 }
 return max;
 }
};

这个解法的问题是时间复杂度过高，导致超时。

解法二：

这里封装了一个函数，用于方便判断是否为元音字母。同时将vowel映射设置为内联静态成员变量，以提高性能。

 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


class Solution {
 inline static std::set<char> vowel{'a', 'e', 'i', 'o', 'u'};
 bool isVowel(char c) {
 if (auto it = vowel.find(c); it != vowel.end()) {
 return true;
 }
 return false;
 }

public:
 int maxVowels(string s, int k) {
 int max{};
 for (int i = 0; i < k; i++) {
 if (isVowel(s[i])) {
 max++;
 }
 }
 int num = max;
 for (int i = k; i < s.size(); ++i) {
 if (isVowel(s[i - k])) {
 num--;
 }
 if (isVowel(s[i])) {
 num++;
 }

 // 比较交换最大数值
 max = std::max(num, max);
 }
 return max;
 }
};

Windows C++使用UTF-8编码

Sun, 27 Oct 2024 10:28:43 +0800

前言

在 Windows 平台上，C++开发过程中处理文本时，涉及到 Unicode 字符时，是一件很头疼的事。因为 Windows 上，会有窄字符和宽字符概念。

如果仅在 Windows 平台开发应用，那么可以按照微软的规范来做。但是当你的应用定位跨平台或国际化应用时，这个问题就很棘手了，容易造成乱码问题。

UTF-8 是一种国际化编码标准，能够同时支持全球所有主要语言。在许多 Unix 系统（例如 Linux 和 macOS）上，UTF-8 是默认的编码格式，因此对于跨平台的应用程序，使用 UTF-8 可以简化编码转换，减少跨平台时的兼容性问题。

所以本文将讨论如何在 Windows 平台使用 UTF-8 编码。至于为什么在 Windows 上选择 UTF-8，可以参考文章：UTF-8 Everywhere

Windows 上采用 UTF-8 的解决方案

方案一：使用 Wide API

Windows 提供了 Wide（宽字符）API（例如 CreateFileW()、ReadFileW() 等）来处理 UTF-16 编码的字符串。使用这些 API 可以绕开 ANSI 代码页的限制，确保 Unicode 字符能够被正确处理。具体来说，使用 wchar_t 数据类型并通过 UTF-16 编码方式，可以实现字符的正确读取和写入。

实现一个宽字符转换函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


std::wstring utf8_to_wchar(const char* str)
{
 int len = MultiByteToWideChar(CP_UTF8, 0, str, (int) strlen(str), NULL, 0);
 wchar_t* wc = new wchar_t[len + 1];
 MultiByteToWideChar(CP_UTF8, 0, str, (int) strlen(str), wc, len);
 wc[len] = '\0';
 std::wstring wstr = wc;
 delete[] wc;
 return wstr;
}

然后在涉及文件 IO 操作时，进行转换：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#ifdef _MSC_VER
 fs::path filepath(char_to_wchar(file.c_str()));
#else
 fs::path filepath(file);
#endif

#ifdef _MSC_VER
 std::ifstream ifs(char_to_wchar("file.txt"), std::ios::binary | std::ios::in);
#else
 std::ifstream ifs("file.txt", std::ios::binary | std::ios::in);
#endif

这种方式需要在临近 API 调用的入口处对 UTF-8 和 UTF-16 进行转换，并且需要使用平台宏区分。

方案二：使用 Boost. Nowide 库

Boost.Nowide库是一个专门为 Windows 设计的库，旨在解决 UTF-8 兼容问题。Boost. Nowide 重载了部分 C++标准库函数，使其能够直接处理 UTF-8 字符串。

例如，使用 Nowide 中的 std::cout 重载，可以在 Windows 控制台中正确显示 UTF-8 字符，ofstream 写入正确的文件名。

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


#include <nowide/iostream.hpp>

int main() {
 nowide::cout << "你好，世界！" << std::endl;

 nowide::ofstream file(filename);
 if (file.is_open()) {
 file << "this is data for test.\n";
 }
 file.close();
 return 0;
}

nowide 库减轻了我们的负担，不需要自行实现转换函数以及在很多地方加入平台宏区分。同时，nowide 有独立于 boost 的版本，standalone 分支，可以直接使用。

我使用 CMake 集成的方式：

1
2
3
4
5
6
7
8
9


include(FetchContent)
FetchContent_Declare(
 nowide
 GIT_REPOSITORY https://github.com/boostorg/nowide.git
 GIT_TAG standalone
)
FetchContent_MakeAvailable(nowide)

target_link_libraries(SimZipTest PRIVATE nowide::nowide)

方案三：指定代码页编码

从 Windows 版本 1903（2019 年 5 月更新）起，可以使用 appxmanifest 中的 ActiveCodePage 属性来强制进程使用 UTF-8 作为进程代码页。

将以下 manifest 文件写入可执行文件里：

1
2
3
4
5
6
7
8
9


<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
 <assemblyIdentity type="win32" name="..." version="6.0.0.0"/>
 <application>
 <windowsSettings>
 <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
 </windowsSettings>
 </application>
</assembly>

name 改为自身的可执行文件名。

使用 mt.exe -manifest <MANIFEST> -outputresource:<EXE>;#1 从命令行向现有可执行文件添加清单。

在 CMake 中，可以直接这样使用：

1
2


add_executable(utf8_demo main.cpp app.manifest)
target_compile_options(utf8_demo PUBLIC /utf-8)

将 manifest 文件写入可执行文件中，同时指定编译器使用 UTF-8 编译。

还可以使用 CMake 创建一个 manifest 文件模版：

app_manifest.xml.in：

1
2
3
4
5
6
7
8
9


<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
 <assemblyIdentity type="win32" name="${TARGET_NAME}" version="6.0.0.0"/>
 <application>
 <windowsSettings>
 <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
 </windowsSettings>
 </application>
</assembly>

然后 CMakeLists. txt 中：

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


set(TARGET_NAME SimZipTest)

if (MSVC)
 # 清单文件的输出路径
 set(MANIFEST_FILE "${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}.manifest")
 # 使用 configure_file 生成清单文件，将 TARGET_NAME 替换为实际目标名称
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/app_manifest.xml.in ${MANIFEST_FILE} @ONLY)
endif ()

# manifest文件加入add_executable()
add_executable(${TARGET_NAME} main.cpp ${MANIFEST_FILE})

if (MSVC)
 # 指定编译器对当前target使用utf-8编译选项
 target_compile_options(${TARGET_NAME} PRIVATE /utf-8)
endif ()

[!note]

GDI 目前不支持为每个进程设置 ActiveCodePage 属性。相反，GDI 默认为活动系统代码页。若要将应用配置为通过 GDI 呈现 UTF-8 文本，请转到 Windows“设置”>“时间和语言”>“语言和区域”>“管理语言设置”>“更改系统区域设置”，然后选中“Beta：使用 Unicode UTF-8 获得全球语言支持”。然后重新启动电脑，使更改生效。

方案四：指定本地环境UTF-8

源码文件使用 UTF-8，指定编译器使用 UTF-8 编译选项，main() 函数指定本地环境为 UTF-8。

CMake 中，指定编译器开启 UTF-8:

1
2
3


if (MSVC)
 target_compile_options(target PRIVATE /utf-8)
else()

在main.cpp指定本地环境：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int main() {
#if _WIN32
 setlocale(LC_ALL, ".utf-8"); // 设置标准库调用系统 API 所用的编码，用于 fopen，ifstream 等函数
 SetConsoleOutputCP(CP_UTF8); // 设置控制台输出编码，或者写 system("chcp 65001") 也行，这里 CP_UTF8 = 65001
#endif
 // 这里开始写你的主程序吧！
 // ...
 std::cout << "你好，世界\n"; // 没问题！
 std::ifstream fin("你好.txt"); // 没问题！
 return 0;
}

这样你的程序就可以正确的以 UTF-8 编码来读取源码，正确的以 UTF-8 编码来存储字符串常量，正确的把 UTF-8 编码的字符串路径转为 UTF-16 后调用 W 系 API。

总结

几种方案中，对于没有历史包袱的项目，首推方案三。有历史包袱的项目，可采用方案二，会比方案一更简洁。对于方案四，看上去是最简单方便的，但未做验证。

当然，除了这三种方案外，还有其他的方案，就不一一列举，如果有更好的方式，欢迎评论区讨论。

https://utf8everywhere.org/

https://github.com/boostorg/nowide/

https://learn.microsoft.com/zh-cn/windows/apps/design/globalizing/use-utf8-code-page

https://learn.microsoft.com/zh-cn/windows/win32/intl/code-pages

https://parallel101.github.io/cppguidebook/unicode/

PyQt 快速入门

Tue, 08 Oct 2024 18:49:59 +0800

前言

本文针对于熟悉 C++ Qt 的开发者需要使用 PyQt 而准备的快速入门教程。本文以 PyQt 6 为例，实际上与 PyQt 5 无异，5 与 6 的差异，更多是接口上的差异。

Python 中，对 Qt 库的绑定，除 PyQt，还有 PySide，两者差异不大，逻辑基本通用。

第一个程序

使用 PyQt 之前，需要安装对应库：

1

pip install PyQt6

推荐使用虚拟环境，本文环境为 Pycharm 创建的工程。

Hello world：

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


import sys
from PyQt6.QtWidgets import QApplication, QWidget


def main():
 app = QApplication(sys.argv)
 w = QWidget()
 w.setWindowTitle('HelloWorld')
 w.show()

 sys.exit(app.exec())


if __name__ == '__main__':
 main()

自定义 Widget 类：

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


import sys
from PyQt6.QtWidgets import QApplication, QWidget, QLabel


class Widget(QWidget):
 def __init__(self):
 super().__init__()
 self.resize(200,50)
 self.setWindowTitle("PyQt5")
 self.label = QLabel(self)
 self.label.setText("Hello World")
 self.label.move(50,20)

def main():
 app = QApplication(sys.argv)
 w = Widget()
 w.show()
 sys.exit(app.exec())


if __name__ == '__main__':
 main()

使用 Qt Designer 创建 UI

PyQt 同样可以使用 Qt Designer 设计 UI 界面。打开 Designer，创建窗体，然后保存为 .ui 文件。

当设计好界面后，在 PyQt 中如何引用.ui文件呢？

这里有两种方法可以实现：

将.ui文件转为.py文件，以类的形式引用。
动态加载.ui文件。

得益于 Python 动态语言的特性，可以动态加载.ui文件，可玩性会更高。

方法一：ui转py文件

在终端进入虚拟环境，使用pyuic命令转为 py 文件：

1
2


(.venv) ~/Documents/code/pythonProject/pyqt_demo
pyuic6 -x widget.ui -o widget.py

-x 选项是可选的，用于生成额外的代码来测试和显示类，即会在 widget. py 多添加以下代码：

1
2
3
4
5
6
7
8


if __name__ == "__main__":
 import sys
 app = QtWidgets.QApplication(sys.argv)
 Form = QtWidgets.QWidget()
 ui = Ui_Form()
 ui.setupUi(Form)
 Form.show()
 sys.exit(app.exec())

在 main. py 中，可以这样引用 ui 文件：

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


import sys
from PyQt6.QtWidgets import QApplication, QWidget, QLabel

from widget import Ui_Form

class Widget(QWidget):
 def __init__(self):
 super().__init__()
 self.ui = Ui_Form()
 self.ui.setupUi(self)

def main():
 app = QApplication(sys.argv)
 w = Widget()
 w.show()
 sys.exit(app.exec())

if __name__ == '__main__':
 main()

pyuic 工具 -h 帮助输出：

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


pyuic6 -h
usage: pyuic6 [-h] [-V] [-p] [-o FILE] [-x] [-d] [-i N] [-w N] ui

Python User Interface Compiler

positional arguments:
 ui the .ui file created by Qt Designer or a directory containing .ui files

options:
 -h, --help show this help message and exit
 -V, --version show program's version number and exit
 -p, --preview show a preview of the UI instead of generating code
 -o FILE, --output FILE
 write generated code to FILE instead of stdout
 -x, --execute generate extra code to test and display the class
 -d, --debug show debug output
 -i N, --indent N set indent width to N spaces, tab if N is 0 [default: 4]
 -w N, --max-workers N
 use a maximum of N worker processes when converting a directory [default: 0]

方法二：动态加载ui文件

使用 loadUi()方法动态加载.ui文件

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


import sys
from PyQt6.QtWidgets import QApplication, QWidget
from PyQt6.uic import loadUi

class Widget(QWidget):
 def __init__(self):
 super().__init__()
 self.ui = loadUi('widget.ui', self)
 self.ui.pushButton.clicked.connect(lambda: print('clicked'))

def main():
 app = QApplication(sys.argv)
 w = Widget()
 w.show()
 sys.exit(app.exec())


if __name__ == '__main__':
 main()

两种方法各有千秋，可根据具体使用场景选择。

信号槽

PyQt 中的信号槽使用方式与 C++ Qt 有些差异，但理解用法后，就很简单了，PyQt 中的用法更像是调用函数指针。

1
2
3
4
5
6
7
8
9


class Widget(QWidget):
 def __init__(self):
 super().__init__()
 self.ui = Ui_Form()
 self.ui.setupUi(self)
 self.ui.pushButton.clicked.connect(self.on_button_clicked)

 def on_button_clicked(self):
 print('clicked')

发送自定义信号

在 PyQt 中，自定义信号需要使用pyqtSignal类。

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


from PyQt6.QtCore import QObject, pyqtSignal

class Foo(QObject):

 # Define a new signal called 'trigger' that has no arguments.
 trigger = pyqtSignal()

 def connect_and_emit_trigger(self):
 # Connect the trigger signal to a slot.
 self.trigger.connect(self.handle_trigger)

 # Emit the signal.
 self.trigger.emit()

 def handle_trigger(self):
 # Show that the slot has been called.

 print "trigger signal received"

也可单独定义一个信号类，用于通信：

1
2
3


class Communicate(QObject):
 send_message_signal = pyqtSignal()
 param_changed_signal = pyqtSignal(str, bool)

param_changed_signal 信号为带参数信号，这里传递 str 和 bool 类型。

在 Widget 中关联信号槽：

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


class Widget(QWidget):
 def __init__(self):
 super().__init__()
 self.ui = Ui_Form()
 self.ui.setupUi(self)
 self.ui.pushButton.clicked.connect(self.on_button_clicked)
 self.c = Communicate()
 self.c.send_message_signal.connect(self.on_signal_trigger)

 def on_button_clicked(self):
 print('clicked')
 self.c.send_message_signal.emit()

 def on_signal_trigger(self):
 print('on_signal_trigger')

当按钮点击时，会发送 send_message_signal 信号，从而触发与之关联的槽函数 on_signal_trigger()。

当在两个类之间关联信号槽时，也是一样：

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


class Logic:
 def __init__(self):
 self.c = Communicate()

 def send_message(self):
 self.c.send_message_signal.emit()

class Widget(QWidget):
 def __init__(self):
 super().__init__()
 self.ui = Ui_Form()
 self.ui.setupUi(self)
 self.ui.pushButton.clicked.connect(self.on_button_clicked)
 self.logic = Logic()
 self.logic.c.send_message_signal.connect(self.on_signal_trigger)

 def on_button_clicked(self):
 print('clicked')
 self.logic.send_message()

 def on_signal_trigger(self):
 print('on_signal_trigger')

事件

以关闭窗口事件为例：

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


class Widget(QWidget):
 def __init__(self):
 super().__init__()
 self.ui = Ui_Form()
 self.ui.setupUi(self)

 def closeEvent(self, event):
 re = QMessageBox.information(self, '警告', '当前程序正在运行，是否确定退出？', QMessageBox.StandardButton.Yes, QMessageBox.StandardButton.No)
 if re == QMessageBox.StandardButton.Yes:
 QWidget.closeEvent(self, event)
 else:
 event.ignore()

总结

本文为作者在使用 PyQt 过程中，对遇到的问题总结，提炼出几个关键点，用于快速掌握 PyQt 的使用。由于有Qt的经验，当了解 PyQt 基本用法后，上手就简单了很多。

PyQt教程

PyQt5 教程

PyQt Documentation

QScopedPointer 与 std::unique_ptr差异

Thu, 19 Sep 2024 18:57:25 +0800

前言

通常，在讨论 Qt 的智能指针时，我们常视为 QScopedPointer 与标准库的 std::unique_ptr 是类似的，QSharedPointer 与 std::shared_ptr 类似。尽管它们在功能上相似，但在实际应用中，他们的使用方式存在显著差异。

本文将讨论实际工程中 QScopedPointer 与 std::unique_ptr 的差异导致的一个问题。

QScopedPointer

按照 Qt 官方文档的表述，QScopedPointer 通过资源获取初始化（RAII）保证当前作用域消失时，指向的对象将被删除。

QScopedPointer 源码实现非常简单：

 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


template <typename T, typename Cleanup = QScopedPointerDeleter<T> >
class QScopedPointer
{
 typedef T *QScopedPointer:: *RestrictedBool;
public:
 explicit QScopedPointer(T *p = nullptr) noexcept : d(p)
 {
 }

 inline ~QScopedPointer()
 {
 T *oldD = this->d;
 Cleanup::cleanup(oldD);
 }

 inline T &operator*() const
 {
 Q_ASSERT(d);
 return *d;
 }

 T *operator->() const noexcept
 {
 return d;
 }

 bool operator!() const noexcept
 {
 return !d;
 }

#if defined(Q_QDOC)
 inline operator bool() const
 {
 return isNull() ? nullptr : &QScopedPointer::d;
 }
#else
 operator RestrictedBool() const noexcept
 {
 return isNull() ? nullptr : &QScopedPointer::d;
 }
#endif

 T *data() const noexcept
 {
 return d;
 }

 T *get() const noexcept
 {
 return d;
 }

 bool isNull() const noexcept
 {
 return !d;
 }

 void reset(T *other = nullptr) noexcept(noexcept(Cleanup::cleanup(std::declval<T *>())))
 {
 if (d == other)
 return;
 T *oldD = d;
 d = other;
 Cleanup::cleanup(oldD);
 }

 T *take() noexcept
 {
 T *oldD = d;
 d = nullptr;
 return oldD;
 }

 void swap(QScopedPointer<T, Cleanup> &other) noexcept
 {
 qSwap(d, other.d);
 }

 typedef T *pointer;

protected:
 T *d;

private:
 Q_DISABLE_COPY(QScopedPointer)
};

简单来说，就是禁用了拷贝操作，使得成为独占指针，利用 RAII 特性析构时释放内存。

QScopedPointer 与 std::unique_ptr 的差异

相比之下，std::unique_ptr 会复杂一些，如在 C++ 14 后，增加了 std::make_unique<T> 工厂构造方法。（因为 C++ 11 遗漏了它 🤣）。

这里，重点讲解一个实际情况遇到的问题，有以下代码：

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


std::unique_ptr<QString> func1()
{
 std::unique_ptr<QString> ptr(new QString("string"));
 return ptr;
}
void func2(std::unique_ptr<QString>&& ptr)
{
 // do something, like:
 ptr->size();
}
int main()
{
 func2(func1());
 return 0;
}

这段代码，在 func1() 函数中 new 一个 unique_ptr 智能指针，然后利用 RVO（返回值优化）直接 return ptr，func2() 函数右值引用调用 func1()，编译能通过，并且能正常运行。

但是，使用 QScopedPointer 则不同了，会编译不通过：

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


QScopedPointer<QString> func1()
{
 QScopedPointer<QString> ptr(new QString("string"));
 return ptr;
}
void func2(QScopedPointer<QString>&& ptr)
{
 // do something, like:
 ptr->size();
}
int main()
{
 func2(func1());
 return 0;
}

报错原因在于，QScopedPointer 不能被复制或移动，但 QScopedPointer 源码中只看到禁用了拷贝构造和拷贝赋值，并没有显式禁用移动构造和移动赋值，那为什么不能被移动呢？因为默认情况下，C++ 在禁用拷贝操作时不会为类自动生成移动构造函数或移动赋值操作符。

依据三五法则：

五原则：

因为用户定义（包括 = default 或 = delete）的析构函数、复制构造函数或复制赋值运算符，会阻止隐式定义移动构造函数和移动赋值运算符。

所以这就是为什么即使没有显式禁用移动操作，也无法通过移动语义返回或传递 QScopedPointer 对象。

总结

简单来说，QScopedPointer 可以视为阉割版的 std::unique_ptr，适用于函数范围内，不适用于函数间传递使用。若要函数间传递，则推荐使用 std::unique_ptr。

https://zh.cppreference.com/w/cpp/language/rule_of_three

C++ nlohmann json库快速使用

Thu, 05 Sep 2024 14:15:03 +0800

前言

C++ nlohmann/json 库是一个非常易用，高性能的 json 库。

CMake FetchContent方式集成

1
2
3
4
5
6


include(FetchContent) 
FetchContent_Declare(json
 URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz) 
FetchContent_MakeAvailable(json) 
 
target_link_libraries(json_demo PRIVATE nlohmann_json::nlohmann_json)

快速使用

包含头文件以及声明命名空间别名：

1
2


#include <nlohmann/json.hpp>
using json = nlohmann::json;

解析json

从文件读取解析

1
2
3
4
5
6
7
8


// method 1
std::ifstream f("example.json");
json data = json::parse(f);

// method 2
std::ifstream i("file.json");
json j;
i >> j;

从字符串读取解析

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


// Using (raw) string literals and json::parse
json ex1 = json::parse(R"(
 {
 "pi": 3.141,
 "happy": true
 }
)");

// Using user-defined (raw) string literals
using namespace nlohmann::literals;
json ex2 = R"(
 {
 "pi": 3.141,
 "happy": true
 }
)"_json;

// Using initializer lists
json ex3 = {
 {"happy", true},
 {"pi", 3.141},
};

遍历

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


// special iterator member functions for objects
for (json::iterator it = o.begin(); it != o.end(); ++it) {
 std::cout << it.key() << " : " << it.value() << "\n";
}

// the same code as range for
for (auto& el : o.items()) {
 std::cout << el.key() << " : " << el.value() << "\n";
}

// even easier with structured bindings (C++17)
for (auto& [key, value] : o.items()) {
 std::cout << key << " : " << value << "\n";
}

查找 Key

1
2
3
4
5


if (j.contains("key")) {
}

if (j.find("foo") != o.end()) {
}

读取 key

1
2
3
4
5
6
7
8


auto value = j["key"];
auto value = j.at("key");
std::string value = j["key"].template get<std::string>();

// C++17
using namespace std::literals;
// 如果key不存在，则返回默认值0
int v_integer = j.value("integer"sv, 0);

删除 key

1
2


// delete an entry
o.erase("foo");

注意：数组可能无法删除单个元素

写入 json 文件

1
2


std::ofstream o("pretty.json");
o << std::setw(4) << j << std::endl;

序列化设置缩进

1
2


// 按照四个空格缩进打印json
std::cout << j.dump(4) << std::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
26
27
28
29
30
31


using json = nlohmann::json;

namespace ns {
 struct person {
 std::string name;
 std::string address;
 int age;
 };

 void to_json(json& j, const person& p) {
 j = json{{"name", p.name}, {"address", p.address}, {"age", p.age}};
 }

 void from_json(const json& j, person& p) {
 j.at("name").get_to(p.name);
 j.at("address").get_to(p.address);
 j.at("age").get_to(p.age);
 }
} // namespace ns

// create a person
ns::person p {"Ned Flanders", "744 Evergreen Terrace", 60};

// conversion: person -> json
json j = p;

std::cout << j << std::endl;
// {"address":"744 Evergreen Terrace","age":60,"name":"Ned Flanders"}

// conversion: json -> person
auto p2 = j.template get<ns::person>();

通过实现to_json()和from_json()完成 json 与结构体的映射关系。

[!warning]

使用template get<your_type>()时，必须保证是可以默认构造的。

from_json 中，使用 at() 来访问对象的值，而不是 operator[] 。如果某个键不存在， at 会抛出一个可以处理的异常，而 operator[] 则会表现出未定义的行为。

如果想要将 JSON 对象用作序列化或想要将成员变量名称用作该对象的键。可以使用宏简化操作（自动实现to_json()和from_json()）：

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(name, member1, member2, ...)：在类/结构体的命名空间内进行定义。
NLOHMANN_DEFINE_TYPE_INTRUSIVE(name, member1, member2, ...)：在类/结构内部定义的标识符，用于创建代码。这个宏还可以访问私有成员。

命名空间中使用：

1
2
3
4
5
6
7
8


namespace ns {
 struct person {
 std::string name;
 std::string address;
 int age;
 };
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person, name, address, age)
}

使用私有成员：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


namespace ns {
 class address {
 private:
 std::string street;
 int housenumber;
 int postcode;

 public:
 NLOHMANN_DEFINE_TYPE_INTRUSIVE(address, street, housenumber, postcode)
 };
}

宏相当于：

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


void to_json(nlohmann::json& nlohmann_json_j, const person& nlohmann_json_t)
{
 nlohmann_json_j["name"] = nlohmann_json_t.name;
 nlohmann_json_j["address"] = nlohmann_json_t.address;
 nlohmann_json_j["age"] = nlohmann_json_t.age;
}

void from_json(const nlohmann::json& nlohmann_json_j, person& nlohmann_json_t)
{
 nlohmann_json_t.name = nlohmann_json_j.at("name");
 nlohmann_json_t.address = nlohmann_json_j.at("address");
 nlohmann_json_t.age = nlohmann_json_j.at("age");
}

注意：

使用宏时，如果 json 中缺少某个键，赋值给结构体时，则会抛出 out_of_range.403 异常。但是 json 中如果有多余的键，则会自动忽略。

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


// incomplete deserialization:
json j3 = R"({"address": "742 Evergreen Terrace", "name": "Maggie Simpson"})"_json;
try
{
 auto p3 = j3.template get<ns::person>();
}
catch (const json::exception& e)
{
 std::cout << "deserialization failed: " << e.what() << std::endl;
}

// output:
// deserialization failed: [json.exception.out_of_range.403] key 'age' not found

// redundant fields
json j2 = R"({"address": "742 Evergreen Terrace", "name": "Maggie Simpson", "age": 20, "sex": "man"})"_json;
ns::person p2 = j2.template get<ns::person>();

目前 nlohmann 最新 Release 版本为 3.11.3，还未支持 std::optional，所以当遇到 json 为 null 时，需要额外处理，通过重新定义宏的方式，处理 null 的情形。

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


#ifdef NLOHMANN_JSON_FROM
#pragma push_macro("NLOHMANN_JSON_FROM")
#undef NLOHMANN_JSON_FROM
#endif
// ignore null in json
#define NLOHMANN_JSON_FROM(v1) \
 { \
 if (nlohmann_json_j.at(#v1).is_null()) { \
 nlohmann_json_t.v1 = {}; \
 } else { \
 nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); \
 } \
 }

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(MakeupItem, id, name, order_no, status, makeup_key, created_at, updated_at,
 deleted_at, infos, colors)

#ifdef NLOHMANN_JSON_FROM
#pragma pop_macro("NLOHMANN_JSON_FROM")
#endif

总结

以上就是在使用 json 库时的常用场景。

https://github.com/nlohmann/json

https://github.com/nlohmann/json/tree/develop/docs/examples

https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/#examples

WSL 清理释放磁盘空间

Tue, 27 Aug 2024 23:03:02 +0800

背景

在 WSL 中，删除文件后，并不会直接释放磁盘空间，因为 WSL 使用虚拟硬盘 (VHD) 文件来存储整个 Linux 文件系统。也就是说，WSL 中删除文件时，对于 Windows 来说，这个 VHD 文件大小并没有变化。

解决方案

首先，打开 PowerShell，先关闭正在运行的 WSL：

1

wsl --shutdown

运行 diskpart 命令（需要管理员权限）：

1
2
3
4
5
6


diskpart
select vdisk file="C:\Users\[YourUsername]\AppData\Local\Packages\[WSLDistro]\LocalState\ext4.vhdx"
attach vdisk readonly
compact vdisk
detach vdisk
exit

这样就可以将 VHD 占用的空间缩小。

示例：

 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


$ diskpart

Microsoft DiskPart 版本 10.0.22621.1

Copyright (C) Microsoft Corporation.
在计算机上: DESKTOP-LMR

DISKPART> select vdisk file="C:\Users\LMR\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\ext4.vhdx"

DiskPart 已成功选择虚拟磁盘文件。

DISKPART> attach vdisk readonly

 100 百分比已完成

DiskPart 已成功连接虚拟磁盘文件。

DISKPART> compact vdisk

 100 百分比已完成

DiskPart 已成功压缩虚拟磁盘文件。

DISKPART> detach vdisk

DiskPart 已成功分离虚拟磁盘文件。

DISKPART> exit

退出 DiskPart...

LeetCode 75系列 - 643. 子数组最大平均数 I

Wed, 14 Aug 2024 22:10:00 +0800

题目描述

给你一个由 n 个元素组成的整数数组 nums 和一个整数 k 。

请你找出平均数最大且 长度为 k 的连续子数组，并输出该最大平均数。

任何误差小于 $10^{-5}$ 的答案都将被视为正确答案。

示例 1：

1
2
3


输入：nums = [1,12,-5,-6,50,3], k = 4
输出：12.75
解释：最大平均数 (12-5-6+50)/4 = 51/4 = 12.75

示例 2：

1
2


输入：nums = [5], k = 1
输出：5.00000

提示：

n == nums.length
1 <= k <= n <= $10^{5}$
$-10^{4}$ <= nums[i] <= $10^{4}$

题解

解法一：

使用双指针，从左到右遍历，for 循环累加 K 次，然后与最大的 sum 比较，如果更大，则交换，使得 maxSum 始终是最大的子数组，遍历完毕后，再执行 double 的平均数计算（因为 double 运算更耗时，所以最后才计算平均数）。

但是，此方法超时了。因为 while + for 时间复杂度 $O\left(n^2\right)$ 导致遍历时间过长。

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


class Solution {
public:
 double findMaxAverage(vector<int>& nums, int k) {
 int left{0};
 int right{k};
 int maxSum = INT_MIN;
 int sum{};
 while (right <= nums.size()) {
 for (int i = left; i < left + k; ++i) {
 sum += nums[i];
 }

 if (sum > maxSum)
 maxSum = sum;

 left++;
 right++;
 sum = 0;
 }
 return static_cast<double>(maxSum) / k;
 }
};

解法二：

先计算第一个子数组，然后再从第 k 个开始，计算第二个数组，这里减去第一个数组，加上后一个数组的方式，实现累加。

这样，就只有一层 for 循环，时间复杂度为 $O\left(n\right)$

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


class Solution {
public:
 double findMaxAverage(vector<int>& nums, int k) {
 int sum = 0;
 int n = nums.size();
 for (int i = 0; i < k; i++) {
 sum += nums[i];
 }
 int maxSum = sum;
 for (int i = k; i < n; i++) {
 sum = sum - nums[i - k] + nums[i];
 maxSum = max(maxSum, sum);
 }
 return static_cast<double>(maxSum) / k;
 }
};

工具软件列表

Sun, 07 Jul 2024 21:59:57 +0800

以下为Windows、macOS平台所使用的软件，记录一下，以备日后需要之时。

开发工具

CLion

C++ IDE

插件列表：

Bito
Rainbow Brackets
Translation

VS Code

插件列表：

Comment Translate：注释翻译
Doxygen Documentation Generator：Doxygen格式注释生成
GitLens：Git插件
SVG：SVG图像预览

Cursor

AI 驱动的VS Code

warp

集成AI的终端工具

https://www.warp.dev/

Tabby

终端工具，支持SSH、SFTP

Apifox

API测试工具

Reqable

API抓包调试和API测试工具 Reqable = Fiddler + Charles + Postman

https://reqable.com/

Hoppscotch

轻量API调试工具

DBeaver

数据库工具

https://dbeaver.io/

WinDbg

商店下载的版本，暂不确定与VS附带的是否有区别。WinDbg很强大，但我用的频率很低。

Oh My Posh

终端美化软件

Xmake

比CMake好用，用于更快地创建demo项目。

Dependencies

查看exe动态库依赖，动态库函数签名。

https://github.com/lucasg/Dependencies

fastgithub

用于Github访问，Git clone。

EnigmaVirtualBox

制作单可执行文件exe

笔记工具

Typora

Markdown一流写作工具

Obsidian

笔记 + Git同步流插件列表：

Easy Typing
Git
Excalidraw
Code Preview
Local Images

Fluent Reader

RSS阅读器。支持 Windows、macOS。

macOS 付费 RSS 阅读器 Reeder

https://github.com/yang991178/fluent-reader

日常工具

Bandizip

解压缩工具，免费有广告。支持 Windows、macOS

https://www.bandisoft.com/bandizip/

Everything

Windows 快速搜索工具

https://www.voidtools.com/zh-cn/

uTools

快捷功能工具，常使用沙拉查词、路径转换、斗图、OCR等功能插件。

SumatraPDF

Windows 平台，支持多种格式的电子书阅读器

https://www.sumatrapdfreader.org/

draw.io

流程图绘制工具

IINA

macOS 的现代视频播放器

https://github.com/iina/iina

低频率工具

LockHunter

Windows 平台文件解锁器，用于解除文件被其他应用占用

https://lockhunter.com/

geek

软件干净卸载和强制卸载工具

https://geekuninstaller.com/

spacesniffer

磁盘占用空间分析工具

http://www.uderzo.it/main_products/space_sniffer/index.html

ScreenToGif

GIF 录制工具

https://www.screentogif.com/

unlock-music

解锁网易云、QQ等加密音乐文件

ProcessExplorer

可显示有关打开或加载了哪些句柄和 DLL 进程的信息。

https://learn.microsoft.com/zh-cn/sysinternals/downloads/process-explorer

Sysinternals 全家桶

https://learn.microsoft.com/zh-cn/sysinternals/

System Informer

监控系统资源、调试软件以及检测恶意软件。

https://www.systeminformer.com/

ventoy

制作可启动U盘的开源工具。只需要把 ISO/WIM/IMG/VHD(x)/EFI 等类型的文件直接拷贝到U盘里面就可以启动安装系统。

https://www.ventoy.net/cn/index.html

傲梅分区助手

傲梅分区助手是一款免费、专业的无损分区工具。会比 Windows 10的磁盘管理好用， Windows 11 后磁盘管理改版了，可能会更易用。

https://www.disktool.cn/

CrystalDiskInfo

查看磁盘信息工具。可用于查看硬盘通电时间和健康状态，通常用于判断新电脑的固体硬盘是否为全新。

https://crystalmark.info/en/software/

CrystalDiskMark

磁盘基准测试软件。用于测试磁盘的读写性能。

https://crystalmark.info/en/software/

Hex Fiend

macOS的十六进制数据查看编辑工具

https://github.com/HexFiend/HexFiend

SwitchHosts

管理 hosts 文件应用，支持分组，支持远程

https://github.com/oldj/SwitchHosts

娱乐

Steam

Epic

LeetCode 75系列 - 1679. K 和数对的最大数目

Sat, 22 Jun 2024 23:10:00 +0800

题目描述

给你一个整数数组 nums 和一个整数 k 。

每一步操作中，你需要从数组中选出和为 k 的两个整数，并将它们移出数组。

返回你可以对数组执行的最大操作数。

示例 1：

1
2
3
4
5
6


输入：nums = [1,2,3,4], k = 5
输出：2
解释：开始时 nums = [1,2,3,4]：
- 移出 1 和 4 ，之后 nums = [2,3]
- 移出 2 和 3 ，之后 nums = []
不再有和为 5 的数对，因此最多执行 2 次操作。

示例 2：

1
2
3
4
5


输入：nums = [3,1,3,4,3], k = 6
输出：1
解释：开始时 nums = [3,1,3,4,3]：
- 移出前两个 3 ，之后nums = [1,4,3]
不再有和为 6 的数对，因此最多执行 1 次操作。

提示：

1 <= nums.length <= $10^{5}$
1 <= nums[i] <= $10^{9}$
1 <= k <= $10^{9}$

题解

使用哈希表解法：

从左到右遍历数组，同时用一个哈希表统计元素及其出现次数。

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


class Solution {
public:
 int maxOperations(vector<int>& nums, int k) {
 int res = 0;
 unordered_map<int, int> u;
 for (int x : nums) {
 auto it = u.find(k - x);
 if (it != u.end() && it->second) {
 it->second--;
 res++;
 } else {
 u[x]++;
 }
 }
 return res;
 }
}

Qt QPushButton clicked信号浅析

Mon, 17 Jun 2024 22:29:37 +0800

前言

Qt 的 QPushButton clicked 信号原型：

1

void clicked(bool checked = false);

通常，使用 Qt 的 QPushButton clicked 点击信号时，会以如下方式使用：

1
2
3


connect(ui->pushButton, &QPushButton::clicked, this, [](){
 qDebug()<<"clicked";
});

也就是不带 clicked() 信号参数。而今天，简单分析一下，void clicked(bool checked = false) 信号中的 checked 参数的触发场景和作用。

分析

信号解释：

1

void clicked(bool checked = false);

按钮被激活（即，鼠标光标在按钮内部时按下然后释放），快捷键被输入，或者调用了 click() 或 animateClick() 方法。值得注意的是，如果你调用了 setDown()、setChecked() 或 toggle()，则不会发出此信号。

如果按钮是可勾选的，如果按钮被选中，则 checked 为 true；如果按钮未被选中，则 checked 为 false。也就是说，当QPushButton 的setCheckable()设置为true时，才能使得checked为true。

1
2
3
4


ui->pushButton->setCheckable(true);
connect(ui->pushButton, &QPushButton::clicked, this, [](auto checked){
 qDebug()<<checked;
});

设置setCheckable()设置为true后，第一次点击，checked将为true，按钮变为蓝色，第二次则为false。

总结

所以，如果要使用clicked(bool checked = false) 信号中的 checked 参数，需要设置 setCheckable(true)。

Qt windeployqt 部署的Qt动态库介绍

Sun, 02 Jun 2024 23:33:43 +0800

前言

在 Windows 平台，通常使用 Qt 的工具 windeployqt 将可执行文件的相关 Qt 依赖项部署到当前路径下。

Windows windeployqt 部署工具

Windows 部署工具 windeployqt 旨在自动化创建一个可部署文件夹的过程，该文件夹包含运行应用程序所需的 Qt 相关依赖项（库、QML 导入、插件和翻译）。它为 Windows 桌面应用程序创建了一个安装树，可以轻松地捆绑到安装包中。

该工具可以在 QTDIR/bin/windeployqt 中找到。为了正确运行，它需要在构建环境中运行。当使用 Qt 在线安装器时，应使用脚本 QTDIR/bin/qtenv2.bat 来设置它。

对于 Windows 桌面应用程序，默认情况下，编译器所需的运行时文件也会复制到部署文件夹中（除非指定了 --no-compiler-runtime 选项）。在 Microsoft Visual C++使用的发布版本中，这些包括 Visual C++可再发行包，这些包旨在由应用程序的安装程序在目标机器上递归安装。否则，将使用编译器运行时的共享库。

windeployqt 工具帮助说明：

 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


Usage: windeployqt [options] [files]
Qt Deploy Tool 6.0.0

The simplest way to use windeployqt is to add the bin directory of your Qt
installation (e.g. <QT_DIR\bin>) to the PATH variable and then run:
 windeployqt <path-to-app-binary>
If ICU, etc. are not in the bin directory, they need to be in the PATH
variable. If your application uses Qt Quick, run:
 windeployqt --qmldir <path-to-app-qml-files> <path-to-app-binary>

Options:
 -?, -h, --help Displays help on commandline options.
 --help-all Displays help including Qt specific options.
 -v, --version Displays version information.
 --dir <directory> Use directory instead of binary directory.
 --qmake <path> Use specified qmake instead of qmake from PATH.
 --libdir <path> Copy libraries to path.
 --plugindir <path> Copy plugins to path.
 --debug Assume debug binaries.
 --release Assume release binaries.
 --pdb Deploy .pdb files (MSVC).
 --force Force updating files.
 --dry-run Simulation mode. Behave normally, but do not
 copy/update any files.
 --no-patchqt Do not patch the Qt6Core library.
 --ignore-library-errors Ignore errors when libraries cannot be found.
 --no-plugins Skip plugin deployment.
 --no-libraries Skip library deployment.
 --qmldir <directory> Scan for QML-imports starting from directory.
 --qmlimport <directory> Add the given path to the QML module search
 locations.
 --no-quick-import Skip deployment of Qt Quick imports.
 --translations <languages> A comma-separated list of languages to deploy
 (de,fi).
 --no-translations Skip deployment of translations.
 --no-system-d3d-compiler Skip deployment of the system D3D compiler.
 --compiler-runtime Deploy compiler runtime (Desktop only).
 --no-virtualkeyboard Disable deployment of the Virtual Keyboard.
 --no-compiler-runtime Do not deploy compiler runtime (Desktop only).
 --json Print to stdout in JSON format.
 --no-opengl-sw Do not deploy the software rasterizer library.
 --list <option> Print only the names of the files copied.
 Available options:
 source: absolute path of the source files
 target: absolute path of the target files
 relative: paths of the target files, relative
 to the target directory
 mapping: outputs the source and the relative
 target, suitable for use within an
 Appx mapping file
 --verbose <level> Verbose level (0-2).

Qt libraries can be added by passing their name (-xml) or removed by passing
the name prepended by --no- (--no-xml). Available libraries:
bluetooth concurrent core declarative designer designercomponents gui qthelp
multimedia multimediawidgets multimediaquick network nfc opengl openglwidgets
positioning printsupport qml qmltooling quick quickparticles quickwidgets script
scripttools sensors serialport sql svg svgwidgets test websockets widgets xml
webenginecore webengine webenginewidgets 3dcore 3drenderer 3dquick
3dquickrenderer 3dinput 3danimation 3dextras geoservices webchannel serialbus
webview

Arguments:
 [files] Binaries or directory containing the binary.

例如使用 windeployqt 工具后， Qt 6.7.0 的动态库依赖如下：

 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


.
├── Qt6Cored.dll
├── Qt6Guid.dll
├── Qt6Networkd.dll
├── Qt6Svgd.dll
├── Qt6Widgetsd.dll
├── QtProjectTemplate.exe
├── concrt140d.dll
├── d3dcompiler_47.dll
├── dxcompiler.dll
├── dxil.dll
├── generic
│   └── qtuiotouchplugind.dll
├── iconengines
│   └── qsvgicond.dll
├── imageformats
│   ├── qgifd.dll
│   ├── qicod.dll
│   ├── qjpegd.dll
│   └── qsvgd.dll
├── msvcp140_1d.dll
├── msvcp140_2d.dll
├── msvcp140d.dll
├── msvcp140d_atomic_wait.dll
├── msvcp140d_codecvt_ids.dll
├── networkinformation
│   └── qnetworklistmanagerd.dll
├── opengl32sw.dll
├── platforms
│   └── qwindowsd.dll
├── styles
│   └── qmodernwindowsstyled.dll
├── tls
│   ├── qcertonlybackendd.dll
│   ├── qopensslbackendd.dll
│   └── qschannelbackendd.dll
├── translations
│   ├── qt_ar.qm
│   ├── ...
│   ├── qt_zh_CN.qm
│   └── qt_zh_TW.qm
├── vccorlib140d.dll
├── vcruntime140_1d.dll
├── vcruntime140_threadsd.dll
└── vcruntime140d.dll

Qt 5.15.2 动态库依赖如下：

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


.
├── D3Dcompiler_47.dll
├── QtProjectTemplate.exe
├── Qt5Cored.dll
├── Qt5Guid.dll
├── Qt5Svgd.dll
├── Qt5Widgetsd.dll
├── iconengines
│   └── qsvgicond.dll
├── imageformats
│   ├── qgifd.dll
│   ├── qicnsd.dll
│   ├── qicod.dll
│   ├── qjpegd.dll
│   ├── qsvgd.dll
│   ├── qtgad.dll
│   ├── qtiffd.dll
│   ├── qwbmpd.dll
│   └── qwebpd.dll
├── libEGLd.dll
├── libGLESv2d.dll
├── opengl32sw.dll
├── platforms
│   └── qwindowsd.dll
├── styles
│   └── qwindowsvistastyled.dll
└── translations
 ├── qt_ar.qm
 ├── ...
 └── qt_zh_TW.qm

依赖动态库介绍

分发运行 Qt 应用程序所需的所有 Qt DLL 和应用程序特定插件的存档必须包括以下文件：

组件	文件名
可执行文件	`qt-demo.exe`
Qt Windows 平台插件	`platforms\qwindows.dll`
Qt Windows Vista 风格的插件	`styles\qwindowsvistastyle.dll`
Qt 核心模块	`Qt6Core.dll`
Qt GUI 模块	`Qt6Gui.dll`
Qt Widgets 模块	`Qt6Widgets.dll`

根据应用程序使用的功能，可能需要其他插件 (iconengines, imageformats)。

iconengines:

qsvgicon.dll：SVG 图标支持

imageformats：

qgif.dll：提供对 GIF 图像格式的支持。
qicns.dll：提供对 ICNS 图像格式的支持。
qico.dll：提供对 ICO 图像格式的支持。
qjpeg.dll：提供对 JPEG 图像格式的支持。
qsvg.dll：提供对 SVG 图像格式的支持。
qtga.dll：提供对 TGA 图像格式的支持。
qtiff.dll：提供对 TIFF 图像格式的支持。
qwbmp.dll：提供对 WBMP 图像格式的支持。
qwebp.dll：提供对 WebP 图像格式的支持。

注意：以上imageformats列举的动态库为 Qt 5，在 Qt 6 中有所变化，缩减了一些动态库。

此外，如果采用的是 MSVC 编译器，存档必须包含以下编译器特定的库（假设为 Visual Studio 2019）：

组件	文件名
C 运行时	`vcruntime140.dll`
C++ 运行时	`msvcp160.dll`

如果使用了动态 OpenGL，则档案可能还包含：

组件	文件名
OpenGL 软件渲染库	opengl32sw. dll

而在Qt 5中，如果使用动态 OpenGL，还需要包含 ANGLE 和软件渲染所需的库：

组件	文件名
OpenGL 软件渲染库	opengl32sw. dll
ANGLE 库	libEGL.dll, libGLESv2.dll
ANGLE 的 HLSL 编译器库	d3dcompiler_XX.dll

如果 Qt 配置为使用 ICU，则归档文件必须包含：

ICU 组件	文件名
	icudtXX. dll
	icuinXX. dll
	icuucXX. dll

与非系统库的直接依赖关系：

Qt	Visual Studio 16 (2019)	MinGW
Qt6Core.dll Qt6Gui.dll Qt6Widgets.dll	vccorlib140.dll vcruntime140d.dll msvcp140.dll	libwinpthread-1.dll libgcc_s_seh-1.dll libstdc++-6.dll

Qt 6 中增加了传输层安全性(TLS)相关的插件，即tls目录：

qcertonlybackend.dll：提供了一个仅用于证书处理的后端实现。它可以用于验证证书链、检查证书的有效性和处理证书相关的任务，而不实际执行加密通信。这个后端可能在不需要完整 TLS 功能的环境中使用，比如在某些测试或调试场景中。
qopensslbackend.dll：基于 OpenSSL 的 TLS 后端实现。OpenSSL 是一个广泛使用的开源库，提供了丰富的加密功能和协议支持，包括 SSL 和 TLS。通过使用这个后端，Qt 应用程序可以利用 OpenSSL 的功能来实现安全的网络通信。
qschannelbackend.dll：提供了基于 Windows 的 SChannel（Secure Channel）安全协议的 TLS 后端实现。SChannel 是 Windows 操作系统的一部分，提供了 SSL 和 TLS 协议的支持。使用这个后端，Qt 应用程序可以在 Windows 平台上利用系统自带的安全功能来实现加密通信。

Qt 插件

所有 Qt GUI 应用程序都需要一个实现 Qt 平台抽象（QPA）层的插件。对于 Windows，平台插件的名称是 qwindows.dll。此文件必须位于您的分发目录下的特定子目录（默认为 platforms）中。或者，可以调整 Qt 用于查找其插件的搜索路径。

应用程序还可能依赖于一个或多个 Qt 插件，例如打印支持插件、JPEG 图像格式插件或 SQL 驱动程序插件。确保与您的应用程序一起分发所需的任何 Qt 插件。与平台插件类似，每种类型的插件都必须位于分发目录内特定的子目录（例如 printsupport、imageformats 或 sqldrivers）中。

总结

Qt 6 的依赖库相比 Qt5 多了很多新东西，但大多可望文生义，可猜个大概意思。也可查询官方文档进行佐证。

Qt for Windows - Deployment | Qt 6.7

使用create-dmg工具制作dmg安装包

Sun, 02 Jun 2024 18:08:59 +0800

简介

create-dmg 是一个用来创建磁盘镜像文件（dmg）的 shell 脚本命令行工具。本文将介绍如何使用 create-dmg 来创建一个 dmg 磁盘镜像文件，即 macOS 系统的安装包，使应用可进行分发。

准备工作

create-dmg可以通过 Homebrew 来安装，使用以下命令安装 create-dmg：

1

brew install create-dmg

创建 dmg 文件

在创建 dmg 文件之前，确保你的应用程序已经打包好，并且所有的资源文件都已经放置在正确的位置。通常为 xxx.app 的 bundle 形式文件。

创建一个文件夹，将你的应用程序拖放进去。这个文件夹将作为 dmg 文件的根目录。这里以 dmg-demo 作为目录为例：

1
2
3


dmg-demo
├── QtProjectDemo.app
├── bg.svg

只需要额外提供一张背景图即可。当然也可再提供一个 icns 图标文件作为磁盘镜像文件的图标（双击 dmg 后，桌面显示的磁盘镜像图标）

如图，上面为默认的磁盘镜像图标，下图为自行替换的图标：

这里提供的是SVG格式的背景图：

在应用程序文件夹所在的目录打开终端。然后运行以下命令：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


create-dmg \
 --volname "Application Installer" \
 --background "bg.svg" \
 --window-pos 400 200 \
 --window-size 660 400 \
 --icon-size 100 \
 --icon "QtProjectDemo.app" 160 185 \
 --hide-extension "QtProjectDemo.app" \
 --app-drop-link 500 185 \
 "Installer.dmg" \
 "QtProjectDemo.app/"

这个命令中包含了多个参数：

--volname：设置卷的名称。
--background：设置窗口的背景图。
--window-pos：设置双击 dmg，打开窗口的位置坐标。
--window-size：设置窗口的大小。
--icon-size：设置应用程序图标的大小。
--icon：设置应用程序的图标和位置坐标。
--hide-extension：隐藏应用程序文件的扩展名。
最后两个参数分别是输出的 dmg 文件名和包含应用程序的文件夹名称。

输出信息：

 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


Creating disk image...
..................................................................................................
created: /Users/leo/Downloads/dmg-demo/rw.74691.Installer.dmg
Mounting disk image...
Device name: /dev/disk5
Searching for mounted interstitial disk image using /dev/disk5s...
Mount dir: /Volumes/dmg.kaLqeq
Copying background file 'bg.svg'...
Making link to Applications dir...
/Volumes/dmg.kaLqeq
Running AppleScript to make Finder stuff pretty: /usr/bin/osascript "/var/folders/mn/vvr3gxpn7b38rlkyfl_j5m2h0000gn/T/createdmg.tmp.XXXXXXXXXX.SfFuKvgIMf" "dmg.kaLqeq"
waited 1 seconds for .DS_STORE to be created.
Done running the AppleScript...
Fixing permissions...
Done fixing permissions
Skipping blessing on sandbox
Deleting .fseventsd
Unmounting disk image...
"disk5" ejected.
Compressing disk image...
正在准备映像引擎…
正在读取Protective Master Boot Record（MBR：0）…
 (CRC32 $0821720F：Protective Master Boot Record（MBR：0）)
正在读取GPT Header（Primary GPT Header：1）…
 (CRC32 $2718773B：GPT Header（Primary GPT Header：1）)
正在读取GPT Partition Data（Primary GPT Table：2）…
 (CRC32 $D08A2D56：GPT Partition Data（Primary GPT Table：2）)
正在读取（Apple_Free：3）…
 (CRC32 $00000000：（Apple_Free：3）)
正在读取disk image（Apple_HFS：4）…
.........................................................................................................................
 (CRC32 $FC0F7A84：disk image（Apple_HFS：4）)
正在读取（Apple_Free：5）…
.........................................................................................................................
 (CRC32 $00000000：（Apple_Free：5）)
正在读取GPT Partition Data（Backup GPT Table：6）…
.........................................................................................................................
 (CRC32 $D08A2D56：GPT Partition Data（Backup GPT Table：6）)
正在读取GPT Header（Backup GPT Header：7）…
.........................................................................................................................
 (CRC32 $E02061DB：GPT Header（Backup GPT Header：7）)
正在添加资源…
.........................................................................................................................
已耗时： 3.355s
文件大小：31846419字节，校验和：CRC32 $7457A18C
已处理扇区：213072，已压缩158148
速度：23.0MB/秒
节省：70.8%
created: /Users/leo/Downloads/dmg-demo/Installer.dmg
hdiutil does not support internet-enable. Note it was removed in macOS 10.15.
Disk image done

创建完成后，双击 dmg 文件，检查它是否按照预期显示和工作。

这里需要注意的点在于，安装界面的图标位置计算。图标的位置是中心坐标，而不是左上角坐标。

这里指定了宽度 660 px 和高度 400 px 的窗口大小，是整个窗口（包含标题栏），而标题栏本身会占有 30 px 的高度，也就是实际上的区域只有 (660，370)，这就导致，如果你要想要图标都居中，那么图标的的中心坐标位置将是 (x, 370/2)。

背景图的制作也是，中间的▶️图标如果要中心居中，那么实际上需要向上偏移 30 px 高度，才会居中。

另外，虽然 create-dmg 文档说支持 png、gif、jpg，但实测还支持 SVG、tiff 格式。

总结

通过使用 create-dmg，你可以为你的 Mac 应用程序创建 DMG 磁盘镜像文件，同时也能方便地集成到 CI/CD 流程中。

附录

create-dmg 用法：

1

create-dmg [options ...] <output_name.dmg> <source_folder>

参数选项：

--volname <name>：设置卷标名称（在 Finder 侧边栏和窗口标题中显示）
--volicon <icon.icns>：设置卷标图标
--background <pic.png>：设置文件夹背景图像（提供 png、gif、jpg 格式）
--window-pos <x> <y>：设置文件夹窗口的位置
--window-size <width> <height>：设置文件夹窗口的大小
--text-size <text_size>：设置窗口文本大小（10-16）
--icon-size <icon_size>：设置窗口图标大小（最大 128）
--icon <file_name> <x> <y>：设置文件图标的位置
--hide-extension <file_name>：隐藏文件的扩展名
--app-drop-link <x> <y>：在位置 x, y 创建一个指向应用程序的快捷链接
--ql-drop-link <x> <y>：在位置 x, y 创建一个指向 /Library/QuickLook 的快捷链接
--eula <eula_file>：附加一个许可协议文件到 dmg
--rez <rez_path>：指定包含许可协议文件的 Rez 工具的自定义路径
--no-internet-enable：禁用自动挂载和复制
--format：指定最终图像格式（UDZO|UDBZ|ULFO|ULMO）（默认为 UDZO）
--filesystem：指定图像文件系统（HFS+|APFS）（默认为 HFS+，APFS 支持 macOS 10.13 或更新版本）
--encrypt：启用结果磁盘镜像的加密（AES-256 - 将提示输入密码）
--encrypt-aes128：启用结果磁盘镜像的加密（AES-128 - 将提示输入密码）
--add-file <target_name> <file|folder> <x> <y>：添加额外的文件或文件夹（可多次使用）
--disk-image-size <x>：手动设置磁盘镜像大小为 x MB
--hdiutil-verbose：以详细模式执行 hdiutil
--hdiutil-quiet：以安静模式执行 hdiutil
--codesign <signature>：使用指定的签名对磁盘镜像进行代码签名
--notarize <credentials>：使用存储在钥匙串中的凭据对磁盘镜像进行签名（等待并装订）。更多信息请查看 Apple的文档
--skip-jenkins：跳过 Finder 美化 AppleScript，适用于沙盒和非 GUI 环境
--sandbox-safe：与沙盒兼容的 hdiutil，不祝福也不执行 AppleScript（不支持 APFS 磁盘镜像）
--version：显示工具版本号
-h, --help：显示帮助

create-dmg/create-dmg: A shell script to build fancy DMGs (github.com)

制作macOS icns图标

Thu, 23 May 2024 18:57:06 +0800

背景

macOS 应用通常需要一个桌面图标，而桌面图标的格式是 macOS 专有的 icns 格式。一般，在线图像格式转换工具转换的 icns 图标文件，通常仅有一种分辨率，而符合规范的 icns 图标里含有多种尺寸的图标。所以，本文将介绍，如何在 macOS 平台上，制作含有多种尺寸的 icns 格式图标。

制作 icns

首先需要一张 1024 x 1024 分辨率图片，然后复制下面的命令创建 run.sh 脚本：

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


echo "icns 生成器"
echo "-- 请先确保需要转换的PNG图片文件在脚本所在的当前文件夹，并且大小为 1024x1024 "
read -p "-- 请输入需要转换的文件的名称，包含扩展名：" filename
temp_path="$filename.iconset"
echo "--> 创建临时文件夹 $temp_path"
mkdir $temp_path
echo "-- 准备创建临时图片"
sips -z 16 16 $filename --out $temp_path/icon_16x16.png
sips -z 32 32 $filename --out $temp_path/icon_16x16@2x.png
sips -z 32 32 $filename --out $temp_path/icon_32x32.png
sips -z 64 64 $filename --out $temp_path/icon_32x32@2x.png
sips -z 128 128 $filename --out $temp_path/icon_128x128.png
sips -z 256 256 $filename --out $temp_path/icon_128x128@2x.png
sips -z 256 256 $filename --out $temp_path/icon_256x256.png
sips -z 512 512 $filename --out $temp_path/icon_256x256@2x.png
sips -z 512 512 $filename --out $temp_path/icon_512x512.png
sips -z 1024 1024 $filename --out $temp_path/icon_512x512@2x.png
echo "-- 临时图片创建完毕，准备生成 icns 文件"
iconutil -c icns $temp_path -o $filename.icns
echo "-- icns 文件生成完毕，准备清理临时文件"
rm -rf $temp_path
echo "-- 临时文件清理完毕"
echo "icns 文件生成完毕"

运行该脚本：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$./run.sh
icns 生成器
-- 请先确保需要转换的PNG图片文件在脚本所在的当前文件夹，并且大小为 1024x1024
-- 请输入需要转换的文件的名称，包含扩展名：logo.png
--> 创建临时文件夹 logo.png.iconset
-- 准备创建临时图片
/logo.png
....
logo.png.iconset/icon_512x512@2x.png
-- 临时图片创建完毕，准备生成 icns 文件
icns 文件生成完毕

原理

这里使用了两个 macOS 系统自带的命令行工具 sips 进行图像大小的调整，以便生成多种分辨率的图像，iconutil 则用于将多张 png 图像合成为 icns 格式图像。

效果展示

制作含有多尺寸的ico图标

Thu, 23 May 2024 18:43:32 +0800

前言

应用程序通常需要一个桌面图标，Windows 下是 ico 格式，macOS 是 icns 格式。

ICO 图标格式是一种通常包含不同分辨率（16×16，32×32，64×64 像素）和各种颜色深度（16 种颜色，32，64，128，256，16 位等）的小图像图标的文件格式。

可以将 ico 图标格式理解为一个容器，里面可以是包含一张分辨率的图，也可以是包含多张分辨率的图。

大部分 png 转 ico 格式的在线工具只支持包含一种分辨率尺寸，会导致在不同电脑或不同 Windows 系统版本桌面图标显示模糊的情况。所以，这里使用 ImageMagick 命令行工具，实现一条命令完成多尺寸 png 图转换为 ico 格式。

ImageMagick 安装

ImageMagic 是跨平台工具，支持不同系统，所以可参考官网（ https://imagemagick.org/script/download.php ）选择自己喜欢的方式进行下载安装。

这里以 macOS 系统为例：

1

brew install imagemagick

Windows 也可使用 WinGet 安装：

1

winget install ImageMagick

png 转 ico

预先准备256、128、64、48、32、24、16分辨率，PNG格式的logo图。

将多尺寸 png 图标放在 logo 文件夹下：

1
2
3
4
5
6
7
8


logo/
├── 256_256.png
├── 128_128.png
├── 64_64.png
├── 48_48.png
├── 32_32.png
├── 24_24.png
├── 16_16.png

然后在 logo 目录下，打开终端，输入命令：

1

convert 256_256.png 128_128.png 64_64.png 48_48.png 32_32.png 24_24.png 16_16.png icon.ico

即可得到一张含有多尺寸的 ico 图。

Windows 平台（ Windows convert 命令是系统命令，所以需要使用 magick convert 命令）：

1

magick convert 256_256.png 128_128.png 64_64.png 48_48.png 32_32.png 24_24.png 16_16.png icon.ico

注意：

如果执行中报错信息为：

1

convert: width or height exceeds limit `icon.ico' @ error/icon.c/WriteICONImage/1008.

这通常意味着你的图片尺寸超出了 ICO 文件格式所支持的最大尺寸限制。ICO 文件格式对图像的尺寸有特定的限制。对于标准的 ICO 文件，单个图像的最大尺寸通常是 256 x 256 像素。所以 512 x 512 像素尺寸的图片需要移除。

得到的 ico 图标如下：

可以看到左侧列表有很多不同分辨率的图标。

[!note]

应至少具有以下像素：16x16、24x24、32x32、48x48 和 256x256。这涵盖了最常见的图标大小，通过提供 256px 图标，可确保 Windows 只会纵向缩减图标，从不会纵向缩放。

https://blog.walterlv.com/post/convert-to-ico-icon-using-image-magick

构造 Windows 应用的图标 - Windows apps | Microsoft Learn

使用CMake和Catch2进行单元测试

Fri, 17 May 2024 22:57:28 +0800

前言

单元测试是软件开发过程中的重要部分，它帮助我们确保每个组件按预期工作。C++ 中进行单元测试的一个流行选择是 Catch2 测试框架，结合 CMake 构建系统，可以创建一个强大且灵活的测试环境。在这篇博客中，将演示使用 Catch2 集成到 CMake 的 CTest 工具中进行单元测试。

环境准备

CMake：v3.28
Catch 2：v3.6.0 假设目录结构如下：

1
2
3
4
5
6
7


MyProject/
|-- CMakeLists.txt
|-- src/
 |-- main.cpp
|-- test/
 |-- CMakeLists.txt
 |-- test.cpp

CMake 配置

根目录 CMakeLists.txt：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# CMakeLists.txt
cmake_minimum_required(VERSION 3.28) 
...
option(ENABLE_TESTS "Build the test" ON)
...
if (ENABLE_TESTS)
 # 启用测试
 enable_testing() 
 add_subdirectory(test) 
endif ()

使用 enable_testing() 启用 CTest 测试。

test 目录下的 CMakeLists.txt：

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


# test/CMakeLists.txt
include(FetchContent) 
FetchContent_Declare(
 Catch2
 GIT_REPOSITORY https://github.com/catchorg/Catch2.git
 GIT_TAG v3.6.0
) 
FetchContent_MakeAvailable(Catch2) 
 
add_executable(SimZipTest test.cpp) 
target_link_libraries(SimZipTest PRIVATE SimZip Catch2::Catch2WithMain) 
 
add_test(NAME SimZipTest
 COMMAND $<TARGET_FILE:SimZipTest> --success
) 

这里使用了 CMake 的 FetchContent 方式集成 Catch2，并指定了 Git tag 为 v3.6.0，然后使用 target_link_libraries() 将需要链接的库和 Catch 的库链接上。

Catch 2 有两种方式：Catch2::Catch2 和 Catch2::Catch2WithMain。如果不需要自定义 main 函数，则使用后者。如果需要自定义 main，则应该只链接 Catch2::Catch2。

之后便是 add_test() 命令添加测试。

注意，这里使用了 --success 选项传递给单元测试的可执行文件，用于显示 Catch 2的输出。

编写测试代码

在 test 目录下，编写 test.cpp 代码：

 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


// test.cpp
#include "../SimZip.h"
#include <catch2/catch_test_macros.hpp>
#include <fstream>
#include <filesystem>

void generateData()
{
 std::ofstream file("data.txt");
 if (file.is_open()) {
 for (auto i = 0; i < 10; i++) { file << "this is data for test."; }
 file.close();
 }
}

TEST_CASE("create zip", "[create_zip]")
{
 generateData();
 SimZip zip("test.zip", SimZip::OpenMode::Create);
 REQUIRE(zip.add("data.txt") == true);
 REQUIRE(zip.add("data.txt", "folder/rename.txt") == true);
 REQUIRE(zip.add("empty.txt") == false);
 zip.save();
}

TEST_CASE("extract zip", "[extract_zip]")
{
 SimZip zip("test.zip", SimZip::OpenMode::Read);

 SECTION("Extract single file from zip")
 {
 zip.extract("data.txt", "output/");
 REQUIRE(fs::exists("output/data.txt"));
 }
 SECTION("Extract all files from zip")
 { zip.extractall("output/");
 std::vector<std::string> expected_files = {"data.txt", "folder/rename.txt"};
 for (const auto& file: expected_files) { REQUIRE(fs::exists("output/" + file)); }
 }
}

在 Catch2 测试框架中，TEST_CASE 是一个宏，用于定义一个测试用例。这个宏接受几个参数，其中最常见的是测试用例的名称和可选的标签。

1
2
3


TEST_CASE("test name", "[tags]") {
// 测试代码
}

测试用例名称：第一个参数是测试用例的名称，它是一个描述性的字符串，表明测试用例的目的或测试的行为。在 Catch2 中运行测试时，这个名称会被用来识别和过滤特定的测试。
标签：第二个参数是可选的，它允许你为测试用例添加标签。标签通常用方括号 [] 包围，并可以用逗号 , 分隔，从而为测试用例分配多个标签。标签可以用来对测试进行分类，或者在运行测试时进行过滤。

SECTION 是一个宏，用于将一个测试案例（TEST_CASE）划分为多个独立的部分，每个部分都可以单独运行或独立地进行断言检查。这允许你以模块化的方式编写测试，并且可以针对相同的测试设置运行多个不同的测试场景。

运行测试

使用命令：

1
2
3


cmake -B build
cmake --build build
ctest --test-dir build/

然后就可以看到测试结果：

1
2
3
4
5
6
7
8


$ ctest
Test project /mnt/f/Code/CppProjects/SimZip/build
 Start 1: SimZipTest
1/1 Test #1: SimZipTest ....................... Passed 0.06 sec

100% tests passed, 0 tests failed out of 1

Total Test time (real) = 0.10 sec

对 CTest 添加 -V 参数，可以看到详细信息

1

ctest --test-dir build/ -V

如果你使用的是 CLion，那么可以很方便地进行测试，选择 CTest 然后运行，即可执行测试。

测试结果：

总结

CMake 和 Catch2 的结合提供了一个简单而强大的单元测试解决方案，它可以帮助你确保代码的质量。通过遵循上述步骤，你可以轻松地在你的 C++ 项目中集成测试，并保持代码的可维护性和健壮性。

Qt hide()和setVisible(false)区别

Tue, 23 Apr 2024 11:30:13 +0800

前言

在一些场景下，我们需要控制控件的显示与隐藏，QWidget 类提供了两种方法来隐藏控件hide() 和 setVisible(false)。那么他们有何区别呢？

1
2
3


widget->hide();
// == ？
widget->setVisible(false);

`hide()` 和 `setVisible(false)` 解析

根据 Qt 文档 QWidget::hide() 介绍：

void QWidget:: hide () Hides the widget. This function is equivalent to setVisible (false).

即 hide() 等效于 setVisible(false)。

文档说的很清楚了，接下来看源码实现进一步确认，Qt QWidget::hide() 源代码实现：

1
2
3
4


void QWidget::hide()
{
 setVisible(false);
}

那么，这里就很清楚了，hide() 实质上就是调用了 setVisible(false)。

顺便看看 setVisible() 实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


void QWidget::setVisible(bool visible)
{
 if (testAttribute(Qt::WA_WState_ExplicitShowHide) && testAttribute(Qt::WA_WState_Hidden) == !visible)
 return;

 // Remember that setVisible was called explicitly
 setAttribute(Qt::WA_WState_ExplicitShowHide);

 Q_D(QWidget);
 d->setVisible(visible);
}

setVisible() 相关方法：isVisible()

`setHidden()`

另外，还有一个方法 setHidden(bool hidden)，与 setVisible(!hidden) 等价。

总结

Qt hide() 和 setVisible(false) 没有区别。

https://doc.qt.io/qt-6/qwidget.html

macOS brew 使用指南

Fri, 05 Apr 2024 20:26:36 +0800

介绍

brew（ Homebrew）是 macOS 的软件包的管理器，类似于 Linux 平台的 apt、dpkg 等，可以让你在 Mac 上轻松安装、更新和管理软件包和应用程序。

Homebrew 会将软件包安装到独立目录，并将其文件软链接至 /opt/homebrew 。

安装

安装 brew 之前，我们需要下载 Command Line Tools for Xcode工具：

1

sudo xcode-select --install

之后再执行安装脚本：

1

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

如果 GitHub 无法访问，可使用国内版脚本：

1

/bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)"

安装完成之后，可以执行以下命令验证是否成功安装：

1
2
3


brew --version # 预期输出版本号
# 或者
brew doctor # 预期输出：Your system is ready to brew!

使用 brew

brew 分为 Formula 和 Cask 两种类型：

Formula 通常用于编译和安装那些需要从源代码构建的软件，或者那些没有预编译二进制文件的软件。Formula 脚本会处理软件的依赖关系、配置和安装过程。
Cask 专门用于安装预编译的二进制文件，通常是图形界面应用程序（GUI apps）。Cask 简化了安装过程，不再需要下载 .dmg 文件并将其拖动到“应用程序”文件夹中。

brew install

安装软件（ formulas 或者 cask）:

1

brew install

brew update

获取最新版本的 Homebrew 和所有 formulae（软件包）列表，更新 Homebrew 自身：

1

brew update

brew outdated

查看查看可升级的 formula 或者 cask:

1

brew outdated

brew upgrade

升级所有已安装的软件包或指定的软件：

1

brew upgrade <package>

brew cleanup

Homebrew 将旧版本的 formulas 保留在系统上，以防想回滚到旧版本。这很少是必要的，所以你可以清理那些旧版本：

1

brew cleanup

如果想查看 Homebrew 将会删除哪些可以运行：

1

brew cleanup --dry-run

brew list

查看已安装的软件包：

1

brew list

查看已安装软件包版本号：

1

brew list --versions

示例：

1
2
3
4
5
6


$brew list --version
ca-certificates 2023-12-12
cmake 3.28.3
git 2.44.0
git-lfs 3.4.1
warp 0.2024.02.13.08.02.stable_00

brew search

搜索 formulas 或者 cask：

1

brew search

示例：

1
2
3
4
5
6
7


$brew search chrome
==> Formulae
chrome-cli chrome-export chroma rome chrony

==> Casks
chrome-devtools chromedriver epichrome mkchromecast
chrome-remote-desktop-host chromium google-chrome

brew info

获取相关的详细信息：

1

brew info

示例：

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


$brew info cmake
Warning: Treating cmake as a formula. For the cask, use homebrew/cask/cmake or specify the `--cask` flag.
==> cmake: stable 3.29.1 (bottled), HEAD
Cross-platform make
https://www.cmake.org/
/opt/homebrew/Cellar/cmake/3.28.3 (3,329 files, 54.4MB) *
 Poured from bottle using the formulae.brew.sh API on 2024-02-26 at 15:25:57
From: https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/c/cmake.rb
License: BSD-3-Clause
==> Options
--HEAD
 Install HEAD version
==> Caveats
To install the CMake documentation, run:
 brew install cmake-docs

Emacs Lisp files have been installed to:
 /opt/homebrew/share/emacs/site-lisp/cmake
==> Analytics
install: 133,740 (30 days), 377,293 (90 days), 1,512,635 (365 days)
install-on-request: 106,313 (30 days), 297,449 (90 days), 1,185,548 (365 days)
build-error: 705 (30 days)

brew deps

显示依赖项。brew info也会输出包的依赖项，但没有brew deps简洁。

brew uninstall

卸载命令:

1

brew uninstall <package>

不常用命令

brew config 显示对调试有用的Homebrew和系统配置信息。
brew doctor 检查是否有潜在问题。如果发现任何潜在问题，将以非零状态退出。

Homebrew

Homebrew Documentation

FAQ — Homebrew Documentation

Homebrew · macOS Setup Guide

HomebrewCN

LeetCode 75系列 - 11. 盛最多水的容器

Wed, 27 Mar 2024 21:10:00 +0800

题目描述

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

**说明：**你不能倾斜容器。

示例 1：

1
2
3


输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

1
2


输入：height = [1,1]
输出：1

提示：

n == height.length
2 <= n <= 10^5
0 <= height[i] <= 10^4

题解

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


class Solution {
public:
 int maxArea(vector<int>& height) {
 int i = 0;
 int j = height.size() - 1;
 int res = 0;
 while (i < j) {
 res = height[i] < height[j] ? max(res, (j - i) * height[i++])
 : max(res, (j - i) * height[j--]);
 }
 return res;
 }
};

Qt 高分辨率扩展屏下窗口最大化问题

Tue, 26 Mar 2024 12:20:00 +0800

前言

Qt5 在扩展屏情况下，存在一些bug，影响用户的正常使用。这里讲述一种在高分辨率扩展屏下，Qt 应用最大化时，应用尺寸超出屏幕的问题，进行产生原因分析并提供对应解决方案。

问题复现

环境：

Qt 5.15 系列
Windows 10/11
主屏 1920*1080，缩放 125%，扩展屏 2160*1440 100%

复现代码：

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


// main.cpp
#include <QApplication>
#include "mainwindow.h"

int main(int argc, char *argv[]) {
 QApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy::PassThrough);
 QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
 QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
 QApplication a(argc, argv);
 MainWindow w;
 w.show();
 return QApplication::exec();
}

 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


// mainwindow.h
#ifndef FRAMELESS_TEST_MAINWINDOW_H
#define FRAMELESS_TEST_MAINWINDOW_H

#include <QWidget>

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QWidget {
 Q_OBJECT

public:
 explicit MainWindow(QWidget *parent = nullptr);

 ~MainWindow() override;

protected:
 void mousePressEvent(QMouseEvent* event) override;

 void mouseMoveEvent(QMouseEvent* event) override;

 void mouseReleaseEvent(QMouseEvent* event) override;

private:
 Ui::MainWindow *ui;
 bool isMoving{false};
 QPoint pressPos;
 QRect r;
 qreal m_currentDpr = -1;
};


#endif //FRAMELESS_TEST_MAINWINDOW_H

 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


//mainwindow.cpp
#include "mainwindow.h"
#include "ui_MainWindow.h"
#include <QMouseEvent>
#include <QDebug>
#include "Windows.h"

MainWindow::MainWindow(QWidget *parent) :
 QWidget(parent), ui(new Ui::MainWindow) {
 ui->setupUi(this);
 setWindowFlags(Qt::FramelessWindowHint);
 connect(ui->pushButton, &QPushButton::clicked, this, [this]() {
 showMaximized();
 qDebug() << "1maximized size:" << this->size() << this->geometry();
// auto handle = (HWND) this->windowHandle()->winId();
// if (handle)
// ::ShowWindow(handle, SW_SHOWMAXIMIZED);

 });
 connect(ui->pushButton_2, &QPushButton::clicked, this, [this]() {
 qDebug() << "normal size:" << this->size() << this->geometry();
 showNormal();
// auto handle = (HWND) this->windowHandle()->winId();
// if (handle)
// ::ShowWindow(handle, SW_SHOWNORMAL);
 });
}

MainWindow::~MainWindow() {
 delete ui;
}

void MainWindow::mousePressEvent(QMouseEvent *event) {
 if (event->button() == Qt::MouseButton::LeftButton) {
 pressPos = event->pos();
 isMoving = true;
 }
 // if (ReleaseCapture()) {
 // SendMessage(HWND(window()->winId()), WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);
 // }

 QWidget::mousePressEvent(event);
}

void MainWindow::mouseMoveEvent(QMouseEvent *event) {
 if (isMoving) {
 QPoint diff = event->pos() - pressPos;
 window()->move(window()->pos() + diff);
 }
 QWidget::mouseMoveEvent(event);
}

void MainWindow::mouseReleaseEvent(QMouseEvent *event) {
 isMoving = false;

 QWidget::mouseReleaseEvent(event);
}

 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


// mainwindow.ui
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QWidget" name="MainWindow">
 <property name="geometry">
 <rect>
 <x>0</x>
 <y>0</y>
 <width>400</width>
 <height>300</height>
 </rect>
 </property>
 <property name="windowTitle">
 <string>MainWindow</string>
 </property>
 <layout class="QVBoxLayout" name="verticalLayout">
 <item>
 <widget class="QPushButton" name="pushButton">
 <property name="text">
 <string>最大化</string>
 </property>
 </widget>
 </item>
 <item>
 <widget class="QPushButton" name="pushButton_2">
 <property name="text">
 <string>还原</string>
 </property>
 </widget>
 </item>
 <item>
 <widget class="QLabel" name="label">
 <property name="text">
 <string>TextLabel</string>
 </property>
 </widget>
 </item>
 <item>
 <layout class="QHBoxLayout" name="horizontalLayout">
 <item>
 <widget class="QPushButton" name="pushButton_4">
 <property name="text">
 <string>PushButton</string>
 </property>
 </widget>
 </item>
 <item>
 <widget class="QPushButton" name="pushButton_3">
 <property name="text">
 <string>PushButton</string>
 </property>
 </widget>
 </item>
 </layout>
 </item>
 </layout>
 </widget>
 <resources/>
 <connections/>
</ui>

复现步骤：

主屏启动应用，移动到扩展屏
应用最大化

现象：

应用最大化后，界面会超出扩展屏屏幕尺寸，而不是撑满扩展屏。

预期：

应用最大化，撑满扩展屏尺寸。

问题分析

尝试使用 Windows API ShowWindow() 进行窗口最大化和还原操作，但问题并未得到解决。最终通过打印窗口不同阶段的尺寸，发现了问题。

问题产生的核心原因与 Qt 去边框有关，也就是使用了setWindowFlags(Qt::FramelessWindowHint);，导致应用最大化时，未获取到当前屏幕的正确屏幕尺寸。也就是窗体的最大化尺寸不正确，它不等于扩展屏尺寸，而是远大于扩展屏本身尺寸，导致应用总是超出屏幕。

比如这里的窗口的尺寸为（400x300），最大化后的尺寸为（3200x1752），大于扩展屏尺寸（2160x1440）。

注意，虽然在 main.cpp 中调用了高分辨率适配的函数，但这并不是导致此问题的原因，一般很容易陷入此误区。

同时，此问题产生的前提是，从低分辨率移动到高分辨率后（即这里的1080P屏幕移动到2K屏幕），窗口最大化，并且 1080P 屏幕作为主屏。

解决方案

可在最大化时，获取当前屏幕尺寸，手动调用resize()设置为正确的尺寸，同时也不会改变窗体的标识：

1
2
3


showMaximized();
auto rect = screen()->availableGeometry();
resize(rect.width(), rect.height());

总结

这属于 Qt 5的一个bug，在 Qt 6 中已经修复。如果项目中无法升级 Qt6，可使用此方案解决。

https://code.qt.io/cgit/qt/qtbase.git/tree/tests/manual/highdpi/dprgadget?id=bcedeb6d3d8e0e72aac16acbc519d09aa99f23fd

https://doc.qt.io/qt-6/highdpi.html#dprgadget

Windows DPI 深入探究

Mon, 25 Mar 2024 21:46:00 +0800

核心概念

什么是 DPI

每英寸点数 (DPI) 是显示器的线性英寸中像素数的物理测量值。 DPI 取决于显示器分辨率和尺寸；DPI 越高，构成显示器的点越多、越小。较高的分辨率或较小的尺寸会导致较高的 DPI，较低的分辨率或较大的尺寸会导致较低的 DPI。当显示器具有较高的 DPI 时，像素较小且更靠近，因此用户界面 (UI) 和其他显示内容看起来比预期的要小。

DPI 值 96 被视为中性默认值。

什么是像素

像素是一个彩色点。计算机图形中的图像由排列在二维网格中的许多像素组成。可以将像素视为生成所有图像的原子。

像素的物理大小因显示器而异。当计算机连接到大尺寸但分辨率较低的显示器或外部显示器时，像素可能相当大，但在具有 1080p 的手机上，只有几英寸宽，像素很小。

像素的大小取决于两个因素：显示分辨率和监视器的物理大小。因此，物理英寸不是有用的度量值，因为物理英寸和像素之间没有固定的关系。相反，字体以逻辑单位度量。 72 磅字体定义为一个逻辑英寸高。逻辑英寸随后转换为像素。多年来，Windows 使用以下转换：1 个逻辑英寸等于 96 像素。使用此比例系数，72 磅字体呈现为 96 像素高。 12 磅字体高 16 像素。

此比例系数描述为每英寸 96 点 (DPI) 。术语点派生自打印，其中物理墨点放在纸上。对于计算机显示器，说每逻辑英寸 96 像素会更准确，但术语 DPI 停滞不前。

由于实际像素大小各不相同，因此在另一台监视器上可读的文本可能太小。此外，Windows 允许用户更改 DPI 设置。例如，如果用户将显示器设置为 144 DPI，则 72 磅字体的高度为 144 像素。标准 DPI 设置为 100% (96 DPI) 、125% (120 DPI) 和 150% (144 DPI) 。

什么是 DIP

与设备无关的像素（DIP）。这是一个虚拟化单元，可能与物理像素相同、更大或小于物理像素。

像素和 DIP 之间的比率由 DPI 确定：

1

pixels = dips * dpi / 96

当 DPI 为 96 时，像素和 DIP 相同。使用更高的 DPI 时，单个 DIP 可能对应于多个像素 (或部分像素，在 DPI 不是 96) 的确切倍数的常见情况下。

大多数Windows 运行时 API（包括 Win2D）使用 DIP 而不是像素。这样做的优点是，无论在什么显示器上运行应用，图形的物理大小都保持大致相同。例如，如果应用指定一个按钮的宽度为 100 DIP，则当在高 DPI 设备（如手机或 4k 监视器）上运行时，此按钮将自动缩放为宽度超过 100 像素，因此它仍然是用户可单击的合理大小。另一方面，如果以像素为单位指定了按钮大小，则这种高 DPI 显示器上的按钮大小会显得非常小，因此应用必须执行更多工作才能针对每种屏幕以不同的方式调整布局。

什么是 Windows 比例系数

Windows 通过指示应用程序（包括 Windows 桌面 shell）按比例系数调整内容的大小，确保所有内容以可用且一致的大小显示在屏幕上。这个数字取决于显示器 DPI 以及影响用户对显示器的感知的其他因素。几乎所有台式机显示器和目前大多数笔记本电脑显示器都在 95-110 DPI 范围内；对于这些设备，无需缩放，并且 Windows 将比例系数设置为 100%。但是，许多新设备（特别是在高端笔记本电脑和平板电脑市场）具有超过 200 DPI 的更高显示。对于这些设备，Windows 设置了更高的比例系数，以确保用户体验的舒适性和可视性。

DPI 感知模式

Windows 桌面应用大致分为两类：DPI 感知应用和非 DPI 感知应用。 DPI 感知应用在应用程序启动期间会主动告知 Windows 它们能够自我缩放以便在高 DPI 显示器上正常工作。但是，如果某个应用程序不具备 DPI 感知能力并在高 DPI 显示器上运行，则 Windows 会通过对应用程序输出应用位图缩放来缩放该应用。这可以确保该应用程序在高 DPI 显示器上以正确的大小显示。在大多数情况下，这可以使应用程序保持清晰且可正常使用，但在某些情况下，位图缩放会导致应用程序不够清晰，并呈现略微模糊的外观。

桌面应用程序必须告知 Windows 它们是否支持 DPI 缩放。默认情况下，系统将桌面应用程序 DPI 视为无法感知，并对其窗口进行位图拉伸。

无法感知 DPI

无法感知 DPI 的应用程序以固定 DPI 值 96 (100%) 进行呈现。每当这些应用程序在显示比例大于 96 DPI 的屏幕上运行时，Windows 会将应用程序位图拉伸到预期的物理大小。这会导致应用程序显示模糊。

系统 DPI 感知

可感知系统 DPI 的桌面应用程序通常在用户登录时接收主连接监视器的 DPI。在初始化期间，它们使用该系统 DPI 值来适当地设置 UI 布局（调整控件大小、选择字号、加载资产等）。因此，在以单个 DPI 呈现的显示器上，可感知系统 DPI 的应用程序不会由 Windows 进行 DPI 缩放（位图拉伸）。当应用程序移动到具有不同缩放因子的显示器时，或者如果显示比例因子发生其他更改，Windows 将对应用程序的窗口进行位图缩放，使其显示模糊。实际上，可感知系统 DPI 的桌面应用程序仅以单个显示缩放因子清晰呈现，每当 DPI 发生更改时，这些应用程序都会变得模糊。

高DPI问题

显示缩放因子 & DPI

随着显示技术的进步，显示面板制造商在其面板上的每个物理空间单元中都封装了越来越多的像素。这导致新式显示面板的每英寸点数 (DPI) 远高于历史上的点数。过去，大多数显示器每线性英寸的物理空间有 96 个像素 (96 DPI)：2017 年，具有近 300 DPI 或更高 DPI 的显示器随处可见。

大多数旧版桌面 UI 框架都有内置的假设，即显示 DPI 在进程的生存期内不会改变。这种假设不再成立，在应用程序进程的整个生存期内，显示 DPI 通常会更改多次。显示缩放因子/DPI 更改的一些常见场景如下：

多监视器设置，其中每个显示器具有不同的缩放因子，应用程序从一个显示器移动到另一个显示器（如 4K 和 1080p 显示器）
将高 DPI 笔记本电脑与低 DPI 外部显示器连接和分离（反之亦然）
通过远程桌面从高 DPI 笔记本电脑/平板电脑连接到低 DPI 设备（反之亦然）
在应用程序运行时更改显示缩放因子设置

DPI 缩放比例

DPI	比例因子
96	100
120	125
144	150
192	200

DWM 缩放

如果程序未考虑 DPI，则高 DPI 设置中可能显示以下缺陷：

已剪裁的 UI 元素。
布局不正确。
像素化的位图和图标。
鼠标坐标不正确，可能会影响命中测试、拖放等。

为了确保较旧的程序在高 DPI 设置下工作，DWM 实现了有用的回退。如果程序未标记为 DPI 感知，DWM 将缩放整个 UI 以匹配 DPI 设置。例如，在 144 DPI 下，UI 按 150% 缩放，包括文本、图形、控件和窗口大小。如果程序创建一个 500 × 500 窗口，则窗口实际上显示为 750 × 750 像素，并且窗口的内容会相应地缩放。

此行为意味着较旧的程序在高 DPI 设置下“只工作”。但是，缩放也会导致一些模糊的外观，因为缩放是在绘制窗口后应用的。

DPI 感知应用程序

若要避免 DWM 缩放，程序可以将自身标记为 DPI 感知。这会告知 DWM 不执行任何自动 DPI 缩放。所有新应用程序都应设计为 DPI 感知，因为 DPI 感知可改善 UI 在较高 DPI 设置下的外观。

程序通过其应用程序清单声明自己的 DPI 感知。清单只是描述 DLL 或应用程序的 XML 文件。清单通常嵌入到可执行文件中，尽管它可以作为单独的文件提供。清单包含 DLL 依赖项、请求的权限级别以及程序设计用于的 Windows 版本等信息。

若要声明程序可识别 DPI，请在清单中包含以下信息。

1
2
3
4
5
6
7


<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" >
 <asmv3:application>
 <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
 <dpiAware>true</dpiAware>
 </asmv3:windowsSettings>
 </asmv3:application>
</assembly>

此处显示的列表只是部分清单，但 Visual Studio 链接器会自动为你生成清单的其余部分。若要在项目中包括部分清单，请在 Visual Studio 中执行以下步骤。

在“ 项目 ”菜单上，单击“ 属性”。
在左窗格中，依次展开“ **配置属性”**和“ 清单工具”，然后单击“ 输入和输出”。
在“ 其他清单文件 ”文本框中，键入清单文件的名称，然后单击“ 确定”。

通过将程序标记为 DPI 感知，可以告知 DWM 不要缩放应用程序窗口。现在，如果创建 500 × 500 窗口，则无论用户的 DPI 设置如何，该窗口都将占用 500 × 500 像素。

GDI 和 DPI

GDI 绘图以像素为单位测量。这意味着，如果程序标记为 DPI 感知，并且你要求 GDI 绘制一个 200 × 100 矩形，生成的矩形将在屏幕上为 200 像素宽，100 像素高。但是，GDI 字体大小将缩放为当前 DPI 设置。换句话说，如果创建 72 磅字体，则字体大小将为 96 像素（96 DPI），但在 144 DPI 时为 144 像素。下面是使用 GDI 以 144 DPI 呈现的 72 磅字体。

如果应用程序可识别 DPI，并且使用 GDI 进行绘图，请缩放所有绘图坐标以匹配 DPI。

Direct2D 和 DPI

Direct2D 会自动执行缩放以匹配 DPI 设置。在 Direct2D 中，坐标以称为 设备无关像素 (DIP) 单位进行测量。 DIP 定义为逻辑英寸的 1/96。在 Direct2D 中，所有绘图操作都在 DIP 中指定，然后缩放到当前 DPI 设置。

DPI 设置	DIP 大小
96	1 像素
120	1.25 像素
144	1.5 像素

例如，如果用户的 DPI 设置为 144 DPI，并且你要求 Direct2D 绘制一个 200 × 100 矩形，则矩形将为 300 × 150 个物理像素。此外，DirectWrite以 DIP 而不是磅为单位衡量字号。若要创建 12 磅字体，请指定 16 个 DIP (12 磅 = 1/6 逻辑英寸 = 96/6 个 DIP) 。在屏幕上绘制文本时，Direct2D 会将 DIP 转换为物理像素。此系统的优点是无论当前 DPI 设置如何，文本和绘图的度量单位都是一致的。

注意：鼠标和窗口坐标仍以物理像素表示，而不是 DIP。例如，如果处理 WM_LBUTTONDOWN 消息，则鼠标按下位置以物理像素为单位。若要在该位置绘制点，必须将像素坐标转换为 DIP。

将物理像素转换为 DIP

DPI 的基值定义为 USER_DEFAULT_SCREEN_DPI 设置为 96。若要确定比例系数，请取 DPI 值并除以 USER_DEFAULT_SCREEN_DPI。

从物理像素到 DIP 的转换使用以下公式。

1

DIPs = pixels / (DPI / USER_DEFAULT_SCREEN_DPI)

若要获取 DPI 设置，请调用 GetDpiForWindow 函数。 DPI 作为浮点值返回。计算两个轴的缩放系数。

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


float g_DPIScale = 1.0f;

void InitializeDPIScale(HWND hwnd)
{
 float dpi = GetDpiForWindow(hwnd);
 g_DPIScale = dpi / USER_DEFAULT_SCREEN_DPI;
}

template <typename T>
float PixelsToDipsX(T x)
{
 return static_cast<float>(x) / g_DPIScale;
}

template <typename T>
float PixelsToDips(T y)
{
 return static_cast<float>(y) / g_DPIScale;
}

如果不使用 Direct2D，下面是获取 DPI 设置的替代方法：

1
2
3
4
5
6
7


void InitializeDPIScale(HWND hwnd)
{
 HDC hdc = GetDC(hwnd);
 g_DPIScaleX = GetDeviceCaps(hdc, LOGPIXELSX) / USER_DEFAULT_SCREEN_DPI;
 g_DPIScaleY = GetDeviceCaps(hdc, LOGPIXELSY) / USER_DEFAULT_SCREEN_DPI;
 ReleaseDC(hwnd, hdc);
}

对于桌面应用，建议使用 GetDpiForWindow;对于通用 Windows 平台 (UWP) 应用，请使用 DisplayInformation::LogicalDpi。尽管我们不建议这样做，但可以使用 SetProcessDpiAwarenessContext 以编程方式设置默认 DPI 感知。一旦在进程中创建了一个窗口 (HWND) ，就不再支持更改 DPI 感知模式。如果要以编程方式设置进程默认 DPI 感知模式，则必须在创建任何 HWND 之前调用相应的 API。有关详细信息，请参阅设置进程的默认 DPI 感知。

调整呈现器目标的大小

如果窗口的大小发生更改，则必须调整呈现目标的大小以匹配。在大多数情况下，还需要更新布局并重新绘制窗口。下面的代码演示了这些步骤。

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


void MainWindow::Resize()
{
 if (pRenderTarget != NULL)
 {
 RECT rc;
 GetClientRect(m_hwnd, &rc);

 D2D1_SIZE_U size = D2D1::SizeU(rc.right, rc.bottom);

 pRenderTarget->Resize(size);
 CalculateLayout();
 InvalidateRect(m_hwnd, NULL, FALSE);
 }
}

GetClientRect 函数获取工作区的新大小（以物理像素为单位）， (而不是 DIP) 。 ID2D1HwndRenderTarget::Resize 方法更新呈现器目标的大小（也以像素为单位指定）。 InvalidateRect 函数通过将整个工作区添加到窗口的更新区域来强制重新绘制。 (请参阅模块 1.) 中的绘制窗口

随着窗口的增大或缩小，通常需要重新计算所绘制的对象的位置。例如，在圆形程序中，必须更新半径和中心点：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


void MainWindow::CalculateLayout()
{
 if (pRenderTarget != NULL)
 {
 D2D1_SIZE_F size = pRenderTarget->GetSize();
 const float x = size.width / 2;
 const float y = size.height / 2;
 const float radius = min(x, y);
 ellipse = D2D1::Ellipse(D2D1::Point2F(x, y), radius, radius);
 }
}

ID2D1RenderTarget::GetSize 方法以 DIP (而不是像素) 返回呈现器目标的大小，这是用于计算布局的适当单位。有一个密切相关的方法 ID2D1RenderTarget::GetPixelSize，它以物理像素为单位返回大小。对于 HWND 呈现目标，此值与 GetClientRect 返回的大小匹配。但请记住，绘制以 DIP 而不是像素执行。

如何判断应用程序是否不具备 DPI 感知能力

使用进程浏览器工具确定应用是否具备 DPI 感知能力。 图 1 进程资源管理器显示此实用工具正在使用，其中启用了 DPI 感知列。（默认情况下，进程资源管理器不显示 DPI 感知列。若要打开此列，请单击“视图”菜单，单击“选择列”，选中“DPI 感知”框，单击“确定”。）标题为感知的列会告诉你某个特定进程是否感知到 DPI。

图 1：进程浏览器

Windows 区分三类应用程序。

表 1：DPI 感知应用

DPI 感知	示例	行为
无法感知	Mmc.exe（Microsoft 管理控制台及其插件）	Windows 位图根据连接到系统的任何高 DPI 显示器缩放应用程序；可以按 125% 和 150% 的缩放因子模糊显示应用程序。
系统感知	Office 应用	应用程序在启动时按系统 DPI 进行缩放（通常与主显示器 DPI 相同）；Windows 将应用缩放到与此不匹配的任何显示器。
按监视器感知（Per-Monitor DPI 感知）	Internet Explorer 11	应用程序根据显示器 DPI 动态缩放自身。

如何测试 DPI 处理

测试应用是否对更改显示 DPI 执行正确操作的最简单方法是在Windows 10或Windows 11上运行，并在应用运行时更改显示设置：

右键单击桌面背景，然后选择“显示设置”
移动标记为“更改文本、应用和其他项目的大小”的滑块
单击“应用”按钮
选择“稍后注销”

如果没有Windows 10或Windows 11，还可以使用 Windows 模拟器进行测试。在 Visual Studio 工具栏中，将“本地计算机”设置更改为“模拟器”，然后使用“更改分辨率”图标在以下两者之间切换模拟显示：

100% (DPI = 96)
140% (DPI = 134.4)
180% (DPI = 172.8)

总结

关于 Qt 高分辨率的适配，通常比较复杂，了解这些前置知识，在一定程度上会有帮助。

https://learn.microsoft.com/zh-cn/windows/apps/develop/win2d/dpi-and-dips

https://learn.microsoft.com/zh-cn/windows-hardware/manufacture/desktop/fixing-blurry-text-in-windows-for-it-professionals?view=windows-11

https://learn.microsoft.com/zh-cn/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows

https://learn.microsoft.com/zh-cn/windows/win32/learnwin32/dpi-and-device-independent-pixels

Qt lconvert 工具介绍

Fri, 22 Mar 2024 22:20:00 +0800

介绍

lconvert 是 Qt 的 Linguist 工具链的一部分。它可以用于转换和过滤翻译数据文件的独立工具。

用法：

1

lconvert [options] <infile> [<infile>...]

支持以下文件格式：

qm：编译后的 Qt 翻译
pot：GNU Gettext 本地化模板文件
qph：Qt Linguist 短语手册
ts：Qt 翻译源
po：GNU Gettext 本地化文件
xlf：XLIFF 本地化文件

如果指定了多个输入文件，它们将被合并以后文件的翻译优先。

选项：

 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


-H
-help 帮助

-i <infile>
-input-file <infile>
 指定输入文件。 如果 <infile> 可能以破折号开头。
 该选项可以多次使用来合并输入。
 可以是“-”（标准输入），用于管道中。

-o <outfile>
-output-file <outfile>
 指定输出文件。 默认为“-”（标准输出）。

-if <informat>
-input-format <format>
 指定后续 <infile> 的输入格式。
 格式是根据文件名自动检测的，默认为“ts”。

-of <outformat>
-output-format <outformat>
 指定输出格式。见 -if。

-drop-tags <regexp>
 写入 TS 或 XLIFF 文件时删除命名的额外标签。
 可以重复指定。

-drop-translations
 删除现有翻译并将状态重置为“未完成”。
 注意：这意味着 --no-obsolete。

-source-language <language>[_<region>]
 指定/覆盖源字符串的语言。 如果未指定且文件尚未命名
 则默认为 POSIX 。

-target-language <language>[_<region>]
 指定/覆盖翻译的语言。
 如果未指定此选项并且文件内容名称还没有语言，则将从文件名猜测目标语言。

-no-obsolete
 删除过时的消息。

-no-finished
 删除已完成的消息。

-no-untranslated
 删除未翻译的消息。

-sort-contexts
 按字母顺序对输出 TS 文件中的上下文进行排序。

-locations {absolute|relative|none}
 覆盖源代码引用在 TS 文件中的保存方式。
 默认是绝对的。

-no-ui-lines
 从 UI 文件的引用中删除行号。

-verbose
 详细一点

长选项也可以仅用一个前导破折号来指定。

返回值：

0 表示成功
1 命令行解析失败
2 读取失败
3 写入失败

用例

假设有如下 ts 文件：

 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


<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.1" language="zh_CN">
<context>
 <name>MainWindow</name>
 <message>
 <location filename="mainwindow.ui" line="14"/>
 <source>MainWindow</source>
 <translation>主窗口</translation>
 </message>
 <message>
 <location filename="mainwindow.ui" line="21"/>
 <source>按钮</source>
 <translation>按钮</translation>
 </message>
 <message>
 <location filename="mainwindow.ui" line="28"/>
 <source>按钮2</source>
 <translation></translation>
 </message>
 <message>
 <location filename="mainwindow.cpp" line="16"/>
 <location filename="mainwindow.cpp" line="25"/>
 <source>English text</source>
 <translation>英文文本</translation>
 </message>
 <message>
 <location filename="mainwindow.cpp" line="14"/>
 <location filename="mainwindow.cpp" line="20"/>
 <source>Chinese text</source>
 <translation>中文文本</translation>
 </message>
</context>
</TS>

去掉UI文件的行号

1

lconvert lan_zh.ts -no-ui-lines -o lan_zh_n.ts

输出：

 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


<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.1" language="zh_CN">
<context>
 <name>MainWindow</name>
 <message>
 <location filename="mainwindow.ui"/>
 <source>MainWindow</source>
 <translation>主窗口</translation>
 </message>
 <message>
 <location filename="mainwindow.ui"/>
 <source>按钮</source>
 <translation>按钮</translation>
 </message>
 <message>
 <location filename="mainwindow.ui"/>
 <source>按钮2</source>
 <translation></translation>
 </message>
 <message>
 <location filename="mainwindow.cpp" line="16"/>
 <location filename="mainwindow.cpp" line="25"/>
 <source>English text</source>
 <translation>英文文本</translation>
 </message>
 <message>
 <location filename="mainwindow.cpp" line="14"/>
 <location filename="mainwindow.cpp" line="20"/>
 <source>Chinese text</source>
 <translation>中文文本</translation>
 </message>
</context>
</TS>

可以看到，仅是.ui文件的行号被去掉了，而代码里的行号并没有去掉。

去掉行号

可以使用 -locations none 参数将 ts 中 location 去掉，就没有行号了

1

lconvert -locations none lan_zh.ts -o lan_zh_n.ts

输出：

 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


<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.1" language="zh_CN">
<context>
 <name>MainWindow</name>
 <message>
 <source>MainWindow</source>
 <translation>主窗口</translation>
 </message>
 <message>
 <source>按钮</source>
 <translation>按钮</translation>
 </message>
 <message>
 <source>按钮2</source>
 <translation></translation>
 </message>
 <message>
 <source>English text</source>
 <translation>英文文本</translation>
 </message>
 <message>
 <source>Chinese text</source>
 <translation>中文文本</translation>
 </message>
</context>
</TS>

弊端：Qt linguist 工具将无法查看对应的源码位置。

Qt Linguist 界面介绍

Sun, 10 Mar 2024 22:46:00 +0800

Qt Linguist 主界面

上下文视图

上下文视图列出了要翻译字符串的上下文。标记为上下文的列以字母顺序列出上下文名称。每个上下文都是QML类型的名称或QObject的子类的名称。

下面的图标表示每个上下文的当前翻译状态：

状态	图标	描述
接受/正确		上下文中所有字符串都已被翻译，并通过验证测试。
接受/警告		上下文中的所有字符串都已翻译或标记为翻译，但是至少一个翻译验证测试不通过。在字符串视图中，可以看到哪个字符串测试失败。
未接受		至少有一个字符串没有被翻译或不被标记为翻译。
废弃的		翻译后的字符串不再出现在上下文中。这通常意味着应用程序中不再存在上下文。

项目这一列显示上下文中已翻译字符串的数量和可翻译字符串的总数，用斜线（/）分隔。如果数字相等，则上下文中的所有可翻译字符串都已翻译。

字符串视图

字符串视图列出了当前上下文中的所有可翻译字符串及其翻译接受状态。选择要在翻译区域中查看和编辑的字符串。

下面的图标表示每个字符串的当前翻译状态：

状态	图标	描述
接受/正确		源字符串存在翻译(可能为空)。你接受了翻译，并通过所有的验证测试。单击图标可撤销对翻译的接受。如果字符串有翻译，则状态变为未接受；如果翻译为空，则状态为未翻译。如果lupdate更改了字符串的内容，其接受状态将变为未接受。
接受/警告		您接受了翻译，但它没有通过所有的验证测试。警告视图显示了失败的地方。如果单击该图标以撤销对翻译的接受，则该状态将变为“验证失败”。
未接受		该字符串的翻译通过了所有验证测试，但您尚未接受该翻译。单击图标或按Ctrl+Enter键接受翻译。状态变为“接受/正确”。
未翻译		字符串没有翻译。如果单击图标接受空翻译，则状态将变为接受/正确。
验证失败		字符串有翻译，但是翻译并未通过所有验证测试。警告视图显示了验证测试失败。单击图标或按CTRL+ENTER即使验证失败的情况下也接受翻译。通常，您应该修复验证失败的原因。当您修复所有失败时，状态将自动变为未接受。
废弃的		该字符串已过时。上下文中不再使用它。有关如何从文件中删除过时消息的说明，请参阅使用lupdate。

翻译区域

翻译区域显示选定的字符串并允许您为其输入翻译。

源文本中的空格是可视化的。

在输入框中输入当前字符串的翻译。

双击字段中的现有翻译，将其用作当前字符串的翻译。Qt Linguist从短语书中读取短语，并根据TS文件中类似短语的现有翻译进行猜测。

（可选）在译文注释输入框中输入相关的注释。

若要接受翻译，请按 Ctrl+Enter，选择，或单击字符串列表中所选源字符串左侧的图标。

重复此过程，直到字符串列表中的所有字符串都标记为（接受/正确）或（接受/警告)。然后选择下一个上下文并继续。

在上下文中查看字符串

如果 Qt Languist 可以访问包含可翻译字符串的源文件，则“源文和窗体”视图将在“字符串”视图中显示当前字符串的源上下文。它突出显示包含当前字符串的源代码行。如果 Qt Languist 找不到源文件，它将显示预期的绝对文件路径。

如果源上下文显示错误的源代码行，则翻译文件可能与源文件不同步。有关如何同步文件的详细信息，请参阅使用 lupdate。

Qt Designer 将 UI 视图存储在 UI 文件(. UI)中。Qt Linguist 尝试以视图形式显示翻译。

短语和猜测

“短语和猜测”视图显示当前字符串及其短语手册翻译。如果当前字符串与已翻译的字符串相同或类似，则视图还列出该字符串及其翻译。

要将翻译从“短语和猜测”视图复制到翻译区域，可以双击它或选择它然后按 Enter

警告视图

用于显示翻译过程中的一些警告，比如标点符号不一致等的问题。

短语书

短语书文件是人类可读的 XML 文件，包含标准短语及其翻译。这些文件由 Qt 语言学家创建和更新，并且可以被任意数量的项目和应用程序使用。

短语书用于提供一组通用的翻译，以帮助确保一致性。短语书是一组源短语、目标（翻译）短语和可选定义。通常，每个语言和应用程序族都会创建一个短语集。短语书也可以用来避免重复工作，因为一系列应用程序的翻译可以在短语书中生成一次。

创建短语书

要创建一个新短语手册，工具栏选择“短语 > 新建短语书”

选择对应的源语言和目标语言的语言和国家/地区

若要打开短语手册，请选择“短语 > 打开短语书”，然后选择 Qt 短语书文件(.qph)打开。

若要查看和更改打开的短语手册，请选择“短语”> “编辑短语手册”。

要添加新短语，请选择 新建条目 (或按 Alt + N)并键入新的源短语、翻译和可选定义。这对于区分同一源语短语的不同译法是很有用的。

要将正在进行的翻译添加到当前短语书中，请选择“短语 > 添加到短语手册”或按 Ctrl + T。如果加载多个短语书，您必须选择一个。

如果在“短语和猜测”视图中显示的短语书条目中检测到错误，也可以通过右键单击条目并选择“编辑”来对其进行原位编辑。修复错误后，按Return键退出编辑模式。

若要删除短语，请在“源短语”列表中选择该短语，然后选择“移除条目”。

若要打印打开的短语手册，请选择“短语 > 打印短语手册”。

https://doc.qt.io/qt-6/qtlinguist-index.html

https://doc.qt.io/qt-6.2/linguist-translators.html#translating-strings

https://www.qt.io/resources/videos/how-to-do-translations-with-qt-linguist

C++ 打印enum class枚举类

Wed, 21 Feb 2024 21:38:33 +0800

前言

C++11 中引入了强类型的 enum class 类型（或称为枚举类），但是有一点比较尴尬的是，std::cout 标准流不支持输出 enum class 类型。

比如以下代码：

1
2
3
4
5
6
7
8
9


#include <iostream>

int main()
{
 enum class Color { red, green = 20, blue };
 Color r = Color::blue;

 std::cout << r;
}

在编译时，会有报错，GCC 编译错误信息：

1
2
3
4
5
6


main.cpp:8:14: error: no match for 'operator<<' (operand types are 'std::ostream' {aka 'std::basic_ostream<char>'} and 'main()::Color')
 8 | std::cout<<r;
 | ~~~~~~~~~^~~
 | | |
 | | main()::Color
 | std::ostream {aka std::basic_ostream<char>}

MSVC编译错误信息：

1

E0349 没有与这些操作数匹配的 "<<" 运算符

那么，如何打印 enum class 呢？

解决方案

方法一

enum class 底层类型其实是 int 类型，那么我们可以直接进行强制类型转换即可：

1
2
3
4
5
6
7
8


enum class Color { red, green = 20, blue };
Color r = Color::blue;

std::cout<< static_cast<int>(r) << std::endl;
// 或者
std::cout<< static_cast<typename std::underlying_type<Color>::type>(r) << std::endl;

// 输出:21

方法二

每次都要强制类型转换，太麻烦了，还有更方便点的办法吗？当然有！可以通过重载 operator<< 操作符实现：

1
2
3
4
5


std::ostream& operator << (std::ostream& os, const Color& obj)
{
 os << static_cast<std::underlying_type<Color>::type>(obj);
 return os;
}

这样就可以直接使用 std::cout 打印，而不需要先强制转换一次。

1

std::cout<< r << std::endl;

方法三

如果我有多个 enum class 呢，比如 enum Color、enum Fruit，那我岂不是都要重载 operator<< 操作符一次？所以这里使用 C++黑魔法 SFINAE 从而泛型支持任何枚举类，而不限定于某特定的枚举类：

1
2
3
4
5


template<typename T>
std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e)
{
 return stream << static_cast<typename std::underlying_type<T>::type>(e);
}

例子：

 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


#include <iostream>
#include <type_traits>

// Scoped enum
enum class Color
{
 Red,
 Green,
 Blue
};

// Unscoped enum
enum Orientation
{
 Horizontal,
 Vertical
};

template<typename T>
std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e)
{
 return stream << static_cast<typename std::underlying_type<T>::type>(e);
}

int main()
{
 std::cout << Color::Blue << "\n";
 std::cout << Vertical << "\n";
 return 0;
}

缺陷

对于命名空间里的枚举类不能打印，即以下E无法识别:

1
2
3


namespace nn{
enum class E {}
}

总结

在 C++11中，由于枚举类（enum class）无法直接输出到 std::cout 标准流的问题，为了解决这个问题，提供了三种解决方案。

第一种解决方案是通过强制类型转换将枚举类转换为底层的 int 类型，然后输出 int 值。
第二种解决方案是通过重载 operator<< 操作符，将枚举类转换为底层类型后输出。
第三种解决方案是使用 C++的 SFINAE 技术，通过泛型支持任何枚举类，并将枚举类转换为底层类型后输出。

这些解决方案都可以解决无法直接输出枚举类的问题，并提供了不同的选择和灵活性。

How can I output the value of an enum class in C++11 - Stack Overflow

C++ POD类型

Mon, 29 Jan 2024 20:49:12 +0800

前言

有时，在看别人的文章时，会看到 POD 字样，但一直不太清楚含义，直到今天又遇到了它，所以，就专门研究了一下什么是 POD。

正文

POD 是 C++中Plain Old Data 的缩写，指的是可以通过简单内存复制进行复制和传输的数据类型。这表示该类型与用于 C 程序语言的类型兼容，即它能直接以二进制形式与 C 库交互。

POD 类型的特点包括：

标量类型
没有虚函数：POD类型的类或结构体不包含虚函数，即它们不使用C++的多态特性。
没有虚继承：POD类型的类或结构体不涉及虚继承，这意味着它们的继承关系是直接和明确的。
与C兼容：POD类型的对象可以直接与C语言代码交互，因为它们遵循C语言的结构体布局规则。
平凡性：POD类型需要满足平凡性，即它们的默认构造函数、拷贝构造函数、析构函数以及赋值运算符都是平凡的（没有额外的行为）。
标准布局：POD 类型还需要满足标准布局的要求，这意味着类型的非静态成员按照它们在类声明中的顺序排列，并且没有类成员之间的空隙。

我们可以使用元编程的 std::is_pod_v 检查类型是否为 POD 类型：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <type_traits>
 
struct A { int m; };
static_assert(std::is_pod_v<A> == true);
 
class B: public A { int m; };
static_assert(std::is_pod_v<B> == false);
 
struct C { virtual void foo(); };
static_assert(std::is_pod_v<C> == false);

注：此类型要求已在 C++ 标准中被弃用。它的所有使用都已被替换成更为斟酌过的类型要求，例如平凡类型。(C++20 起)

在C++ 20 以后，我们可以使用 std::is_trivial_v 来检查类型是否平凡：

1
2
3
4
5
6
7
8
9


#include <type_traits>

struct A { int m; };
static_assert(std::is_trivial_v<A> == true);

struct B { B() {} };
static_assert(std::is_trivial_v<B> == false);

int main() {}

总结

简单来说，POD 类型就是指能和 C 语言兼容的类型。在 C++ 20 后，POD 换成更研究的 Trivial Type（平凡类型）。总的来说，了解 POD 类型对于涉及到底层编程、内存管理和与 C 语言接口交互时会很有帮助，一般情况，不会接触到。

C++ 具名要求：简旧数据类型 (PODType) - cppreference.com

平凡类类型

POD 类 - cppreference.com

is_pod

Linux 安装 Docker 教程

Sat, 20 Jan 2024 22:11:16 +0800

前言

网上安装 Docker 的教程很多，为什么还要自己写一篇呢？因为质量高低不一，有的是过时的，有的甚至是野路子。为了安装之后能够省心，所以这篇文章是基于 Docker 官方文档涉及多个不同的平台（Debian、Ubuntu、Centos）的安装步骤。

主要涉及 Debian、Ubuntu、Centos 安装 Docker 的教程。

Debian 安装 Docker

前置条件

系统要求：

为了安装 Docker，你需要 64 位的 Ubuntu 版本:

Debian Bookworm 12 (stable)
Debian Bullseye 11 (oldstable)

如果你之前安装过 Docker，在安装 Docker 之前，需要卸载任何冲突的包。

运行以下命令卸载所有冲突的包:

1

for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done

卸载 Docker 时，/var/lib/Docker/ 中存储的镜像、容器、卷和网络不会自动删除。如果希望从干净的安装开始，并希望清理所有现有的数据，请参考卸载 Docker 步骤。

开始安装 Docker

首次在新主机上安装 Docker 之前，需要设置 Docker 存储库。然后，您可以从存储库安装和更新 Docker。

设置 Docker 的 apt 存储库

复制以下命令到终端粘贴并回车运行

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


# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the repository to Apt sources:
echo \
 "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
 $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
 sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

注意：如果使用的是衍生发行版，比如 Kali Linux，您可能需要替换这个命令中打印版本代码的部分:
1
(. /etc/os-release && echo "$VERSION_CODENAME")
将此部分替换为相应的 Debian 版本的代号，如 bookworm。

安装 Docker 软件包

安装最新版本，运行:

1

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

如果要安装特定版本的 Docker，从列出存储库中的可用版本开始:

1
2
3
4
5
6


# List the available versions:
apt-cache madison docker-ce | awk '{ print $3 }'

5:25.0.0-1~debian.12~bookworm
5:24.0.7-1~debian.12~bookworm
...

选择所需的版本并安装：

1
2


VERSION_STRING=5:25.0.0-1~debian.12~bookworm
sudo apt-get install docker-ce=$VERSION_STRING docker-ce-cli=$VERSION_STRING containerd.io docker-buildx-plugin docker-compose-plugin

通过运行 hello-world 镜像来验证 Docker 安装是否成功：

1

sudo docker run hello-world

此命令下载测试镜像并在容器中运行它。当容器运行时，它将打印一条确认消息并退出。

比如：

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


leo@mini-linux:~$ sudo docker run hello-world
[sudo] leo 的密码：

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
 (arm64v8)
 3. The Docker daemon created a new container from that image which runs the
 executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
 to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

如果验证通过，那么现在已经成功地安装并启动了 Docker。

卸载 Docker

卸载 Docker Engine、 CLI、 Container 和 Docker Compose 包:

1

sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

删除所有镜像、容器和卷:

1
2


sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

Ubuntu 安装 Docker

前置条件

系统要求：

为了安装 Docker，你需要 64 位的 Ubuntu 版本:

Ubuntu Mantic 23.10
Ubuntu Lunar 23.04
Ubuntu Jammy 22.04 (LTS)
Ubuntu Focal 20.04 (LTS)

如果你之前安装过 Docker，在安装 Docker 之前，需要卸载任何冲突的包。

运行以下命令卸载所有冲突的包:

1

for pkg in docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc; do sudo apt-get remove $pkg; done

开始安装 Docker

首次在新主机上安装 Docker 之前，需要设置 Docker 存储库。然后，您可以从存储库安装和更新 Docker。

设置 Docker 的 apt 存储库

复制以下命令到终端粘贴并回车运行

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


# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the repository to Apt sources:
echo \
 "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
 $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
 sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

注意：如果使用的是 Ubuntu 派生发行版，比如 Linux Mint，您可能需要使用 UBUNTU _ CODENAME 而不是 VERION _ CODENAME。

安装 Docker 软件包

安装最新版本，运行:

1

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

如果要安装特定版本的 Docker，从列出存储库中的可用版本开始:

1
2
3
4
5
6


# List the available versions:
apt-cache madison docker-ce | awk '{ print $3 }'

5:24.0.0-1~ubuntu.22.04~jammy
5:23.0.6-1~ubuntu.22.04~jammy
...

选择所需的版本并安装：

1
2


VERSION_STRING=5:24.0.0-1~ubuntu.22.04~jammy
sudo apt-get install docker-ce=$VERSION_STRING docker-ce-cli=$VERSION_STRING containerd.io docker-buildx-plugin docker-compose-plugin

通过运行 hello-world 镜像来验证 Docker 安装是否成功：

1

sudo docker run hello-world

此命令下载测试镜像并在容器中运行它。当容器运行时，它将打印一条确认消息并退出。

比如：

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


leo@mini-linux:~$ sudo docker run hello-world
[sudo] leo 的密码：

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
 (arm64v8)
 3. The Docker daemon created a new container from that image which runs the
 executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
 to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

如果验证通过，那么现在已经成功地安装并启动了 Docker。

卸载 Docker

卸载 Docker Engine、 CLI、 Container 和 Docker Compose 包:

1

sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

删除所有镜像、容器和卷:

1
2


sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

Centos 安装 Docker

前置条件

系统要求：

要安装 Docker ，需要以下 CentOS 版本之一的维护版本：

CentOS 7
CentOS 8 (stream)
CentOS 9 (stream)

必须启用 centos-excas 存储库。默认情况下启用此存储库。如果您已经禁用了它，则需要重新启用它。

如果你之前安装过 Docker，旧版本的 Docker 使用的是 Docker 或 Docker-engine。在尝试安装新版本之前卸载任何这样的旧版本以及相关的依赖项。

运行以下命令卸载 Docker:

1
2
3
4
5
6
7
8


sudo yum remove docker \
 docker-client \
 docker-client-latest \
 docker-common \
 docker-latest \
 docker-latest-logrotate \
 docker-logrotate \
 docker-engine

开始安装 Docker

首次在新主机上安装 Docker 之前，需要设置 Docker 存储库。然后，您可以从存储库安装和更新 Docker。

设置 Docker 的 rpm 存储库

安装 yum-utils 包（它提供了 yum-config-manager 实用程序）并设置存储库。

复制以下命令到终端粘贴并回车运行

1
2


sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

安装 Docker 软件包

安装最新版本，运行:

1

sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

如果提示接受 GPG 密钥，请验证指纹是否匹配，然后接受指纹。

这个命令安装了 Docker，但是没有启动 Docker。它还创建了一个 docker 组，但是默认情况下它不会将任何用户添加到组中。

如果要安装特定版本的 Docker，首先从列出存储库中的可用版本开始:

1
2
3
4
5


yum list docker-ce --showduplicates | sort -r

docker-ce.x86_64 3:25.0.0-1.el8 docker-ce-stable
docker-ce.x86_64 3:24.0.7-1.el8 docker-ce-stable
<...>

选择所需的版本并安装：

1
2
3
4
5


VERSION_STRING=3:25.0.0-1.el8
sudo yum install docker-ce-$<VERSION_STRING> docker-ce-cli-$<VERSION_STRING> containerd.io docker-buildx-plugin docker-compose-plugin

# 或者直接指定对应版本
sudo yum install docker-ce-3:25.0.0-1.el8 docker-ce-cli-3:25.0.0-1.el8 containerd.io docker-buildx-plugin docker-compose-plugin

启动 Docker：

1

sudo systemctl start docker

通过运行 hello-world 镜像来验证 Docker 安装是否成功：

1

sudo docker run hello-world

此命令下载测试镜像并在容器中运行它。当容器运行时，它将打印一条确认消息并退出。

比如：

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


leo@mini-linux:~$ sudo docker run hello-world
[sudo] leo 的密码：

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
 (arm64v8)
 3. The Docker daemon created a new container from that image which runs the
 executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
 to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

如果验证通过，那么现在已经成功地安装并启动了 Docker。

卸载 Docker

卸载 Docker Engine、 CLI、 Container 和 Docker Compose 包:

1

sudo yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

删除所有镜像、容器和卷:

1
2


sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

UOS 安装 Docker

这里讲解一下 UOS/Deepin 如何安装 Docker，适用于 UOS 家庭版/专业版/教育版和 Deepin

因为 UOS 家庭版/专业版/教育版和 Deepin 20.x 版是基于 Debian 10 开发的，所以我们可以按照 Docker 官方文档使用 Debian 10 的方式安装，也就是本文 Debian 安装 Docker 的方法。

主要区别就是修改这行：

1

echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian buster stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

将 $(. /etc/os-release && echo "$VERSION_CODENAME") stable 改为了 buster stable，其他的是一致的。

LeetCode 75系列 - 392. 判断子序列

Thu, 11 Jan 2024 21:10:00 +0800

题目描述

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

示例 1：

1
2


输入：s = "abc", t = "ahbgdc"
输出：true

示例 2：

1
2


输入：s = "axc", t = "ahbgdc"
输出：false

提示：

0 <= s.length <= 100
0 <= t.length <= 10^4
两个字符串都只由小写字符组成。

题解

解法一

思路：string 的 find() 函数，当找到字符时，会返回此字符的位置，那么我继续从这个位置往下寻找，那么是不是就解决了呢？

我们对字符串 s 遍历，挨个搜索字符是否在字符串 t 里，如果在，则以此位置加一个偏移量开始继续搜索下一个字符。

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


class Solution {
public:
 bool isSubsequence(string s, string t) {
 std::string::size_type pos{0};
 for (int i = 0; i < s.size(); ++i) {
 auto ipos = t.find(s[i], pos);
 if (ipos == std::string::npos) {
 return false;
 } else {
 pos = ipos + 1;
 }
 }
 return true;
 }
};

解法二

设置双指针 i , j 分别指向字符串 s , t 的首个字符，遍历字符串 t ：

当 s[i] == t[j] 时，代表匹配成功，此时同时 i++ , j++ ；进而，若 i 已走过 s 尾部，代表 s 是 t 的子序列，此时应提前返回 true ；
当 s[i] != t[j] 时，代表匹配失败，此时仅 j++ ；
若遍历完字符串 t 后，字符串 s 仍未遍历完，代表 s 不是 t 的子序列，此时返回 false 。

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


class Solution {
public:
 bool isSubsequence(string s, string t) {
 if (s.size() > t.size())
 return false;
 for (int i = 0, j = 0; j < t.size(); j++) {
 if (s[i] == t[j]) {
 // 若已经遍历完 s ，则提前返回 true
 if (++i == s.size())
 return true;
 }
 }
 return false;
 }
};

C++ 智能指针实现之shared_ptr

Thu, 11 Jan 2024 17:10:00 +0800

前言

智能指针本质上并不神秘，其实就是 RAII 资源管理功能的自然展现而已。本文将介绍如何实现 C++中智能指针的 shared_ptr。

原理简介

多个不同的 shared_ptr 不仅可以共享一个对象，在共享同一对象时也需要同时共享同一个计数。当最后一个指向对象（和共享计数）的 shared_ptr 析构时，它需要删除对象和共享计数。

实现过程

我们先实现共享计数的接口，这个 shared_count 类除构造函数之外有三个方法：一个增加计数，一个减少计数，一个获取计数。

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


class shared_count {
public:
 shared_count() : count_(1) {}
 void add_count()
 {
 ++count_;
 }
 long reduce_count()
 {
 return --count_;
 }
 long get_count() const
 {
 return count_;
 }

private:
 long count_;
};

接下来可以实现我们的引用计数智能指针了。首先是构造函数、析构函数和私有成员变量：

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


template <typename T>
class shared_ptr {
public:
 explicit shared_ptr(T* ptr = nullptr)
 : ptr_(ptr)
 {
 if (ptr) {
 shared_count_ = new shared_count();
 }
 }
 ~shared_ptr()
 {
 if (ptr_ && !shared_count_->reduce_count()) {
 delete ptr_;
 delete shared_count_;
 }
 }

private:
 T* ptr_;
 shared_count* shared_count_;
};

构造函数会构造一个 shared_count 出来。析构函数在看到 ptr_ 非空时（此时根据代码逻辑， shared_count 也必然非空），需要对引用数减一，并在引用数降到零时彻底删除对象和共享计数。

为了方便实现赋值（及其他一些惯用法），我们需要一个新的 swap 成员函数：

1
2
3
4
5
6


void swap(shared_ptr& rhs)
{
 using std::swap;
 swap(ptr_, rhs.ptr_);
 swap(shared_count_, rhs.shared_count_);
}

赋值函数，拷贝构造和移动构造函数的实现：

 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


shared_ptr(const shared_ptr& other)
{
 ptr_ = other.ptr_;
 if (ptr_) {
 other.shared_count_->add_count();
 shared_count_ = other.shared_count_;
 }
}
template <typename U>
shared_ptr(const shared_ptr<U>& other) noexcept
{
 ptr_ = other.ptr_;
 if (ptr_) {
 other.shared_count_->add_count();
 shared_count_ = other.shared_count_;
 }
}
template <typename U>
shared_ptr(shared_ptr<U>&& other) noexcept
{
 ptr_ = other.ptr_;
 if (ptr_) {
 shared_count_ = other.shared_count_;
 other.ptr_ = nullptr;
 }
}

除复制指针之外，对于拷贝构造的情况，我们需要在指针非空时把引用数加一，并复制共享计数的指针。对于移动构造的情况，我们不需要调整引用数，直接把 other.ptr_ 置为空，认为 other 不再指向该共享对象即可。

不过，上面的代码有个问题：它不能正确编译。编译器会报错，像：

fatal error: ‘ptr_’ is a private member of ‘shared_ptr’

错误原因是模板的各个实例间并不天然就有 friend 关系，因而不能互访私有成员 ptr_ 和 shared_count_。我们需要在 shared_ptr 的定义中显式声明：

1
2


template <typename U>
friend class shared_ptr;

返回引用计数值

接下来，创建一个返回引用计数值的函数

1
2
3
4
5
6
7
8
9


long use_count() const
{
 if (ptr_) {
 return shared_count_
 ->get_count();
 } else {
 return 0;
 }
}

指针类型转换

对应于 C++ 里的不同的类型强制转换：

static_cast
reinterpret_cast
const_cast
dynamic_cast

智能指针需要实现类似的函数模板。实现本身并不复杂，但为了实现这些转换，我们需要添加构造函数，允许在对智能指针内部的指针对象赋值时，使用一个现有的智能指针的共享计数。如下所示：

1
2
3
4
5
6
7
8
9


template <typename U>
shared_ptr(const shared_ptr<U>& other, T* ptr)
{
 ptr_ = ptr;
 if (ptr_) {
 other.shared_count_->add_count();
 shared_count_ = other.shared_count_;
 }
}

这样我们就可以实现转换所需的函数模板了。下面实现一个 dynamic_pointer_cast 来示例一下：

1
2
3
4
5
6


template <typename T, typename U>
shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& other)
{
 T* ptr = dynamic_cast<T*>(other.get());
 return shared_ptr<T>(other, ptr);
}

验证

我们可以用下面的代码来验证一下它的功能正常：

 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 <iostream>
class shape {
public:
 virtual ~shape() {}
};

class circle : public shape {
public:
 ~circle() { std::cout<<"~circle()\n"; }
};

int main()
{
 shared_ptr<circle> ptr1(new circle());
 std::cout << "use count of ptr1 is" << ptr1.use_count() << "\n";
 shared_ptr<shape> ptr2;
 std::cout << "use count of ptr2 was " << ptr2.use_count() << "\n";
 ptr2 = ptr1;
 std::cout << "use count of ptr2 is now " << ptr2.use_count() << "\n";
 if (ptr1) {
 std::cout<<"ptr1 is not empty\n";
 }

 shared_ptr<circle> ptr3 = dynamic_pointer_cast<circle>(ptr2);
 std::cout << "use count of ptr3 is " << ptr3.use_count() << "\n";
}

输出：

1
2
3
4
5
6


use count of ptr1 is1
use count of ptr2 was 0
use count of ptr2 is now 2
ptr1 is not empty
use count of ptr3 is 3
~circle()

完整代码

 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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154


#include <utility> // std::swap

class shared_count {
public:
 shared_count() noexcept : count_(1) {}
 void add_count() noexcept
 {
 ++count_;
 }
 long reduce_count() noexcept
 {
 return --count_;
 }
 long get_count() const noexcept
 {
 return count_;
 }

private:
 long count_;
};

template <typename T>
class shared_ptr {
public:
 template <typename U>
 friend class shared_ptr;

 explicit shared_ptr(T* ptr = nullptr) : ptr_(ptr)
 {
 if (ptr) {
 shared_count_ = new shared_count();
 }
 }
 ~shared_ptr()
 {
 if (ptr_ && !shared_count_->reduce_count()) {
 delete ptr_;
 delete shared_count_;
 }
 }

 shared_ptr(const shared_ptr& other)
 {
 ptr_ = other.ptr_;
 if (ptr_) {
 other.shared_count_->add_count();
 shared_count_ = other.shared_count_;
 }
 }
 template <typename U>
 shared_ptr(const shared_ptr<U>& other) noexcept
 {
 ptr_ = other.ptr_;
 if (ptr_) {
 other.shared_count_->add_count();
 shared_count_ = other.shared_count_;
 }
 }
 template <typename U>
 shared_ptr(shared_ptr<U>&& other) noexcept
 {
 ptr_ = other.ptr_;
 if (ptr_) {
 shared_count_ = other.shared_count_;
 other.ptr_ = nullptr;
 }
 }
 template <typename U>
 shared_ptr(const shared_ptr<U>& other, T* ptr) noexcept
 {
 ptr_ = ptr;
 if (ptr_) {
 other.shared_count_->add_count();
 shared_count_ = other.shared_count_;
 }
 }
 shared_ptr& operator=(shared_ptr rhs) noexcept
 {
 rhs.swap(*this);
 return *this;
 }

 T* get() const noexcept
 {
 return ptr_;
 }
 long use_count() const noexcept
 {
 if (ptr_) {
 return shared_count_->get_count();
 }
 else {
 return 0;
 }
 }
 void swap(shared_ptr& rhs) noexcept
 {
 using std::swap;
 swap(ptr_, rhs.ptr_);
 swap(shared_count_, rhs.shared_count_);
 }

 T& operator*() const noexcept
 {
 return *ptr_;
 }
 T* operator->() const noexcept
 {
 return ptr_;
 }
 operator bool() const noexcept
 {
 return ptr_;
 }

private:
 T* ptr_;
 shared_count* shared_count_;
};

template <typename T>
void swap(shared_ptr<T>& lhs, shared_ptr<T>& rhs) noexcept
{
 lhs.swap(rhs);
}

template <typename T, typename U>
shared_ptr<T> static_pointer_cast(const shared_ptr<U>& other) noexcept
{
 T* ptr = static_cast<T*>(other.get());
 return shared_ptr<T>(other, ptr);
}

template <typename T, typename U>
shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& other) noexcept
{
 T* ptr = reinterpret_cast<T*>(other.get());
 return shared_ptr<T>(other, ptr);
}

template <typename T, typename U>
shared_ptr<T> const_pointer_cast(const shared_ptr<U>& other) noexcept
{
 T* ptr = const_cast<T*>(other.get());
 return shared_ptr<T>(other, ptr);
}

template <typename T, typename U>
shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& other) noexcept
{
 T* ptr = dynamic_cast<T*>(other.get());
 return shared_ptr<T>(other, ptr);
}

在代码里加了不少 noexcept。这对这个智能指针在它的目标场景能正确使用是十分必要的。

总结

我们实现了一个基本完整的带引用计数的shared_ptr智能指针。从而对智能指针有一个比较深入的理解。当然，这里与标准的std::shared_ptr还欠缺一些东西，比如多线程安全、不支持自定义删除器以及和std::weak_ptr的配合。

《现代 C++编程实战》

C++ 智能指针实现之unique_ptr

Thu, 11 Jan 2024 16:40:00 +0800

前言

智能指针本质上并不神秘，其实就是 RAII 资源管理功能的自然展现而已。本文将介绍如何实现 C++中智能指针的 unique_ptr。

实现过程

首先，unique_ptr 能够包装任意类型，所以，要让这个类能够包装任意类型的指针，我们需要把它变成一个类模板。

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


template <typename T>
class unique_ptr {
public:
 explicit unique_ptr(T* ptr = nullptr)
 : ptr_(ptr) {}
 ~unique_ptr()
 {
 delete ptr_;
 }
 T* get() const { return ptr_; }
private:
 T* ptr_;
};

目前这个 unique_ptr 的行为还是和指针有点差异的：

它不能用 * 运算符解引用
它不能用 -> 运算符指向对象成员
它不能像指针一样用在布尔表达式里

不过，这些问题也相当容易解决，加几个成员函数就可以：

1
2
3
4
5
6
7
8


template <typename T>
class unique_ptr {
public:
 …
 T& operator*() const { return *ptr_; }
 T* operator->() const { return ptr_; }
 operator bool() const { return ptr_; }
}

拷贝构造和赋值

最简单的情况显然是禁止拷贝。我们可以使用下面的代码：

1
2
3
4
5
6
7


template <typename T>
class unique_ptr {
 …
 unique_ptr(const unique_ptr&) = delete;
 unique_ptr& operator=(const unique_ptr&) = delete;
 …
};

禁用这两个函数非常简单，但是，有时我们需要转移所有权，那么这个方案就不可行了。

这里，我们采用移动语义：

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


template <typename T>
class unique_ptr {
 …
 unique_ptr(unique_ptr&& other)
 {
 ptr_ = other.release();
 }
 unique_ptr& operator=(unique_ptr rhs)
 {
 rhs.swap(*this);
 return *this;
 }
 …
};

把拷贝构造函数中的参数类型 unique_ptr& 改成了 unique_ptr&&；现在它成了移动构造函数。
把赋值函数中的参数类型 unique_ptr& 改成了 unique_ptr，在构造参数时直接生成新的智能指针，从而不再需要在函数体中构造临时对象。现在赋值函数的行为是移动还是拷贝，完全依赖于构造参数时走的是移动构造还是拷贝构造。根据 C++ 的规则，如果我提供了移动构造函数而没有手动提供拷贝构造函数，那后者自动被禁用。

子类指针向基类指针的转换

一个 circle* 类是可以隐式转换成 shape* 类的，但上面的 unique_ptr<circle> 却无法自动转换成 unique_ptr<shape>。

不过，只需要额外加一点模板代码，就能实现这一行为。在我们目前给出的实现里，只需要增加一个构造函数即可。

1
2
3
4
5


template <typename U>
unique_ptr(unique_ptr<U>&& other)
{
 ptr_ = other.release();
}

这样，我们自然而然利用了指针的转换特性：现在 unique_ptr<circle> 可以移动给 unique_ptr<shape>，但不能移动给 unique_ptr<triangle>。不正确的转换会在代码编译时直接报错。

验证

1
2
3
4
5
6


unique_ptr<shape> ptr1{create_shape(shape_type::circle)};
unique_ptr<shape> ptr2{ptr1}; // 编译出错
unique_ptr<shape> ptr3;
ptr3 = ptr1; // 编译出错
ptr3 = std::move(ptr1); // OK，可以
unique_ptr<shape> ptr4{std::move(ptr3)}; // OK，可以

完整代码

 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


#include <utility>

template <typename T>
class unique_ptr {
public:
 explicit unique_ptr(T* ptr = nullptr)
 : ptr_(ptr) {}
 ~unique_ptr()
 {
 delete ptr_;
 }
 unique_ptr(unique_ptr&& other)
 {
 ptr_ = other.release();
 }
 // 子类指针向基类指针的转换
 template <typename U>
 unique_ptr(unique_ptr<U>&& other)
 {
 ptr_ = other.release();
 }
 unique_ptr& operator=(unique_ptr rhs)
 {
 rhs.swap(*this);
 return *this;
 }
 T* release()
 {
 T* ptr = ptr_;
 ptr_ = nullptr;
 return ptr;
 }
 void swap(unique_ptr& rhs)
 {
 using std::swap;
 swap(ptr_, rhs.ptr_);
 }
 T* get() const { return ptr_; }
 T& operator*() const { return *ptr_; }
 T* operator->() const { return ptr_; }
 operator bool() const { return ptr_; }
private:
 T* ptr_;
};

总结

自行实现一个 unique_ptr 相对比较简单，因为不涉及引用计数，只需要一个对象只能被单个 unique_ptr 所拥有。

《现代 C++编程实战》

LeetCode 75系列 - 283. 移动零

Wed, 10 Jan 2024 19:10:00 +0800

题目描述

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

1
2


输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

1
2


输入: nums = [0]
输出: [0]

提示:

1 <= nums.length <= 10^4
-2^31 <= nums[i] <= 2^31 - 1

题解

类似于快速排序的思路，以 0 为基准，只要 nums[i]!=0，我们就交换 nums[i] 和 nums[j]。最终实现，交换到最后，大于 0 的都在左边，右边全剩下 0

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


class Solution {
public:
 void moveZeroes(vector<int>& nums) {
 int left{0};
 for (int i = 0; i < nums.size(); ++i) {
 if (nums[i] != 0) {
 swap(nums[i], nums[left]);
 left++;
 }
 }
 }
};

LeetCode 75系列 - 443. 压缩字符串

Mon, 08 Jan 2024 22:30:00 +0800

题目描述

给你一个字符数组 chars ，请使用下述算法压缩：

从一个空字符串 s 开始。对于 chars 中的每组 连续重复字符 ：

如果这一组长度为 1 ，则将字符追加到 s 中。
否则，需要向 s 追加字符，后跟这一组的长度。

压缩后得到的字符串 s 不应该直接返回 ，需要转储到字符数组 chars 中。需要注意的是，如果组长度为 10 或 10 以上，则在 chars 数组中会被拆分为多个字符。

请在 修改完输入数组后 ，返回该数组的新长度。

你必须设计并实现一个只使用常量额外空间的算法来解决此问题。

示例 1：

1
2
3


输入：chars = ["a","a","b","b","c","c","c"]
输出：返回 6 ，输入数组的前 6 个字符应该是：["a","2","b","2","c","3"]
解释："aa" 被 "a2" 替代。"bb" 被 "b2" 替代。"ccc" 被 "c3" 替代。

示例 2：

1
2
3


输入：chars = ["a"]
输出：返回 1 ，输入数组的前 1 个字符应该是：["a"]
解释：唯一的组是“a”，它保持未压缩，因为它是一个字符。

示例 3：

1
2
3


输入：chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
输出：返回 4 ，输入数组的前 4 个字符应该是：["a","b","1","2"]。
解释：由于字符 "a" 不重复，所以不会被压缩。"bbbbbbbbbbbb" 被 “b12” 替代。

提示：

1 <= chars.length <= 2000
chars[i] 可以是小写英文字母、大写英文字母、数字或符号

题解

解法一

思路：使用双指针计算重复字符的距离数字转为字符可直接使用 std::to_string() 转成字符串，然后 for 遍历每个字符，推入容器中。

 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


class Solution {
public:
 int compress(vector<char>& chars) {
 if (chars.size() < 2)
 return 1;
 vector<char> re;
 int left = 0;
 int right = 0;
 for (int i = 0; i < chars.size(); ++i) {
 if (i == chars.size() - 1 || chars[i] != chars[i + 1]) {
 int num = right - left + 1;
 re.push_back(chars[i]);
 if (num > 1) {
 auto str = std::to_string(num);
 for (const auto& c : str) {
 re.push_back(c);
 }
 }
 left = i;
 right = i;
 }
 else {
 right++;
 }
 }
 chars.clear();
 chars = re;
 return re.size();
 }
};

LeetCode 75系列 - 334. 递增的三元子序列

Mon, 08 Jan 2024 21:30:00 +0800

题目描述

给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。

如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。

示例 1：

1
2
3


输入：nums = [1,2,3,4,5]
输出：true
解释：任何 i < j < k 的三元组都满足题意

示例 2：

1
2
3


输入：nums = [5,4,3,2,1]
输出：false
解释：不存在满足题意的三元组

示例 3：

1
2
3


输入：nums = [2,1,5,0,4,6]
输出：true
解释：三元组 (3, 4, 5) 满足题意，因为 nums[3] == 0 < nums[4] == 4 < nums[5] == 6

提示：

1 <= nums.length <= 5 * 10^5
-2^31 <= nums[i] <= 2^31 - 1

题解

使用了贪心算法。

从左到右遍历数组 nums，遍历过程中维护两个变量 first 和 second，分别表示递增的三元子序列中的第一个数和第二个数，任何时候都有 first<second。

初始时，first=nums[0]，second=+∞。对于 1≤i<n，当遍历到下标 i 时，令 num=nums[i]，进行如下操作：

如果 num>second，则找到了一个递增的三元子序列，返回 true
如果 num>first，则将 second的值更新为 num
否则，将 first 的值更新为 num

如果遍历结束时没有找到递增的三元子序列，返回 false。

上述做法的贪心思想是：为了找到递增的三元子序列，first 和 second 应该尽可能地小，此时找到递增的三元子序列的可能性更大。

简单说就是：赋初始值时，已经满足 second > first ，现在找第三个数 third

如果 third 比 second 大，说明找到了，直接返回 true
如果 third 比 second 小，但是比 first 大，那就把 second 指向 third，然后继续遍历找 third
如果 third 比 first 还小，那就把 first 指向 third，然后继续遍历找 third（这样的话，first 会跑到 second 的后边，但是不要紧，因为在 second 的前边，旧 first 还是满足的）

 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


class Solution {
public:
 bool increasingTriplet(vector<int>& nums) {
 if (nums.size() < 3) {
 return false;
 }
 int first = nums[0];
 int second = std::numeric_limits<int>::max();

 for (int i = 1; i < nums.size(); i++) {
 // third比second大
 if (nums[i] > second) {
 return true;
 }
 // third比second小，但比first大
 else if (nums[i] > first) {
 second = nums[i];
 }
 // third比first还小
 else {
 first = nums[i];
 }
 }
 return false;
 }
};

LeetCode 75系列 - 238. 除自身以外数组的乘积

Tue, 02 Jan 2024 22:30:00 +0800

题目描述

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。

题目数据保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。

请 **不要使用除法，**且在 O(n) 时间复杂度内完成此题。

示例 1:

1
2


输入: nums = [1,2,3,4]
输出: [24,12,8,6]

示例 2:

1
2


输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]

提示：

2 <= nums.length <= 10^5
-30 <= nums[i] <= 30
保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内

题解

 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


class Solution {
public:
 vector<int> productExceptSelf(vector<int>& nums) {
 int length = nums.size();
 // L 和 R 分别表示左右两侧的乘积列表
 vector<int> L(length, 0), R(length, 0);
 vector<int> answer(length);

 // L[i] 为索引 i 左侧所有元素的乘积
 // 对于索引为 '0' 的元素，因为左侧没有元素，所以 L[0] = 1
 L[0] = 1;
 for (int i = 1; i < length; i++) {
 L[i] = nums[i - 1] * L[i - 1];
 }

 // R[i] 为索引 i 右侧所有元素的乘积
 // 对于索引为 'length-1' 的元素，因为右侧没有元素，所以 R[length-1] = 1
 R[length - 1] = 1;
 for (int i = length - 2; i >= 0; i--) {
 R[i] = nums[i + 1] * R[i + 1];
 }

 // 对于索引 i，除 nums[i] 之外其余各元素的乘积就是左侧所有元素的乘积乘以右侧所有元素的乘积
 for (int i = 0; i < length; i++) {
 answer[i] = L[i] * R[i];
 }

 return answer;
 }
};

LeetCode 75系列 - 151. 反转字符串中的单词

Tue, 02 Jan 2024 18:30:00 +0800

题目描述

给你一个字符串 s ，请你反转字符串中单词的顺序。

单词是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的单词分隔开。

返回单词顺序颠倒且单词之间用单个空格连接的结果字符串。

**注意：**输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

1
2


输入：s = "the sky is blue"
输出："blue is sky the"

示例 2：

1
2
3


输入：s = " hello world "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。

示例 3：

1
2
3


输入：s = "a good example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

提示：

1 <= s.length <= 10^4
s 包含英文大小写字母、数字和空格 ' '
s 中 至少存在一个 单词

题解

这道题可以在遍历的过程中先将字符串首尾的空格去掉，遇到空格时，即说明遍历了一个单词，此时只需要将单词存入栈中，待到遍历完之后，就可以从栈中取出单词构建一个字符串。

这里需要注意几点：

遍历时，需要注意 s[left] 越界问题
从栈中取出单词构造字符串时，最后一个单词末尾不能加空格

 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


class Solution {
public:
 string reverseWords(string s) {
 stack<string> word;
 string res;
 int left{0};
 int right = s.size() - 1;

 while (left <= right) {
 while (s[left] == ' ') {
 ++left;
 }
 while (s[right] == ' ') {
 --right;
 }

 while (s[left] != ' ' && left < s.size()) {
 res.push_back(s[left++]);
 }
 word.push(res);
 res.clear();
 }

 res.clear();
 while (!word.empty()) {
 res.append(word.top());
 word.pop();
 if (!word.empty())
 res.push_back(' ');
 }
 return res;
 }
};

这道题还可以使用双指针：

倒序遍历字符串 s ，记录单词左右索引边界 left , right
每确定一个单词的边界，将其添加至单词列表 res 中
最终，将单词列表拼接为字符串并返回即可。

LeetCode 75系列 - 345. 反转字符串中的元音字母

Fri, 29 Dec 2023 23:30:00 +0800

题目描述

给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。

元音字母包括 'a'、'e'、'i'、'o'、'u'，且可能以大小写两种形式出现不止一次。

示例 1：

**输入：**s = “hello” 输出：“holle”

示例 2：

**输入：**s = “leetcode” 输出：“leotcede”

提示：

1 <= s.length <= 3 * 10^5
s 由 可打印的 ASCII 字符组成

题解

这道题可以先将元音字母（包括大小写）存入容器中以供查询，逆序循环字符串，当遇到元音字母时，就存入队列中，并且标记对应位置。之后在顺序循环，依次在元音字母的位置，从队列的对头取出元音字母，赋值给字符串。

最核心的是通过队列从对头的方式实现了元音字母的反转和记住元音字母的位置。

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


class Solution {
public:
 string reverseVowels(string s) {
 set<char> words{'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'};
 vector<bool> v(s.size(), false);
 queue<char> re;

 for (int i = s.size(); i >= 0; i--) {
 if (words.contains(s[i])) {
 re.push(s[i]);
 v[i] = true;
 }
 }
 for (int i = 0; i < v.size(); ++i) {
 if (v[i] == true) {
 s[i] = re.front();
 re.pop();
 }
 }
 return s;
 }
};

LeetCode 75系列 - 605. 种花问题

Fri, 29 Dec 2023 21:30:00 +0800

题目描述

假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false 。

示例 1：

1
2


输入：flowerbed = [1,0,0,0,1], n = 1
输出：true

示例 2：

1
2


输入：flowerbed = [1,0,0,0,1], n = 2
输出：false

提示：

1 <= flowerbed.length <= 2 * 10^4
flowerbed[i] 为 0 或 1
flowerbed 中不存在相邻的两朵花
0 <= n <= flowerbed.length

题解

 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


class Solution {
public:
 bool canPlaceFlowers(vector<int>& flowerbed, int n) {
 int count = 0;
 int m = flowerbed.size();
 int prev = -1;
 for (int i = 0; i < m; i++) {
 if (flowerbed[i] == 1) {
 if (prev < 0) {
 count += i / 2;
 } else {
 count += (i - prev - 2) / 2;
 }
 if (count >= n) {
 return true;
 }
 prev = i;
 }
 }
 if (prev < 0) {
 count += (m + 1) / 2;
 } else {
 count += (m - prev - 1) / 2;
 }
 return count >= n;
 }
};

Linux 图形化视窗系统（X Window System）

Fri, 29 Dec 2023 17:20:13 +0800

前言

在 Linux 系统上，图形化视窗系统通常是 X Window System，简称 X11 或 X。

规范

1984 年 MIT 大学创造了 X 规范，就类似 TCP/IP 协议栈一样。是UNIX 系统构建图形化视窗系统的设计方案，准确名称叫“X Window System”。

X 规范在 1987 年形成了第 11 版（Version 11），1994 年发布第 11 版的第 6 次发行（Release 6），确切版本名即为“X11 R 6”，后来成为 UNIX 上图形视窗系统标准规范，也简称“X11”或者“X”，目前最新版本是 2012 年发布的“X11R7.7”。

“X11”采用了 C/S 的架构，在其设计下，整个图形视窗系统主要分为 3 个部分：

X Server（X 服务器）。X Server 一方面负责和设备驱动交互，监听显示器和键盘鼠标，另一方面响应 X Client 需求传递键盘、鼠标事件、（通过设备驱动）绘制图形文字等。注意，X Server 运行在本地。
X Client（X 客户端）。X Client 也叫 X 应用程序，负责实现程序逻辑，在收到设备事件后计算出绘图数据，由于本身没有绘制能力，只能向 X Server 发送绘制请求和绘图数据，告诉 X Server 在哪里绘制一个什么样的图形。X Client 可以和 X Server 在同一个主机上，也可以通过 TCP/IP 网络连接。
Window Manager（窗口管理器，简称 WM），或者叫合成器（Compositor）。多个 X Client 向 X Server 发送绘制请求时，各 X Client 程序并不知道彼此的存在，绘制图形出现重叠、颜色干扰等问题是大概率事件，这就需要一个管理者统一协调，即 Window Manager，它掌管各 X Client 的 Window（窗口）视觉外观，如形状、排列、移动、重叠渲染等。注意，Window Manager 并非 X Server 的一部分，而是一个特殊的 X Client 程序。

3 个部分， X Server 是整个 X Window System 的中心，协调 X 客户端和窗口管理器的通信。

“X11”充分遵循 UNIX 设计哲学，尽可能简单，除非必要绝不新增功能，其实也意味着粗糙、原始；提供机制而非具体策略，如菜单、按钮等元素细节并不做规定，交给窗口管理器、客户端程序等自主实现，于是不同的实现风格各异。任何遵循了 X11 规范的客户端程序和服务器程序配合起来，即可正常运行，X11 得益其开放性，迅速发展，成为 UNIX 系统的事实标准。

假定多个 X 客户端程序及窗口管理器在主机 A 上，某个 X Server（如下文 X.Org Server）运行在主机 B 上，程序运行过程可简化如下过程。

某个 X 客户端进程启动，向主机 B 发送连接请求，目标地址可通过命令行或配置文件指定，如果给定的地址已有 X Server 正在监听端口，则进行下一步；
主机 B 上的 X Server 返回一个连接正确响应，X Server 也可以配置接受或拒绝某些地址的请求；
X 客户端向 X Server 发送渲染请求及窗口界面数据；
X Server 一方面将窗口界面数据交给显示驱动计算渲染缓冲，另一方面综合各个 X 客户端的渲染请求，计算更新区域，但它并不知道如何将多个窗口“合成到一起”，于是将更新区域事件发给窗口管理器；
窗口管理器了解到需要在屏幕上重新合成一块区域，再向 X Server 发送整个屏幕的绘制请求和数据；
X Server 将绘图数据交给显示驱动计算所有渲染缓冲，并最终绘制图形；
运行过程中，X Server 可能收到主机 B 上的鼠标、键盘事件，经计算后，X Server 决定发给哪个 X 客户端（即获得焦点）；
X 客户端收到鼠标、键盘事件后，回调事件处理，并计算界面该如何更新；
循环第 3~8，直至 X 客户端收到关闭事件，进程终止、连接断开。

以上过程，主机 A 和 B 的 CPU 架构、操作系统可能都不相同，若 A 和 B 是同一个主机，就相当于在本地绘图、显示了。

XFree 86 和X.Org 等实现

X11 只是规范，并不是代码实现。

1992 年，XFree86 项目顺利开展，作为 X Window System 的一个早期开源实现，兼容 IBM PC 机（XFree86 中 86 的含义），得到广泛应用，项目地址 http://www.xfree86.org。至 2004 年，由于项目内部争论和许可证分歧，XFree86 从 GPL 协议改为 XFree 86 License 发布，项目从开放走向封闭。

2004 年，X.Org 基金会成立，开始领导 X 项目，不仅推动 X 规范本身发展，还在 XFree86 4.4 RC 2 版基础上开发了 X 规范的另一个实现—— X.Org Server，原来 XFree86 上很多开发者也转向了 X.Org Server，由于更加开放而被多数 GNU/Linux 发行版使用，项目官网 https://www.x.org，源代码库地址 http://cgit.freedesktop.org/xorg/xserver，2019年发布的稳定版为1.20.5。

在 X Client 方面，X.Org Server 实现了 2 个开发库，Xlib 和 XCB，便于开发者编写 X 应用程序。
在 X Server 方面，X.Org Server 实现了“X Window System”核心规范及多个扩展组件。
在 Window Manager 方面，X.Org Server 继承 XFree86 项目的 twm。
其他，实现了一个 X Display Manager（X 显示管理器）—— xdm。通常透过字符终端登录 Linux 主机时，用户仅能获得字符环境，而 X 显示管理器实现 XDMCP 规范（X Display Manager Control Protocol），为多用户提供图形登录、会话管理服务，允许用户登录时自主选择使用哪个 Window Manager 等。

除上 X Server，X11 系统客户端、窗口管理器也有着很多种实现。

客户端。Xlib 及其替代者 XCB 开发库过于靠近底层，于是就出现了进一步封装、抽象级别更高的 GUI 库，如 QT、GTK 等，比方说前者提供绘制点线面的方法，后者提供绘制按钮、滚动条、下拉菜单等控件的方法，更高层次的抽象对于简化开发工作的重要性不言而喻。在众多 X 客户端程序中，有一个比较著名—— xterm，它是基于 X 的终端模拟器，兼容 VT 102，也是 X 研发初期所计划的少数客户端程序之一。GNU/Linux 发行版中设备/dev/tty 1~~tty 6 对应着 6 个全屏纯字符的终端模拟器，通过 Ctrl-Alt-F 1~~F 6 切换，显示能力有限；如果运行到图形环境（通过 Ctrl-Alt-F 7 切换），一般都集成了 xterm，可配置的特性十分丰富，其他的诸如 Gnome Terminal、Konsole、xfce-term 等终端模拟器，或基于 xterm，或参考 xterm，增加了更多高级功能，如 tab 标签页、图片显示等。
窗口管理器。常见如 Metacity、Mutter、KWin、 vtwm、Xfwm、Compiz 等，功能、风格各异，有的注重简洁高效，有的注重外观酷炫。
服务器。X.Org Server 占绝对统治地位，但也有其他衍生变种或移植，如 XQuartz 以及 Cygwin/X、Xming、WeirdX，它们所支持的系统平台、底层库也都不一样。

需注意的是，X Window System 诞生比 Linux 早，也不是 UNIX 或 Linux 内核的一部分，而是用户态的软件组件，用户在系统上可以选择启用或禁用 X。

桌面环境

X Window System 各个部分都有着多种实现，X 规范本身特别偏底层，加之 GNU/Linux 自由开放的特点，有不少项目在 X 规范基础之上进一步封装，并把上述各组件、图标、主题、及其他特色组件打包在一起，形成开箱即用的桌面环境（Desktop Environment），常见如 Gnome、KDE、Unity、XFCE、LXDE 等，不一一列举，每种桌面环境都有不少用户群体，所支持的系统平台、底层库也各不一样。

应用场景

X11 规范的模块化设计，最大的好处是 X Client 和 X Server 相互独立，并不需要了解彼此所处的硬件、软件环境。常见的 X 应用程序诸如 xterm、输入法、Web浏览器、Office套件 等等，部署在一台 Linux 主机上，如果这个主机也同时部署了 X Server，那么运行这些 X 应用程序毫无障碍，这是作为桌面计算机的常见应用场景。

另一种应用场景，Linux 主机通常作为服务器使用，未配备比较好的图形显卡等硬件，也没有必要部署 X Server，从终端登录到 Linux 主机也仅有字符界面，那 X 应用程序该如何运行呢？可以在图形显卡等硬件设备比较好的 Windows/Mac 主机上部署 X Server，保持与 Linux 主机网络连通，在 Linux 主机上写好配置文件，配置好 X Server 地址和 X11 请求转发（X11 Forwarding），从任意一个终端登录到 Linux 主机并启动 X 客户端应用程序，就可以使程序的图形界面显示在 Windows/Mac 主机上，并与用户交互。事实上，在 1990 年代初期，就有这样的硬件设备，称为“X 终端机（X terminal）”，专门部署 X Server，将远端 UNIX 主机上的图形界面程序显示出来，这也正是 MIT 研发 X 的初衷之一。

从场景描述看出，与常规 Client/Server 所不同的是，通常 X Server 部署在本地用户主机上，监听、调控本地用户主机的硬件设备，而 X Client 可能部署在远端服务器/嵌入式设备上，也可能在本地。

X 的竞争对手

一方面，X 工作在用户空间，X 客户端程序不能直接访问显示驱动、X Server 与 X 客户端及窗口管理器之间繁琐的通信流程，拉低了绘图效率；另一方面，通过扩展、补丁手段允许在本地直接访问显示驱动，又造成稳定性问题。总之，X 的设计随着新技术发展而显得臃肿、过度复杂，背负了沉重的历史包袱。

Wayland

2010 年 Wayland 加入了 Freedesktop. org 项目，项目官网为 https://wayland.freedesktop.org，代码开源地址 https://cgit.freedesktop.org/wayland/wayland。

Wayland 是一个新的图形窗口系统方案，一套旨在取代 X 的新规范。与 X 最大的不同是，Wayland将 X 中的 Server 和窗口管理器整合到一起作为服务端，称为合成器（Compositor），架构上只分了客户端和合成器两大部件，有没有觉得终于看着舒服了一些。

客户端（Wayland Client），直接计算各自界面的渲染缓冲数据，客户端程序需要和渲染库（如 OpenGL）链接。
合成器（Wayland Compositor），汇总所有客户端的渲染数据，实现各界面窗口“合成”，最后交给显示驱动绘图。 Wayland 项目提供了两套底层库 libwayland-server 和 libwayland-client，简化图形程序开发，还给了一个 Compositor 参考实现——Weston。

假定多个 Wayland 客户端程序在主机 A 上，某个 Wayland Compositor（如 Weston）运行在主机 B 上。

某个客户端进程启动，向主机 B 发送连接请求，目标地址可通过命令行或配置文件指定，如果给定的地址已有 Compositor 正在监听端口，则进行下一步；
主机 B 上的 Compositor 返回一个连接正确响应，Compositor 也可以配置接受或拒绝某些地址的请求；
客户端自行生成 UI 界面和渲染缓冲，不需要向 Compositor 发送绘制请求，但需要发送更新区域事件，告知渲染缓冲中更新了哪些内容；
Compositor 综合各客户端的区域更新事件，重新合成整个屏幕，并交给显示驱动绘制图形；
运行过程中，Compositor 可能收到主机 B 上的鼠标、键盘事件，经计算后，Compositor 决定发给哪个客户端（即获得焦点）；
客户端收到鼠标、键盘事件后，回调事件处理；
循环第 3~6，直至客户端收到关闭事件，进程终止、连接断开。

Wayland 适用于桌面设备，也适用于移动设备，原来基于 X 的 GUI 库、桌面环境很快适配了对 Wayland 的支持，如 Qt、Gnome、KDE、Compiz 等，Ubuntu 更是早在 2010 年就将 Unity 切换到适配 Wayland。Wayland 依赖了较多 Linux 内核技术，不易移植到其他系统平台。

XWayland

Wayland 开发者在 X.Org Server 基础上打上系列补丁，称为 XWayland，目的是在 Wayland 规范之上搞成新的 X Server，在 Wayland 环境中运行 X 客户端程序时，Wayland 合成器（如 Weston）调用 XWayland 进行服务，以便在过渡到 Wayland 过程中保持对 X 的兼容性。

总结

尽管有这样那样的问题，X 仍然是 GNU/Linux、UNIX 上的主力，Wayland 作为强有力的竞争对手，在远程桌面方面亦存在问题，重度依赖 Linux 内核技术不易移植到其他系统平台。在微软的 WSL 崛起之时，X 的优势倒可以尽情发挥出来。

Cygwin系列（十二）：了解X | silaoA的博客

LeetCode 75系列 - 1431. 拥有最多糖果的孩子

Thu, 28 Dec 2023 21:30:00 +0800

题目描述

给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。

对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有最多的糖果。注意，允许有多个孩子同时拥有最多的糖果数目。

示例 1：

1
2
3
4
5
6
7
8


输入：candies = [2,3,5,1,3], extraCandies = 3
输出：[true,true,true,false,true]
解释：
孩子 1 有 2 个糖果，如果他得到所有额外的糖果（3个），那么他总共有 5 个糖果，他将成为拥有最多糖果的孩子。
孩子 2 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。
孩子 3 有 5 个糖果，他已经是拥有最多糖果的孩子。
孩子 4 有 1 个糖果，即使他得到所有额外的糖果，他也只有 4 个糖果，无法成为拥有糖果最多的孩子。
孩子 5 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。

示例 2：

1
2
3


输入：candies = [4,2,1,1,2], extraCandies = 1
输出：[true,false,false,false,false]
解释：只有 1 个额外糖果，所以不管额外糖果给谁，只有孩子 1 可以成为拥有糖果最多的孩子。

示例 3：

1
2


输入：candies = [12,1,12], extraCandies = 10
输出：[true,false,true]

提示：

2 <= candies.length <= 100
1 <= candies[i] <= 100
1 <= extraCandies <= 50

题解

这里的思路是可以先通过排序，找到最小值和最大值，如果最小值加额外值的和大于最大值，那么说明全为 true。之后再通过循环，挨个比较与额外值的和是否大于等于最大值，如果是，那么为 true，如果不是则为 false。

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


class Solution {
public:
 vector<bool> kidsWithCandies(vector<int>& candies, int extraCandies) {
 vector<int> res{candies};
 vector<bool> re(candies.size(), true);
 sort(res.begin(), res.end());
 int max = res.back();
 int min = res.front();
 if (min + extraCandies > max)
 return re;
 for (int i = 0; i < candies.size(); ++i) {
 if (candies[i] + extraCandies > max ||
 candies[i] + extraCandies == max)
 re[i] = true;
 else
 re[i] = false;
 }
 return re;
 }
};

LeetCode 75系列 - 1071. 字符串的最大公因子

Wed, 27 Dec 2023 20:31:13 +0800

题目描述

对于字符串 s 和 t，只有在 s = t + ... + t（t 自身连接 1 次或多次）时，我们才认定 “t 能除尽 s”。

给定两个字符串 str1 和 str2 。返回 最长字符串 x，要求满足 x 能除尽 str1 且 x 能除尽 str2 。

示例 1：

1
2


输入：str1 = "ABCABC", str2 = "ABC"
输出："ABC"

示例 2：

1
2


输入：str1 = "ABABAB", str2 = "ABAB"
输出："AB"

示例 3：

1
2


输入：str1 = "LEET", str2 = "CODE"
输出：""

提示：

1 <= str1.length, str2.length <= 1000
str1 和 str2 由大写英文字母组成

题解

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


class Solution {
 bool check(string t,string s){
 int lenx = (int)s.length() / (int)t.length();
 string ans = "";
 for (int i = 1; i <= lenx; ++i){
 ans = ans + t;
 }
 return ans == s;
 }
public:
 string gcdOfStrings(string str1, string str2) {
 int len1 = (int)str1.length(), len2 = (int)str2.length();
 for (int i = min(len1, len2); i >= 1; --i){ // 从长度大的开始枚举
 if (len1 % i == 0 && len2 % i == 0){
 string X = str1.substr(0, i);
 if (check(X, str1) && check(X, str2)) return X;
 }
 }
 return "";
 }
};

LeetCode 75系列 - 1768. 交替合并字符串

Tue, 26 Dec 2023 20:30:06 +0800

题目描述

给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。

返回 合并后的字符串 。

示例 1：

1
2
3
4
5
6


输入：word1 = "abc", word2 = "pqr"
输出："apbqcr"
解释：字符串合并情况如下所示：
word1： a b c
word2： p q r
合并后： a p b q c r

示例 2：

1
2
3
4
5
6


输入：word1 = "ab", word2 = "pqrs"
输出："apbqrs"
解释：注意，word2 比 word1 长，"rs" 需要追加到合并后字符串的末尾。
word1： a b
word2： p q r s
合并后： a p b q r s

示例 3：

1
2
3
4
5
6


输入：word1 = "abcd", word2 = "pq"
输出："apbqcd"
解释：注意，word1 比 word2 长，"cd" 需要追加到合并后字符串的末尾。
word1： a b c d
word2： p q
合并后： a p b q c d

提示：

1 <= word1.length, word2.length <= 100
word1 和 word2 由小写英文字母组成

题解

对于这道题，首先可以想到，交替地插入字符即可。这里需要考虑字符串长度不一致应该如何处理。

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


class Solution {
public:
 string mergeAlternately(string word1, string word2) {
 int i{0};
 int j{0};
 string re;
 while (i < word1.size()) {
 re.push_back(word1[i++]);
 if (j < word2.size()) {
 re.push_back(word2[j++]);
 }
 }
 re += word2.substr(j);
 return re;
 }
};

对于 C++，需要注意的一点是，string 的 push_back() 原型是 void push_back(CharT ch);，即参数是 char 类型。

以上解法相比于官方解法少了一次 if 判断，但也增加了理解难度。可以参考官方的题解：

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


class Solution {
public:
 string mergeAlternately(string word1, string word2) {
 int m = word1.size(), n = word2.size();
 int i = 0, j = 0;
 string ans;

 while (i < m || j < n) {
 if (i < m) {
 ans.push_back(word1[i]);
 ++i;
 }
 if (j < n) {
 ans.push_back(word2[j]);
 ++j;
 }
 }
 return ans;
 }
};

Hugo Stack主题博客添加Waline评论系统

Sat, 16 Dec 2023 21:58:04 +0800

前言

博客搭建完成之后，可以添加一个评论系统，方便读者反馈交流。这里选用的是 Waline，因为 Hugo Stack 主题支持 Waline，所以配置起来也会方便不少。同时Waline，只需几个步骤，就可以在你的网站中启用 Waline 提供评论服务。

所以，本文将要介绍给博客添加Waline评论系统，并配置以自己的域名邮箱接收博客评论的邮箱通知提醒功能。

由于Waline文档写的挺详细的，所以直接照搬过来，并针对自身的需求做些改动。

LeanCloud 设置 (数据库)

登录或注册 LeanCloud 国际版 并进入控制台
点击左上角创建应用并起一个你喜欢的名字 (选择免费的开发版):
进入应用，选择左下角的 设置 > 应用 Key。你可以看到你的 APP ID,APP Key 和 Master Key。请记录它们，以便后续使用。

注意！如果使用 Leancloud 国内版 (leancloud.cn) 需要备案，推荐使用国际版 (leancloud.app)。否则，你需要为应用额外绑定已备案的域名，同时购买独立 IP 并完成备案接入。

Vercel 部署 (服务端)

点击上方按钮，跳转至 Vercel 进行 Server 端部署。

注：如果你未登录的话，Vercel 会让你注册或登录，请使用 GitHub 账户进行快捷登录。
输入一个你喜欢的 Vercel 项目名称并点击 Create 继续:
此时 Vercel 会基于 Waline 模板帮助你新建并初始化仓库，仓库名为你之前输入的项目名。

一两分钟后，满屏的烟花会庆祝你部署成功。此时点击 Go to Dashboard 可以跳转到应用的控制台。
点击顶部的 Settings - Environment Variables 进入环境变量配置页，并配置三个环境变量 LEAN_ID, LEAN_KEY 和 LEAN_MASTER_KEY 。它们的值分别对应上一步在 LeanCloud 中获得的 APP ID, APP KEY, Master Key。
环境变量配置完成之后点击顶部的 Deployments 点击顶部最新的一次部署右侧的 Redeploy 按钮进行重新部署。该步骤是为了让刚才设置的环境变量生效。
此时会跳转到 Overview 界面开始部署，等待片刻后 STATUS 会变成 Ready。此时请点击 Visit ，即可跳转到部署好的网站地址，此地址即为你的服务端地址。

Stack 主题启用Waline

在 config/_default/params.toml 配置文件里找到这一区块：

1
2
3
4


## Comments
[comments]
enabled = true
provider = "waline"

将 enabled 改完 true，provider 改为 waline，然后在 comments.waline 区块设置 waline 的相关配置：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[comments.waline]
serverURL = "your-server-url"
lang = "zh-CN"
avatar = ""
emoji = ["https://cdn.jsdelivr.net/gh/walinejs/emojis/weibo"]
requiredMeta = ["nick", "mail", "url"]

[comments.waline.locale]
admin = "Admin"
placeholder = "评论区掩码"

serverURL 改为你的 vercel 的服务端地址即可。

评论服务此时就会在你的网站上成功运行 🎉

评论管理 (管理端)

部署完成后，请访问 <serverURL>/ui/register 进行注册。首个注册的人会被设定成管理员。
管理员登陆后，即可看到评论管理界面。在这里可以修改、标记或删除评论。
用户也可通过评论框注册账号，登陆后会跳转到自己的档案页。

评论邮箱通知

当网站有用户发布评论或者用户回复评论时，Waline 支持对博主和回复评论作者进行通知，当访客的评论收到回复时，我们会对访客进行邮件通知。

邮件通知需要配置以下环境变量:

SMTP_SERVICE: SMTP 邮件发送服务提供商。

提示

你可以在这里查看所有支持的运营商。

如果你的运营商不受支持，你必须填写 SMTP_HOST 和 SMTP_PORT。
- SMTP_HOST: SMTP 服务器地址，一般可以在邮箱的设置中找到。
- SMTP_PORT: SMTP 服务器端口，一般可以在邮箱的设置中找到。
SMTP_USER: SMTP 邮件发送服务的用户名，一般为登录邮箱。
SMTP_PASS: SMTP 邮件发送服务的密码，一般为邮箱登录密码，部分邮箱(例如 163)是单独的 SMTP 密码。
SMTP_SECURE: 是否使用 SSL 连接 SMTP。
SITE_NAME: 网站名称，用于在消息中显示。
SITE_URL: 网站地址，用于在消息中显示。
AUTHOR_EMAIL: 博主邮箱，用来接收新评论通知。如果是博主发布的评论则不进行提醒通知。
SENDER_NAME: 自定义发送邮件的发件人
SENDER_EMAIL: 自定义发送邮件的发件地址

这里我们选择的是 Brevo，关于 Brevo 的配置参见免费搭建属于自己的域名个性邮箱 (limuran.top)。

1
2
3
4
5


"SendinBlue": {
 "aliases": ["Brevo"],
 "host": "smtp-relay.brevo.com",
 "port": 587
 }

当你创建好后，前往 Vercel 继续添加环境变量。

所需环境变量如下表：

Key	Value	Comment（用于解释作用）
SMTP_SERVICE	SendinBlue	Brevo 对应的提供商是 `SendinBlue`
SMTP_USER		Brevo Login 对应的邮箱名
SMTP_PASS		Brevo 的 SMTP key value
SITE_NAME		网站名称
SITE_URL		网站地址
AUTHOR_EMAIL		作者邮箱
SENDER_NAME		发件人昵称
SENDER_EMAIL		发件人域名邮箱（如：limuran@limuran.top）

空着的 Value 自行添加。

然后再点击 Redeploy 按钮进行重新部署，即可生效，之后就可测试了。

视频教程

以下是热心用户制作的视频教程，以上操作不清楚的也可以参考一二。

Waline 部署教程（快速上手）

A BiliBili video

使用 Vercel 简单地部署 Waline 评论系统

A BiliBili video

免费搭建属于自己的域名个性邮箱

Fri, 15 Dec 2023 21:56:46 +0800

前言

通常来说，平时使用的邮箱多是 @qq.com、@163.com、@outlook.com，即@之后的后缀名称是固定的。如果以自己的域名为邮箱后缀，那么是非常 cool 的！

比如我的域名是 limuran.top，使用自己的域名为邮箱后缀，将是admin@limuran.top这样的邮箱。

那么如何实现呢？首先需要满足一些前置条件：

域名（可 DNS 解析）

注册 Brevo 账号

选择 Brevo 是因为：

支持 SMTP 和 API
永久免费套餐：每日最多 300 封，免费套餐适合中小型站点

在 https://onboarding.brevo.com/account/register 界面注册账号，需要邮箱和手机号验证，这里介意手机号接收验证码的可以劝退了。

填写基础信息

填写公司相关信息，这里可以随便填：

然后就是公司规模，推荐填小规模的：接下来需要验证手机号了

选择免费套餐进入控制面板：

以上账号便注册完毕了。

配置 Brevo

接下来，在 Campaigns 设置里绑定域名

选择 Domains

Enter your email domain：输入自己的域名
Your email domain provider：如果域名不是这些机构买的，选 Other 即可

然后进入 Configuration ，有两项Brevo code和DKIM record的值需要填入到域名的 DNS 解析中。

以阿里云为例，在域名解析面板添加记录，记录类型选择TXT，主机记录填 Name 的值，记录值填 Value

然后在 Brevo 网站右上角点击公司名展开列表选项，选择 Senders，Domains & Dedicated IPs，添加发送者

From name 填入发件人的名称，From email 填入自定义的邮箱号。添加完成后，即可来测试一下了。

SMTP 验证

还是右上角打开 SMTP & API

这些参数将会用上

打开 https://smtpserver.com/cn/smtptest 网站，填写对应信息：

用户名就是指 Login 的值，密码就是 Master Password，发件人指刚刚创建的 Sender 发件人

点击 测试smtp ，成功返回响应，同时邮箱也收到对应的邮件了。

至此，就完成了配置。

总结

创建一个属于自己域名的邮箱后缀就完成了，可能有人会问，那有何用处呢？我这里主要的用途是用作评论系统的邮件通知使用。

由于以上步骤为事后回忆记录，未全流程截图，故部分截图源于网络。

在线SMTP服务器测试

https://writee.org/salt/smtp-services-overview

注册Brevo配置开源独角数卡SMTP

让搜索引擎收录博客网站

Mon, 11 Dec 2023 23:10:24 +0800

前言

个人博客搭建好之后，我们还需要让搜索引擎收录我们的站点，这样别人才能搜索到，才有更多的曝光量。

通常来说，搜索引擎的爬虫会自动爬取网站并收录，但是这个过程时间不可控，通常会很慢。所以，可以采取主动让搜索引擎收录的方式，加快这个过程。那么，如何主动提交站点让搜索引擎收录呢？

准备工作

为了更好地让搜索引擎收录我们的站点，我们需要先做一些工作。

站点地图（site map）

站点地图是一种文件，您可以在其中提供与您网站中的网页、视频或其他文件有关的信息，还可以说明这些内容之间的关系。Google 等搜索引擎会读取此文件，以便更高效地抓取您的网站。站点地图会告诉 Google 您认为网站中的哪些网页和文件比较重要，还会提供与这些文件有关的重要信息。例如，网页上次更新的时间和网页是否有任何备用的语言版本。

由于使用的Hugo博客框架可以自动帮我们在根目录生成 sitemap.xml，所以我们可以不用管。

各大搜索引擎都有对应的站长工具，我们挨个将站点提交并验证，然后即可等待被收录了。

Google

进入 Google Search Console 添加自己的站点地址，按照提示进行验证网站所有权即可。

然后按照提示提交站点地图即可，之后等待收录情况即可。

除此之外，还有一种不用登录就可以提交的方法，那就是ping提交：

1

http://google.com/ping?sitemap=你需要提交的网页地址、或是URL列表页地址

回车访问页面。等到下方结果后就代表提交成功，无需做更多操作，十分的简单。

Bing

进入 Bing Webmaster Tools 添加自己的站点地址并验证，如果已经在Google添加了站点，可选择通过 Google Search Console 进行验证直接导入，避免再次验证站点所有权。

同样地，提交站点地图。

百度

进入百度搜索资源平台，然后登录账号，添加站点时，需要填入自己的手机号，邮箱，微信号等（Emmmmmm 🙄）。

不过，百度添加站点时，似乎有些问题，显示301网页存在跳转，好吧，暂时放弃了。

360

360 应该算是最友好的了，因为可以不用登录，直接进入网站收录_360搜索提交即可

总结

在同一天都提交了，除了百度，然后谷歌是收录最快的，第二天就收录了。Bing、360 第三天还没结果。

Google 搜索中心 | 网站 SEO 资源 | Google for Developers

如何查看自己的网站被搜索引擎收录

Sat, 09 Dec 2023 23:18:44 +0800

前言

当我们已经搭建好自己的个人博客，并且申请了自己的域名。但是我们写的博客并不能让更多的人了解和访问，需要通过搜索引擎将网站收录，才能让更多的人能够搜索到。

那么，我们如何知道自己的网站有没有被搜索引擎收录呢？

方法一：使用site指令查询

site指令是搜索引擎提供的一种高级搜索功能，可以帮助用户快速查找到特定网站的相关内容。通过在搜索引擎中输入特定的site指令，可以查看你的网站是否被搜索引擎收录以及收录的数量。

即在搜索引擎中输入site:domain name形式，比如域名是limuran.top：

1

site:limuran.top

Bing 搜索引擎结果

Google搜索引擎结果

当被搜索引擎收录时，使用此方法便可看到网站相关的词条。反之，则看不到相关的结果

方法二：使用站长工具

站长工具是一种专门为网站管理员提供的在线工具，可以帮助用户查询网站的SEO信息、关键词排名、收录情况等。通过使用站长工具，用户可以更加方便地查看自己的网站是否被搜索引擎收录以及收录的数量。

比如这里使用站长工具 - 站长之家，输入自己的域名即可查询相关的情况，这里我们重点在搜索引擎收录上，可以看到各大搜索引擎的收录情况

总结

总之，通过以上两种方法，你可以方便地查看自己的网站是否被搜索引擎收录以及收录的数量。如果你的网站尚未被搜索引擎收录，可以尝试优化网站的SEO设置，提高网站的权重和排名，从而增加被搜索引擎收录的机会。还可以尝试主动提交给搜索引擎收录。

基于 Github Actions 自动构建发布 Hugo 博客

Mon, 04 Dec 2023 23:07:37 +0800

前言

Hugo 是目前流行的开源静态网站生成器中的一个，使用它生成最终的静态页面放在 Web 服务器上即可完成部署。

通常来说，可能是工作流是这样：本地写文章 -> 本地构建页面 -> 上传 public 文件夹到云服务器。这个步骤有些繁琐，而本文简化了构建和上传步骤。

这里，我们介绍如何基于 Github Actions 自动构建静态页面并发布到云服务器上实现页面自动更新内容。

本文基于 Stack 主题的 CaiJimmy/hugo-theme-stack-starter 模板，这样帮我们省事不少，因为自带了 Github Actions ，我们只需要修改模板里的 .github/workflows/deploy.yml 文件即可实现自动发布到云服务器上。

前置条件：

Linux 系统的云服务器
基于 CaiJimmy/hugo-theme-stack-starter 创建了自己的仓库
会 Git 命令

当然，其他主题也会有类似的快速开始的模板，大同小异。

实现步骤

修改 .github/workflows/deploy.yml 文件：

 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


name: Deploy to Cloud Server

on:
 push:
 branches: [master]
 pull_request:
 branches: [master]

jobs:
 build:
 runs-on: ubuntu-latest

 permissions:
 # Give the default GITHUB_TOKEN write permission to commit and push the
 # added or changed files to the repository.
 contents: write

 steps:
 - uses: actions/checkout@v3

 - name: Cache Hugo resources
 uses: actions/cache@v3
 env:
 cache-name: cache-hugo-resources
 with:
 path: resources
 key: ${{ env.cache-name }}

 - uses: actions/setup-go@v4
 with:
 go-version: "^1.17.0"
 - run: go version

 - name: Setup Hugo
 uses: peaceiris/actions-hugo@v2
 with:
 hugo-version: "latest"
 extended: true

 - name: Build
 run: hugo --minify --gc

 - name: Deploy to cloud server
 uses: burnett01/rsync-deployments@6.0.0
 with:
 # -a: 表示以归档模式进行同步，保留文件的所有属性和权限
 # -v: 表示输出详细的同步过程信息
 # -z: 表示在传输文件时进行压缩，以减少传输时间和带宽
 # -r: 表示递归地同步目录及其子目录
 # --delete: 表示在目标目录中删除源目录中不存在的文件
 switches: -avzr --delete
 path: ./public
 remote_path: /home/nginx/html/
 remote_host: ${{ secrets.DEPLOY_HOST }} # 远程主机 IP
 remote_port: ${{ secrets.DEPLOY_PORT }} # ssh 端口，默认为 22
 remote_user: ${{ secrets.DEPLOY_USER }} # ssh user
 remote_key: ${{ secrets.DEPLOY_KEY }} # ssh 私钥（云服务器创建密钥，下载的key.pem文件）

代码里有详尽的注释，这里还是展开介绍一下吧。如果你熟悉 Github Actions 的话，其实应该很好理解。不熟悉的话也没关系，照抄就行了。

重点在于最后一步:

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


 - name: Deploy to cloud server
 uses: burnett 01/ rsync-deployments@6.0.0
 with:
 # -a: 表示以归档模式进行同步，保留文件的所有属性和权限
 # -v: 表示输出详细的同步过程信息
 # -z: 表示在传输文件时进行压缩，以减少传输时间和带宽
 # -r: 表示递归地同步目录及其子目录
 # --delete: 表示在目标目录中删除源目录中不存在的文件
 switches: -avzr --delete
 path: ./public
 remote_path: /home/nginx/html/
 remote_host: $ {{ secrets.DEPLOY_HOST }} # 远程主机 IP
 remote_port: $ {{ secrets.DEPLOY_PORT }} # ssh 端口，默认为 22
 remote_user: $ {{ secrets.DEPLOY_USER }} # ssh user
 remote_key: $ {{ secrets.DEPLOY_KEY }} # ssh 私钥（云服务器创建密钥，下载的 key. pem 文件）

使用 burnett 01/rsync-deployments 工作流，原理就是利用 Linux 的 rsync 命令将文件同步到对应的云服务器。

remote_path就是指云服务器上的站点挂载目录，比如我这里使用的 nginx ，挂载目录是 /home/nginx/html/
remote_host 指云服务器的公网 IP
remote_port是 ssh 登录的端口，默认是 22，如果自己修改过，填上对应的端口即可
remote_user就是指云服务器的用户名
remote_key 云服务器的密钥，这个需要注意，不是 ssh 登录密码，而是通过云服务器厂商的控制台创建的密钥。比如，我这里用的是阿里云的服务器，在云服务器 ECS 页面，网络与安全 - 密钥对这里创建一个，会得到一个 xxxx. pem 的文件，保存好这个文件，后面会用到。

然后，前往 GitHub 博客仓库，在 Settings - Secrets and variables - Actions 界面添加 secret key。

创建 secret：

DEPLOY_HOST 填入公网 IP
DEPLOY_PORT 填入 ssh 端口
DEPLOY_USER 填入用户名
DEPLOY_KEY 填入 xxx. pem 文件的内容

之后，登录自己的云服务器，查看是否安装 rsync，同时查看是否处于运行中：

1
2
3
4
5
6


~# systemctl status rsync
○ rsync. service - fast remote file copy program daemon
 Loaded: loaded (/lib/systemd/system/rsync. service; disabled; vendor preset: enabled)
 Active: inactive (dead)
 Docs: man: rsync (1)
 man: rsyncd.conf (5)

Active: inactive (dead)就说明未启动，我们设置为开机自动：

1
2


systemctl enable rsync
systemctl start rsync

然后再使用 systemctl status rsync 可以看到：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


~# systemctl status rsync
○ rsync. service - fast remote file copy program daemon
 Loaded: loaded (/lib/systemd/system/rsync. service; enabled; vendor preset: enabled)
 Active: inactive (dead)
 Condition: start condition failed at Thu 2023-11-30 23:29:42 CST; 3 days ago
 └─ ConditionPathExists=/etc/rsyncd. conf was not met
 Docs: man: rsync (1)
 man: rsyncd.conf (5)

Nov 30 23:29:42 ecs systemd[1]: Condition check resulted in fast remote file copy program daemon being skipped.

多了 Condition: start condition failed at Thu 2023-11-30 23:29:42 CST; 3 days ago这一行之后，就可以使用了

验证

1
2
3


git add -u
git commit -m "add actions"
git push

git 三部曲之后前往 GitHub 查看结果

同时，可以查看自己的博客是否已经更新。

总结

本文介绍了 Github Action 自动构建发布到云服务器上的方法，当然也可直接发布到 GitHub Pages 上，由于这样更简单，可直接参考基于 Github Action 自动构建 Hugo 博客 - (lixueduan.com) 。

基于 Github Action 自动构建 Hugo 博客 - (lixueduan.com)

Hugo Stack 主题美化

Sun, 03 Dec 2023 21:52:07 +0800

前言

Hugo Stack 主题很好看，但是还有一些细节地方有些粗糙，同时想增加一些自己喜欢的功能，于是写下这篇美化文章。

文件添加随机海报

寻找一个好看的封面图是一件费时间的事情，那么我们可以自动生成一张随机的封面图解决这个问题。

推荐在模板中设置，修改 archetypes/default.md（如果没有则新建一个即可）

1
2
3
4
5


---
title: "{{ replace .Name "-" " " | title }}"
date: {{ .Date }}
image: https://picsum.photos/800/600.webp?random={{ substr (md5 (.Date)) 4 8 }}
---

这里的重点是 image 这一行，即使用了 Lorem Picsum 的接口，然后就可以得到一张随机的图片，更多详情也可前往 Lorem Picsum 了解。

之后，我们通过 hugo new 命令时，新建的文章会随机匹配一张图片

增加加载进度条

在 layouts/partials/footer/custom.html 中增加以下内容：

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


<script
 src="https://cdn.jsdelivr.net/gh/zhixuan2333/gh-blog@v0.1.0/js/nprogress.min.js"
 integrity="sha384-bHDlAEUFxsRI7JfULv3DTpL2IXbbgn4JHQJibgo5iiXSK6Iu8muwqHANhun74Cqg"
 crossorigin="anonymous"
></script>
<link
 rel="stylesheet"
 href="https://cdn.jsdelivr.net/gh/zhixuan2333/gh-blog@v0.1.0/css/nprogress.css"
 integrity="sha384-KJyhr2syt5+4M9Pz5dipCvTrtvOmLk/olWVdfhAp858UCa64Ia5GFpTN7+G4BWpE"
 crossorigin="anonymous"
/>
<script>
 NProgress.start();
 document.addEventListener("readystatechange", () => {
 if (document.readyState === "interactive") NProgress.inc(0.8);
 if (document.readyState === "complete") NProgress.done();
 });
</script>

然后就可以看到网页上方会有一个加载进度的进度条了。

添加彩虹背景

layouts/partials/footer/custom.html 中增加以下内容:

1
2
3
4
5
6
7
8
9


<script
 src="https://cdn.jsdelivr.net/gh/zhixuan2333/gh-blog@v0.1.0/js/ribbon.min.js"
 integrity="sha384-UEK8ZiP3VgFNP8KnKMKDmd4pAUAOJ59Y2Jo3ED2Z5qKQf6HLHovMxq7Beb9CLPUe"
 crossorigin="anonymous"
 size="300"
 alpha="0.6"
 zindex="-1"
 defer
></script>

滚动条美化

默认的滚动条有点丑，但是我们可以优化一下。

assets/scss/custom.scss 添加以下内容：

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


html{
 ::-webkit-scrollbar {
 width: 20px;
 }

 ::-webkit-scrollbar-track {
 background-color: transparent;
 }

 ::-webkit-scrollbar-thumb {
 background-color: #d6dee1;
 border-radius: 20px;
 border: 6px solid transparent;
 background-clip: content-box;
 }

 ::-webkit-scrollbar-thumb:hover {
 background-color: #a8bbbf;
 }
}

选中文本样式美化

默认选中文本的样式是蓝底白字的，与博客风格显得比较突兀，所以也可以改一下。

assets/scss/custom.scss 添加以下内容：

1
2
3
4


::selection {
 color: #ffff;
 background: #557697;
}

主页右侧动画

搜索菜单动画

1
2
3
4
5
6
7


.search-form.widget {
 transition: transform 0.6s ease;
}

.search-form.widget:hover {
 transform: scale(1.1, 1.1);
}

归档动画

1
2
3
4
5
6
7


.widget.archives .widget-archive--list {
 transition: transform .3s ease;
}

.widget.archives .widget-archive--list:hover {
 transform: scale(1.05, 1.05);
}

标签动画

1
2
3
4
5
6
7
8
9


.tagCloud .tagCloud-tags a {
 border-radius: 10px;
 font-size: 1.4rem;
 transition: transform .3s ease;
}

.tagCloud .tagCloud-tags a:hover {
 transform: scale(1.1, 1.1);
}

归档页面双栏

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


@media (min-width: 1024px) {
 .article-list--compact {
 display: grid;
 grid-template-columns: 1fr 1fr;
 background: none;
 box-shadow: none;
 gap: 1rem;

 article {
 background: var(--card-background);
 border: none;
 box-shadow: var(--shadow-l2);
 margin-bottom: 8px;
 border-radius: 16px;
 }
 }
}

增加赞赏

添加赞赏二维码，比如微信、支付宝的二维码。

添加页面

对应目录新建 layouts\partials\reward.html 文件。

写入以下代码：

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


<div class="post-reward" data-html2canvas-ignore>
 <input type="checkbox" name="reward" id="reward" hidden />
 <label class="reward-button" for="reward">赞赏支持</label>
 <div class="qr-code">
 {{ if .Site.Params.Reward.wechat }}
 <label class="qr-code-image" for="reward">
 <img class="image" src="{{ .Site.Params.Reward.wechat }}">
 <span>微信打赏</span>
 </label>
 {{ end }}
 {{ if .Site.Params.Reward.alipay }}
 <label class="qr-code-image" for="reward">
 <img class="image" src="{{ .Site.Params.Reward.alipay }}">
 <span>支付宝打赏</span>
 </label>
 {{ end }}
 {{ if .Site.Params.Reward.paypal }}
 <label class="qr-code-image" for="reward">
 <img class="image" src="{{ .Site.Params.Reward.paypal }}">
 <span>PayPal打赏</span>
 </label>
 {{ end }}
 </div>
</div>

文章对应位置引入页面，一般在single.html中。

1
2
3


{{ if .Site.Params.Reward.enable }}
 {{ partial "reward.html" . }}
{{ end }}

添加样式

custom.css中添加样式：

 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


/* 打赏 */
.post-reward {
 margin-top: 20px;
 padding-top: 10px;
 text-align: center;
 border-top: 1px dashed #e6e6e6
}

.post-reward .reward-button {
 margin: 15px 0;
 padding: 3px 7px;
 display: inline-block;
 color: #c05b4d;
 border: 1px solid #c05b4d;
 border-radius: 5px;
 cursor: pointer
}

.post-reward .reward-button:hover {
 color: #fefefe;
 background-color: #c05b4d;
 transition: .5s
}

.post-reward #reward:checked~.qr-code {
 display: block
}

.post-reward #reward:checked~.reward-button {
 display: none
}

.post-reward .qr-code {
 display: none
}

.post-reward .qr-code .qr-code-image {
 display: inline-block;
 min-width: 200px;
 width: 40%;
 margin-top: 15px
}

.post-reward .qr-code .qr-code-image span {
 display: inline-block;
 width: 100%;
 margin: 8px 0
}

.post-reward .qr-code .image {
 width: 200px;
 height: 200px;
 background-color: transparent;
}

增加配置

config.toml中加入：

1
2
3
4
5


[params.reward]
 enable = true # 是否启用
 wechat = "xxxx.png" # 微信
 alipay = "" # 支付宝
 paypal = "" # paypal

为空不会显示。

总结

以上美化效果参考了不少大佬的文章。

目前的美化效果就暂时这样，后续再继续更新。

https://xrg.fj.cn/p/hugo-stack%E4%B8%BB%E9%A2%98%E6%9B%B4%E6%96%B0%E5%B0%8F%E8%AE%B0

使用 Hugo 对博客的重建与 Stack 主题优化记录 (oxidane-uni.github.io)

（3）Stack主题的自定义 (linsnow.cn)

Hugo-theme-Stack 魔改美化 | Naive Koala (xalaok.top)

『Hugo』Hugo Styles (echosec.top)

Hugo 创建基于目录的archetypes模板

Sun, 03 Dec 2023 18:03:37 +0800

创建基于目录的 archetypes 模板

在 Hugo 中可以使用完整的目录作为原型模板。

前言

如果不想将文章的图片杂乱地放在文章的同级目录下，可以创建一个 images 文件夹，将图片统一放在里面。但是每次都要手动创建，未免太麻烦，这时就可以通过 archetypes 设置一个基于目录的模板来简化这个操作。

本篇基于 Stack 主题。

创建目录结构

在 archetypes 目录下创建一个 default_structure 文件夹，文件名随意，目录结构如下：

1
2
3
4
5
6


archetypes
├── default.md
└── default_structure
 ├── images
 │ └── default.png
 └── index.md

default_structure 目录里的 index.md 也可以加上模板内容，比如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


---
title: "{{ replace .Name "-" " " | title }}"
description:
date: {{ .Date }}
image: images/default.png
hidden: false
comments: true
categories:["C++"]
tags:["C++"]
lastmod: {{ .Date }}
---

新建文章

模板创建好之后，就可以新建一篇文章看看效果了，使用命令：

1

hugo new --kind default_structure post/demo

该命令将创建一个新的文件夹 /content/posts/demo，并且它包含与 default_structure 原型文件夹中相同的文件夹结构。

注意：这里的 --kind 之后的参数需要与前面创建的目录结构的文件夹名相同，即 default_structure 目录名

此时就创建好文章了，可以看到 demo 目录的结构是符合预期的。

1
2
3
4
5


post
└── demo
 ├── images
 │ └── default.png
 └── index.md

同时，demo/index.md 的模板内容也成功添加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


---
title: "Demo"
description:
date: 2023-11-28T21:29:54+08:00
image: images/default.png
hidden: false
comments: true
categories: ["C++"]
tags: ["C++"]
lastmod: 2023-11-28T21:29:54+08:00
---

总结

通过合理设置 archetypes 原型模板，可以使得我们创建符合自身需求的文章目录结构。

当然，如果不喜欢 images 图片文件夹放在文章同级目录下，也可以考虑在 static 目录下创建 images 文件夹，这样在 md 文件中引用的时候也可以显示出来（如 ![](images/one.jpg)）。

Hugo Stack开启多语言模式

Sat, 02 Dec 2023 11:31:54 +0800

前言

Hugo Stack 主题默认没有开启语言模式，网页上没有语言转换的按钮，所以这篇文章介绍如何开启 Stack 主题的多语言模式。

另外，我使用的是 hugo-theme-stack-starter 直接构建的。

开启多语言模式

先看一下目录结构：

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


├─archetypes
├─assets
│ ├─icons
│ ├─img
│ └─scss
├─config
│ └─_default
├─content
│ ├─categories
│ ├─page
│ └─post
├─layouts
├─resources
└─static

这里主要是修改 config/_default 路径下的文件，正常来说会有 config/_default/_languages.toml 配置文件，这里修改为：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# Rename this file to languages.toml to enable multilingual support
[zh-cn]
languageName = "简体中文"
title = "博客站点"
weight = 1
[en]
languageName = "English"
languagedirection = "ltr"
title = "Blog site"
weight = 2

这里在默认的参数下添加了中文，由于我设置的默认语言为中文，所以中文的 weight 权重也是设置为 1。

然后，刷新页面，你会发现怎么还是没生效呢？

这算一个小坑，需要将 _languages.toml 重命名为 languages.toml 才能生效。

最终效果

会在夜间模式切换按钮之上添加一个语言切换按钮

然后，页面上也会有对应的语言切换按钮

至此，关于 Hugo Stack 主题的多语言模式就开启成功了。

关于

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

关于我

一名 90 后，C++ 开发工程师。一个摆脱群体意识的人。

喜欢学习新技术，喜欢学习新知识，喜欢学习新工具。

热衷于探索，探索人生、探索世界。

性格特征

性格类型: 主人公 (ENFJ-A)

主人公觉得被召唤为生活中更大的目标服务。这些人格类型深思熟虑，理想化，努力对其他人和他们周围的世界产生积极的影响。他们很少回避做正确事情的机会，即使这样做远非易事。

个性特征:

外向型 – 56%
直觉型 – 74%
感受型 – 55%
计划型 – 59%
坚决 – 54%

关于技能

擅长 C++、Python
Windows、Linux、macOS
不擅长 Outdated Technology
私以为，知识广度可达 80%。

工具

贡献过的项目

关于兴趣

热爱摄影（迫于现实搁置进阶）
热爱运动（羽毛球、滑雪、攀岩等，但都很菜🤣）
热爱学习（计算机类、经营管理类、心理学，其他领域的也想学习，奈何精力有限无暇顾及 (´。＿。｀) ）

关于未来

在这一条沙漠路上，必然是艰辛的，漫长的，迷茫的，要耐得住寂寞，坚定信念，日夜兼程，方可寻得绿洲。

路漫漫其修远兮

归档

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

搜索

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

友链

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

友链申请

如果您想申请友链，请在评论区留言。友链倾向于技术开发领域的博主，也欢迎其他类型的高质量博主。

评论区格式：

网站名称：（必填）
网站介绍：（选填）
网站地址：（必填）
logo地址：（必填）

格式示例：

网站名称：李慕然的一天

网站介绍：衣带渐宽终不悔，为伊消得人憔悴

网站地址：limuran.top

logo地址：limuran.top/favicon.ico

李慕然的一天

C++ 20 jthread 使用与底层设计实现

std::jthread 的核心特性

示例

底层原理

架构图解

std::jthread 内部实现逻辑

stop_source

stop_token

stop_state

总结

C++20 指定初始化器：现代结构体初始化

基本概念

重要规则

示例

与 C99 的比较

C++20 三路比较运算符（宇宙飞船运算符）使用指南

基本概念

返回类型

动机

基本用法

总结

浏览器301重定向响应流程分析

分析

理论分析

TCP 协议层的分析

调试分析

总结

U盘打不开提示格式化如何恢复

背景

问题解决

排除电脑问题

恢复优盘

预防措施：避免再次发生

良好使用习惯

C++ vector 翻倍扩容策略是错误的认知

Visual Studio 远程调试

简介

准备远程调试

部署调试版本程序

配置远程调试

方法一

方法二

LeetCode 75系列 - 1448. 统计二叉树中好节点的数目

题目描述

题解

LeetCode 75系列 - 872. 叶子相似的树

题目描述

题解

Qt 不同容器探究

前言

Qt 5 版本

QQueue

QStack

QSet

Qt 6 版本

QVector

QList

QStack

总结

LeetCode 75系列 - 104. 二叉树的最大深度

题目描述

题解

LeetCode 75系列 - 2130. 链表最大孪生和

题目描述

题解

解法一

解法二

LeetCode 75系列 - 206. 反转链表

题目描述

题解

LeetCode 75系列 - 328. 奇偶链表

题目描述

题解

解法一

解法二

LeetCode 75系列 - 2095. 删除链表的中间节点

题目描述

题解

C++ IO 缓冲区

`std::jthread` 的核心特性

`std::jthread` 内部实现逻辑

`std::async` 基础用法

`std::async` 策略深入分析