南京大学 CPP 2025Fall 第五次机试 题解和思路分享

原创 于 2025-12-25 12:19:35 发布 · 523 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #算法 #开发语言

题目1：集合操作（MySet）

题目描述

实现一个简化的整数集合类MySet，该类持有一个unordered_set来存储元素，为了更方便地进行集合运算，要求通过操作符重载提供直观的集合运算接口。

具体要求

1. 操作符重载

（1）交集
  • 交（*）：A * B 返回集合A与集合B的交集
  • 交赋值（*=）：A *= B 即 A = A * B
（2）并集与差集
  • 并（+）：A + B 返回集合A与集合B的并集
  • 并赋值（+=）：A += B 即 A = A + B
  • 差（-）：A - B 返回集合A与集合B的差集
  • 差赋值（-=）：A -= B 即 A = A - B
  • 操作数类型支持MySet或int（表示单个整数构成的集合），示例：
    • A + 1 或 1 + A → 集合A与{1}的并集
    • A - 1 → 集合A与{1}的差集
    • 1 - A → 集合{1}与A的差集（结果为{1}或{}）

2. 类型转换

  • bool()：空集合返回false，非空集合返回true
  • int()：返回集合的元素个数
  • std::vector<int>()：转换为向量，元素按升序排列

3. 输出流重载

  • 友元函数：friend std::ostream& operator<<(std::ostream& os, const MySet& s)
  • 输出格式：{a0, a1, a2, ...}（元素按升序排列）

调用示例

#include "MySet.h"
int main() {
    MySet A = {1, 2, 3, 4};
    MySet B = {4, 5, 6, 7, 8};
    std::cout << (A + 5) * B << std::endl;
    B -= 8;
    std::cout << A + (8 - B) << std::endl;
    if (A * B) {
        std::cout << "A size: " << static_cast<int>(A) << std::endl;
        std::vector<int> a = static_cast<std::vector<int>>(A);
        for (int i : a) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    }
}

输出结果

{4, 5}
{1, 2, 3, 4, 8}
A size: 4
1 2 3 4

提示

  • 部分操作符可复用已实现的操作符简化代码
  • 并集操作参考声明（其他操作可仿照）：
MySet operator+(const MySet& other) const;
MySet operator+(int value) const;
friend MySet operator+(int value, const MySet& set);
MySet& operator+=(const MySet& other);
MySet& operator+=(int value);
  • 需创建MySet.h文件实现操作符重载，Main.cpp输入随意内容即可

代码模板（MySet.h）

#include <algorithm>
#include <iostream>
#include <unordered_set>
#include <vector>

class MySet {
private:
    std::unordered_set<int> data;
public:
    MySet() = default;
    MySet(std::initializer_list<int> init) : data(init) {}

    // ========== 基础方法 ==========
    size_t size() const {
        return data.size();
    }

    bool empty() const {
        return data.empty();
    }

    bool contains(int value) const {
        return data.find(value) != data.end();
    }

    void add(int value) {
        data.insert(value);
    }

    void remove(int value) {
        data.erase(value);
    }

    void clear() {
        data.clear();
    }

    // ========== 操作符重载（待实现） ==========
    // 交集
    MySet operator*(const MySet& other) const;
    MySet& operator*=(const MySet& other);

    // 并集
    MySet operator+(const MySet& other) const;
    MySet operator+(int value) const;
    friend MySet operator+(int value, const MySet& set);
    MySet& operator+=(const MySet& other);
    MySet& operator+=(int value);

    // 差集
    MySet operator-(const MySet& other) const;
    MySet operator-(int value) const;
    friend MySet operator-(int value, const MySet& set);
    MySet& operator-=(const MySet& other);
    MySet& operator-=(int value);

    // 类型转换
    operator bool() const {
        return !empty();
    }

    operator int() const {
        return static_cast<int>(size());
    }

    operator std::vector<int>() const {
        std::vector<int> vec(data.begin(), data.end());
        std::sort(vec.begin(), vec.end());
        return vec;
    }

    // 输出流重载（友元）
    friend std::ostream& operator<<(std::ostream& os, const MySet& s);
};

// ========== 操作符实现（待补充） ==========
MySet MySet::operator*(const MySet& other) const {
    MySet res;
    for (int val : data) {
        if (other.contains(val)) {
            res.add(val);
        }
    }
    return res;
}

MySet& MySet::operator*=(const MySet& other) {
    *this = *this * other;
    return *this;
}

MySet MySet::operator+(const MySet& other) const {
    MySet res;
    for (int val : data) res.add(val);
    for (int val : other.data) res.add(val);
    return res;
}

MySet MySet::operator+(int value) const {
    MySet res = *this;
    res.add(value);
    return res;
}

MySet operator+(int value, const MySet& set) {
    return set + value;
}

MySet& MySet::operator+=(const MySet& other) {
    *this = *this + other;
    return *this;
}

MySet& MySet::operator+=(int value) {
    *this = *this + value;
    return *this;
}

MySet MySet::operator-(const MySet& other) const {
    MySet res;
    for (int val : data) {
        if (!other.contains(val)) {
            res.add(val);
        }
    }
    return res;
}

MySet MySet::operator-(int value) const {
    MySet res = *this;
    res.remove(value);
    return res;
}

MySet operator-(int value, const MySet& set) {
    MySet res;
    if (!set.contains(value)) {
        res.add(value);
    }
    return res;
}

MySet& MySet::operator-=(const MySet& other) {
    *this = *this - other;
    return *this;
}

MySet& MySet::operator-=(int value) {
    *this = *this - value;
    return *this;
}

std::ostream& operator<<(std::ostream& os, const MySet& s) {
    std::vector<int> vec = static_cast<std::vector<int>>(s);
    os << "{";
    for (size_t i = 0; i < vec.size(); ++i) {
        if (i > 0) os << ", ";
        os << vec[i];
    }
    os << "}";
    return os;
}

题目2：通用环形缓冲区（RingBuffer）

题目描述

实现一个名为RingBuffer的C++类模板，代表固定大小的环形缓冲区（Circular Buffer）。环形缓冲区是高效的数据结构，用于在固定大小的存储空间中管理数据流。与普通队列不同，当缓冲区满时，新数据将自动覆盖最早的数据（First-In, Overwrite-Oldest）。

支持任意类型T的元素存储，需正确管理内部内存。

核心概念：环形覆盖

假设缓冲区容量为3：

  1. push(1) → buffer: [1, _, _]
  2. push(2) → buffer: [1, 2, _]
  3. push(3) → buffer: [1, 2, 3]（满）
  4. push(4) → buffer: [4, 2, 3]（1被4覆盖，最早元素变为2）

功能要求

实现以下成员函数：

  1. RingBuffer(size_t capacity)：构造函数，分配存储capacity个T类型元素的空间
  2. ~RingBuffer()：析构函数，释放所有动态分配的内存
  3. void push(const T& value)：添加元素
    • 缓冲区未满：添加到队尾
    • 缓冲区已满：覆盖队头元素，更新队头和队尾位置
  1. void pop()：移除队头元素（空缓冲区不执行操作）
  2. T& front()：返回队头元素（最早加入）的引用
  3. T& back()：返回队尾元素（最近加入）的引用
  4. size_t getSize() const：返回当前元素数量
  5. size_t getCapacity() const：返回总容量
  6. bool isFull() const：检查是否已满
  7. bool isEmpty() const：检查是否为空
  8. void print() const：按从旧到新顺序打印所有元素（空格分隔，末尾换行）

输入格式

每行一条操作指令，格式如下：

  • create <capacity>：创建容量为capacity的RingBuffer<int>对象
  • push <value>：添加一个整数
  • pop：移除最早元素
  • front：打印队头元素
  • back：打印队尾元素
  • print：按顺序打印所有元素（队头到队尾）
  • info：打印当前大小（Size）和容量（Capacity）

数据范围

  • 缓冲区容量capacity：0 <= capacity
  • 元素value：int范围内

输出格式

  • front/back指令：输出对应数值；空缓冲区输出Empty
  • print指令：一行输出所有元素（空格分隔）；空缓冲区输出Empty
  • info指令：输出Size: <size>, Capacity: <capacity>

样例输入

create 3
push 10
push 20
info
push 30
info
print
push 40
info
print
front
back
pop
print

样例输出

Size: 2, Capacity: 3
Size: 3, Capacity: 3
10 20 30
Size: 3, Capacity: 3
20 30 40
20
40
30 40

样例解释

  1. create 3：创建容量为3的缓冲区
  2. push 10、push 20：缓冲区为[10, 20]，大小2
  3. push 30：缓冲区为[10, 20, 30]，已满
  4. push 40：覆盖最早的10，逻辑缓冲区变为[20, 30, 40]
  5. pop：移除最早的20，缓冲区变为[30, 40]

代码模板

#include <iostream>
#include <vector>
#include <string>

template <typename T>
class RingBuffer {
private:
    std::vector<T> data;    // 底层存储
    size_t head;            // 队头索引（最早元素）
    size_t tail;            // 队尾索引（下一个插入位置）
    size_t capacity;        // 总容量
    size_t currentSize;     // 当前元素数量

public:
    // 构造函数
    RingBuffer(size_t cap) : capacity(cap), head(0), tail(0), currentSize(0) {
        if (cap > 0) {
            data.resize(cap);
        }
    }

    // 析构函数
    ~RingBuffer() {
        // vector自动管理内存，无需额外释放
    }

    // 添加元素（如果满则覆盖）
    void push(const T& value) {
        if (capacity == 0) {
            return;
        }
        if (isFull()) {
            // 覆盖队头，更新head
            data[tail] = value;
            head = (head + 1) % capacity;
        } else {
            // 插入队尾，增加大小
            data[tail] = value;
            currentSize++;
        }
        // 更新tail（循环索引）
        tail = (tail + 1) % capacity;
    }

    // 移除队头元素
    void pop() {
        if (isEmpty()) {
            return;
        }
        head = (head + 1) % capacity;
        currentSize--;
    }

    // 获取队头引用
    T& front() {
        static T dummy;
        return isEmpty() ? dummy : data[head];
    }

    // 获取队尾引用
    T& back() {
        static T dummy;
        if (isEmpty()) {
            return dummy;
        }
        // tail指向 next 插入位置，实际队尾是 tail-1（处理环绕）
        size_t backIdx = (tail == 0) ? capacity - 1 : tail - 1;
        return data[backIdx];
    }

    // 获取当前大小
    size_t getSize() const {
        return currentSize;
    }

    // 获取容量
    size_t getCapacity() const {
        return capacity;
    }

    // 检查是否已满
    bool isFull() const {
        return currentSize == capacity;
    }

    // 检查是否为空
    bool isEmpty() const {
        return currentSize == 0;
    }

    // 按从旧到新顺序打印元素
    void print() const {
        if (isEmpty()) {
            std::cout << "Empty" << std::endl;
            return;
        }
        size_t idx = head;
        for (size_t i = 0; i < currentSize; ++i) {
            if (i > 0) {
                std::cout << " ";
            }
            std::cout << data[idx];
            idx = (idx + 1) % capacity;
        }
        std::cout << std::endl;
    }
};

int main() {
    std::string command;
    int capacity;
    RingBuffer<int>* buffer = nullptr;

    while (std::cin >> command) {
        if (command == "create") {
            std::cin >> capacity;
            if (buffer) {
                delete buffer;
            }
            buffer = new RingBuffer<int>(capacity);
        } else if (command == "push") {
            int value;
            std::cin >> value;
            if (buffer) {
                buffer->push(value);
            }
        } else if (command == "pop") {
            if (buffer) {
                buffer->pop();
            }
        } else if (command == "front") {
            if (buffer) {
                if (buffer->isEmpty()) {
                    std::cout << "Empty" << std::endl;
                } else {
                    std::cout << buffer->front() << std::endl;
                }
            }
        } else if (command == "back") {
            if (buffer) {
                if (buffer->isEmpty()) {
                    std::cout << "Empty" << std::endl;
                } else {
                    std::cout << buffer->back() << std::endl;
                }
            }
        } else if (command == "print") {
            if (buffer) {
                buffer->print();
            }
        } else if (command == "info") {
            if (buffer) {
                std::cout << "Size: " << buffer->getSize()
                          << ", Capacity: " << buffer->getCapacity() << std::endl;
            }
        }
    }

    if (buffer) {
        delete buffer;
    }
    return 0;
}

解题思路与参考实现

题目1：RingBuffer

思路梳理

  • 底层存储使用定长数组 T* data（容量为 capacity）。
  • 维护三个指标：head 指向队头（最旧元素），tail 指向下一次写入位置，count 为当前元素个数。
  • push：写入 data[tail]，若已满则先移动 head 覆盖最旧元素，否则递增 count，最后 tail = (tail + 1) % capacity。
  • pop：空则无操作；否则 head = (head + 1) % capacity 并 count--。
  • front/back：front 取 data[head]；back 取 (tail + capacity - 1) % capacity。
  • 判空判满：count == 0 / count == capacity；容量为 0 时所有操作直接返回以防越界。

参考代码

#include <iostream>
#include <vector>
#include <string>
#include <bits/stdc++.h>

// TODO: 将 RingBuffer 定义为模板类 template <typename T>
template <typename T>
class RingBuffer {
private:
    // TODO: 添加私有成员变量
    T* data;
    size_t capacity;
    size_t head;
    size_t tail;
    size_t count;
    // 建议使用 T* data 或 std::vector<T> 作为底层存储
    // 需要记录 head (队头), tail (队尾) 或 count (当前数量)

public:
    // 构造函数
    RingBuffer(size_t cap) : capacity(cap),head(0),tail(0),count(0){
        // TODO
        if (capacity>0) {
            data = new T[capacity];
        }else {
            data = nullptr;
        }
    }

    // 析构函数
    ~RingBuffer() {
        // TODO
        delete[] data;
        data = nullptr;
    }

    // 添加元素 (如果满则覆盖)
    void push(const T& value) {
        // TODO
        if (capacity == 0) {
            return;
        }

        data[tail] = value;

        if (isFull()) {
            head = (head + 1) % capacity;
        } else {
            count++;
        }

        tail = (tail + 1) % capacity;
    }

    // 移除元素
    void pop() {
        // TODO
        if (isEmpty()) {
            return;
        }

        head = (head + 1) % capacity;
        count--;
    }

    // 获取队头引用
    T& front() {
        // TODO
        // 注意：实际项目中应处理空的情况，这里为了简单可假设调用前非空或返回默认值
        return data[head];
    }

    // 获取队尾引用
    T& back() {
        // TODO
        size_t tailReturn = (tail - 1 + capacity) % capacity;
        return data[tailReturn];
    }

    size_t getSize() const {
        // TODO
        return count;
    }

    size_t getCapacity() const {
        // TODO
        return capacity;
    }

    bool isFull() const {
        // TODO
        if (count == capacity) {
            return true;
        }else {
            return false;
        }
    }

    bool isEmpty() const {
        // TODO
        if (count == 0) {
            return true;
        }else {
            return false;
        }
    }

    // 打印当前缓冲区的所有元素（从旧到新）
    void print() const {
        // TODO
        if (isEmpty()) {
            std::cout << "Empty" << std::endl;
            return;
        }

        for (size_t i = 0; i < count; ++i) {
            size_t idx = (head + i) % capacity;
            if (i > 0) {
                std::cout << " ";
            }
            std::cout << data[idx];
        }
        std::cout << std::endl;
    }
};

int main() {
    std::string command;
    int capacity;
    RingBuffer<int>* buffer = nullptr;

    while (std::cin >> command) {
        if (command == "create") {
            std::cin >> capacity;
            if (buffer) delete buffer;
            buffer = new RingBuffer<int>(capacity);
        } else if (command == "push") {
            int value;
            std::cin >> value;
            if (buffer) buffer->push(value);
        } else if (command == "pop") {
            if (buffer) buffer->pop();
        } else if (command == "front") {
            if (buffer) {
                if (buffer->isEmpty()) std::cout << "Empty" << std::endl;
                else std::cout << buffer->front() << std::endl;
            }
        } else if (command == "back") {
            if (buffer) {
                if (buffer->isEmpty()) std::cout << "Empty" << std::endl;
                else std::cout << buffer->back() << std::endl;
            }
        } else if (command == "print") {
            if (buffer) {
                if (buffer->isEmpty()) {
                    std::cout << "Empty" << std::endl;
                } else {
                    buffer->print();
                }
            }
        } else if (command == "info") {
            if (buffer) {
                std::cout << "Size: " << buffer->getSize()
                          << ", Capacity: " << buffer->getCapacity() << std::endl;
            }
        }
    }

    if (buffer) delete buffer;
    return 0;
}

代码解析

  • 覆盖策略：push 时若满先前移 head，保证最旧元素被替换；tail 永远指向下一写位置。
  • 取尾元素：(tail + capacity - 1) % capacity 处理循环减一。
  • 安全性：容量为 0 时直接返回，避免除零或越界；析构释放底层数组。

题目2：MySet

思路梳理

  • 内部使用 unordered_set<int> 存储；通过基础操作 add/contains/remove 复用逻辑。
  • 交并差：二元运算返回新集合，赋值运算在当前集合原地更新（可用临时容器后 swap）。
  • 与 int 的混合运算：将单个整数视为 {value}，提供对称友元实现前置写法（如 1 + A）。
  • 类型转换与输出：转换向量后排序，输出 {a0, a1, ...} 升序保证稳定展示。

参考代码

#include <algorithm>
#include <iostream>
#include <unordered_set>
#include <vector>

using namespace std;

class MySet {
 private:
  unordered_set<int> data;

 public:
  MySet() = default;

  MySet(const initializer_list<int> init) : data(init) {}

  // ========== 基础方法 ==========
  size_t size() const {
    return data.size();
  }

  bool empty() const {
    return data.empty();
  }

  bool contains(const int value) const {
    return data.find(value) != data.end();
  }

  void add(const int value) {
    data.insert(value);
  }

  void remove(const int value) {
    data.erase(value);
  }

  void clear() {
    data.clear();
  }

  //交集
  MySet operator*(const MySet& other) const;
  MySet& operator*=(const MySet& other);

  //并集
  MySet operator+(const MySet& other) const;
  MySet operator+(int value) const;
  friend MySet operator+(int value, const MySet& set);
  MySet& operator+=(const MySet& other);
  MySet& operator+=(int value);

  //差集
  MySet operator-(const MySet& other) const;
  MySet operator-(int value) const;
  friend MySet operator-(int value, const MySet& set);
  MySet& operator-=(const MySet& other);
  MySet& operator-=(int value);

  //类型转换
  explicit operator bool() const;
  explicit operator int() const;
  explicit operator std::vector<int>() const;

  //输出流重载
  friend ostream& operator<<(ostream& os, const MySet& s);
};

//交集实现
inline MySet MySet::operator*(const MySet& other) const {
  MySet result;
  for (const int elem : data) {
    if (other.contains(elem)) {
      result.add(elem);
    }
  }
  return result;
}

inline MySet& MySet::operator*=(const MySet& other) {
  unordered_set<int> new_data;
  for (int elem : data) {
    if (other.contains(elem)) {
      new_data.insert(elem);
    }
  }
  data.swap(new_data);
  return *this;
}

//并集实现
inline MySet MySet::operator+(const MySet& other) const {
  MySet result = *this;
  for (const int elem : other.data) {
    result.add(elem);
  }
  return result;
}

inline MySet MySet::operator+(const int value) const {
  MySet result = *this;
  result.add(value);
  return result;
}

inline MySet operator+(const int value, const MySet& set) {
  return set + value;
}

inline MySet& MySet::operator+=(const MySet& other) {
  for (const int elem : other.data) {
    this->add(elem);
  }
  return *this;
}

inline MySet& MySet::operator+=(const int value) {
  this->add(value);
  return *this;
}

//差集实现
inline MySet MySet::operator-(const MySet& other) const {
  MySet result;
  for (const int elem : data) {
    if (!other.contains(elem)) {
      result.add(elem);
    }
  }
  return result;
}

inline MySet MySet::operator-(const int value) const {
  MySet result = *this;
  result.remove(value);
  return result;
}

inline MySet operator-(const int value, const MySet& set) {
  MySet result;
  if (!set.contains(value)) {
    result.add(value);
  }
  return result;
}

inline MySet& MySet::operator-=(const MySet& other) {
  unordered_set<int> new_data;
  for (int elem : data) {
    if (!other.contains(elem)) {
      new_data.insert(elem);
    }
  }
  data.swap(new_data);
  return *this;
}

inline MySet& MySet::operator-=(const int value) {
  this->remove(value);
  return *this;
}

//类型转换
inline MySet::operator bool() const {
  return !this->empty();
}

inline MySet::operator int() const {
  return static_cast<int>(this->size());
}

inline MySet::operator vector<int>() const {
  vector vec(this->data.begin(), this->data.end());
  sort(vec.begin(), vec.end());
  return vec;
}

//输出流
inline ostream& operator<<(ostream& os, const MySet& s) {
  const auto vec = static_cast<vector<int>>(s);
  os << "{";
  for (size_t i = 0; i < vec.size(); ++i) {
    if (i > 0) {
      os << ", ";
    }
    os << vec[i];
  }
  os << "}";
  return os;
}

代码解析

  • 重载对称性：int + MySet、int - MySet 通过友元实现，确保单元素集合场景语义明确。
  • 赋值类操作：使用临时 unordered_set 后 swap，避免边遍历边修改导致逻辑混乱。
  • 输出与向量转换：统一排序后输出，保证展示顺序稳定、可读。
【华为OD机试真题 2025B卷】253、响应报文时间 | 机试真题+思路参考+代码分析（C++、Java、Py、C语言、JS）
KJ.JK
06-05 1万+
题目描述 >IGMP协议中，有一个字段称作最大响应时间(Max Response Time)，HOST收到查询报文，解析出MaxResponse Time字段后，需要在(0~MaxResponseTime)s )时间内选取随机时间回应一个响应报文，如果在随机时间内收到一个新的查询报文，则会根据两者时间的大小，选取小的一方刷新回应时间 >  最大响应时间有如下计算方式： 当MaxRespCode < 128 ，MaxRespTime = MaxRespCode 当MaxRespCode = 128
华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|2025C卷B卷
热门推荐
u014481728的博客
01-26 8万+
华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|华为OD机试|华为od题库|华为od机考|2025真题目录Python实现|B卷C卷
2025-6-12游戏题解
06-12
2025_6_12游戏题解
2025美赛｜数学建模ABCDEF题解+源代码
Talk is cheap, show me the code!
01-15 6207
1.24准时更新
【华为OD机试真题 2025B卷】699、采样过滤 | 机试真题+思路参考+代码解析（C++、Java、Py）（B卷复用）
KJ.JK
05-25 1657
【华为OD机试真题 2025B卷】699、采样过滤 | 机试真题+思路参考+代码解析（C++、Java、Py）（B卷复用） 华为od机试，华为od机试真题，华为od机试E卷，华为odE卷，华为od机试真题E卷，华为OD，华为OD机试，华为OD机试真题，华为od机考，华为od机试D卷，华为od机试真题D卷，华为od手撕代码，华为od，华为od机试C卷，华为od e卷，华为2025e卷，od机试，2025E卷，华为OD机试E卷，什么是华为od，华为od介绍，全面了解华为od，2025华为od，如何备战华为od
面试记录12 软件（c++）工程师
weixin_44389243的博客
12-23 219
科莱瑞迪
LeetCode 面试经典 150_回溯_全排列（100_46_C++_中等）
huayimenghan的博客
12-19 957
LeetCode 面试经典 150_回溯_全排列（100_46_C++_中等） 题目描述： 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
C++ 类与对象：解锁面向对象编程的核心密码（中）
emtai486的博客
12-20 1053
默认成员函数：构造，析构，拷贝构造，赋值重载，取地址重载
Linux C/C++ 学习日记（57）：定时器
2302_79943247的博客
12-21 593
本文介绍了定时器的实现原理与代码示例。定时器是管理大量延时任务的模块，通过高效的数据结构（如红黑树、最小堆）组织任务，并使用IO多路复用（如epoll_wait）触发机制。文中采用红黑树存储定时任务，利用steady_clock确保时间单调性，通过emplace_hint优化插入效率。代码实现了添加/删除定时任务、检测触发和执行回调等功能，最终演示了结合epoll处理定时任务的完整流程。该方案兼顾了IO事件和定时任务处理，避免了sleep等低效方法。
c++ string 容器
leiming6的博客
12-21 445
string s1;i++)int main()test02();test01();test03();test04();test05();test06();test07();test08();
C++ 标准提供的 thread (线程)之 detach() 函数示例(windows平台)
ComputerInBook的专栏
12-24 108
c++线程之 detach() 函数
Google C++ 编码规范核心要点总结 (2025精简版)
猫哥 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS，AIOT)
12-19 1174
本文总结了Google C++编码规范的核心要点，旨在提升代码可读性与一致性。主要包含五大维度：1)头文件与作用域管理，强调自给自足和命名空间使用；2)类设计原则，注重简单明确，推荐组合优先；3)现代C++特性的谨慎使用；4)严格的命名约定，区分不同类型标识符；5)核心编程原则，包括参数传递、类型转换和注释规范。文章强调"显式优于隐式"等核心口诀，并推荐使用cpplint工具进行自动化检测。这些规范适用于需要编写清晰、统一且易于维护的C++代码的开发者。
C++ 线程 （3）
Starry_tsx的博客
12-18 437
作用：阻塞线程，直到被唤醒（或谓词满足）。参数：lock：std::unique_lock<std::mutex> 的引用（调用时需已持有锁）；pred：可调用对象（函数 /lambda 等），返回bool（表示等待的条件）。返回值：无（void）。
windows线程切换之一个线程的Quantum: -93都是在处理KDPC
linux-0.11调试教程
12-19 640
windows线程切换之一个线程的Quantum: -93都是在处理KDPC----线程切换和KDPC没有关系
c++经典练习题-分支练习（2）
lybr的博客
12-19 616
游乐场引进了一个新的游乐设施，可以两人一组开动该设施，但设施设计上有一个缺陷，必须一个人的体重在 60 公斤以上（包含 60 公斤），另一个人体重在 60 公斤以下，才能启动该设施。请你编程从键盘读入两个游客的体重，判断一下设施能否启动，如果能启动输出green，不能启动输出red。比如输入：65.2 28.5，就可以启动设施，输出green。再比如输入：28.5 56.7，就不能启动设施，输出red。两个小数，代表两位游客的体重。如果能启动输出green，不能启动输出red。65.2 28.5。
幽冥大陆(五十五)ASR SetThreadInformation C语言识别到自动化软件
cybersnow精通 28 门计算机语言，凭借其超凡的技术能力，成功开发过上万个应用，广泛涉及政府、商业、个人等众多领域，甚至在检察院、环保局、公安局等专业场景中也大放异彩。不仅熟练掌握单片机和物联网开发，在软件架构设计方面更是独树一帜，自创了跨平台软件
12-20 408
让我们积极投身于技术共享的浪潮中，不仅仅是作为受益者，更要成为贡献者。无论是分享自己的代码、撰写技术博客，还是参与开源项目的维护和改进，每一个小小的举动都可能成为推动技术进步的巨大力量。
C++从0到1撸了个生产级零拷贝缓存：用MAP_POPULATE和大页把文件读取性能进行提升
weixin_45715405的博客
12-20 86
本文探讨了现代高性能计算中的零拷贝技术，重点介绍了共享内存、内存映射和零拷贝传输三大核心技术。项目实现了一个生产级零拷贝缓存系统，通过智能选择存储策略、预分配内存池、多进程共享等优化手段，显著降低了数据拷贝开销。系统采用分片锁、缓存行对齐、大页支持等关键技术，实现了低延迟、高吞吐的数据传输。核心组件SharedMemoryArena通过一次性分配大块共享内存池，避免了频繁系统调用，将小对象分配开销降至纳秒级。该项目不仅提供了高效的零拷贝解决方案，还为理解操作系统级优化、内存管理和并发编程等核心知识提供了实践
关于C++中的typedef typename的含义
阿达King哥的博客
12-23 85
本文解释了C++中typedef typename的用法，主要用于模板编程中声明依赖类型。通过示例展示了如何在模板类Table中使用typedef typename CONFIG::Value VALUE来定义类型别名，并说明了当模板参数为IntConfig或SymbolTableConfig时，编译器如何解析这些类型定义。文章还提到现代C++更推荐使用using VALUE = typename CONFIG::Value的语法，并以JVM hotspot中的符号表实现为例，演示了这种技术在实践中的应用场
算法学习入门---C/C++输入输出
最新发布
2302_80297338的博客
12-24 192
【代码】算法学习入门---C/C++输入输出（上）
机试题解
03-09
针对机试题目的解答或解析，通常涉及编程考试题目中的算法设计、数据结构应用以及具体实现方法等内容。对于此类问题的处理方式取决于具体的题目要求和技术栈的选择。 在面对机试编程题目时，理解题目背景和需求至关重要[^1]。例如，在解决字符串匹配类问题时，可以采用KMP算法来提高效率；而在处理数组或列表操作方面，则可能涉及到快速排序等经典算法的应用[^2]。 为了更好地准备机试，建议练习不同类型的典型题目并熟悉常用的数据结构与算法模式。此外，掌握调试技巧同样重要，这有助于及时发现程序逻辑错误或者性能瓶颈所在之处[^3]。 ```python def kmp_search(text, pattern): n = len(text) m = len(pattern) lps = [0] * m # Longest Prefix Suffix array compute_lps_array(pattern, m, lps) i = j = 0 while i < n: if pattern[j] == text[i]: i += 1 j += 1 if j == m: print("Found pattern at index", str(i-j)) j = lps[j-1] elif i < n and pattern[j] != text[i]: if j != 0: j = lps[j-1] else: i += 1 def compute_lps_array(pat, M, lps): length = 0 lps[0] i = 1 while i < M: if pat[i]== pat[length]: length += 1 lps[i] = length i += 1 else: if length != 0: length = lps[length-1] else: lps[i] = 0 i += 1 ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值