C++ 常用惯用法大全

原创 已于 2025-04-18 14:03:54 修改 · 935 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

于 2025-04-18 14:02:41 首次发布

C++ 作为一门多范式编程语言，拥有丰富的编程惯用法（idioms）。这些惯用法是经验丰富的 C++ 程序员在实践中总结出的高效解决方案。以下是 C++ 中最重要和常用的惯用法：

1. RAII (Resource Acquisition Is Initialization)

资源获取即初始化是 C++ 最核心的惯用法。

class FileHandle {
public:
    FileHandle(const char* filename, const char* mode) {
        file = fopen(filename, mode);
        if (!file) throw std::runtime_error("File open failed");
    }
    
    ~FileHandle() {
        if (file) fclose(file);
    }
    
    // 禁用拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // 可以添加移动语义
    FileHandle(FileHandle&& other) noexcept : file(other.file) {
        other.file = nullptr;
    }
    
    // 其他成员函数...
    
private:
    FILE* file;
};

void useFile() {
    FileHandle f("test.txt", "r"); // 资源在构造函数中获取
    // 使用文件...
    // 资源在析构函数中自动释放
}

2. PIMPL (Pointer to Implementation)

指向实现的指针，用于接口与实现分离。

// widget.h
class Widget {
public:
    Widget();
    ~Widget();
    void doSomething();
private:
    struct Impl;
    std::unique_ptr<Impl> pImpl;
};

// widget.cpp
struct Widget::Impl {
    int data;
    std::string name;
    void helperFunction() { /*...*/ }
};

Widget::Widget() : pImpl(std::make_unique<Impl>()) {}
Widget::~Widget() = default;
void Widget::doSomething() { pImpl->helperFunction(); }

3. CRTP (Curiously Recurring Template Pattern)

奇异递归模板模式，用于静态多态。

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

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

template <typename T>
void useBase(Base<T>& base) {
    base.interface();
}

4. Type Erasure

类型擦除，用于运行时多态而不需要继承。

class AnyDrawable {
    struct Concept {
        virtual ~Concept() = default;
        virtual void draw() const = 0;
    };
    
    template <typename T>
    struct Model : Concept {
        Model(T value) : value(std::move(value)) {}
        void draw() const override { value.draw(); }
        T value;
    };
    
    std::unique_ptr<Concept> pimpl;
    
public:
    template <typename T>
    AnyDrawable(T value) : pimpl(std::make_unique<Model<T>>(std::move(value))) {}
    
    void draw() const { pimpl->draw(); }
};

// 使用
struct Circle { void draw() const { std::cout << "Drawing circle\n"; } };
struct Square { void draw() const { std::cout << "Drawing square\n"; } };

void drawAll(const std::vector<AnyDrawable>& items) {
    for (const auto& item : items) {
        item.draw();
    }
}

5. SFINAE (Substitution Failure Is Not An Error)

替换失败不是错误，用于模板元编程。

template <typename T>
auto print(const T& value) -> decltype(std::cout << value, void()) {
    std::cout << value << std::endl;
}

void print(...) {
    std::cout << "[object cannot be printed]" << std::endl;
}

// C++17 后可以用 constexpr if 简化
template <typename T>
void print(const T& value) {
    if constexpr (std::is_ostreamable_v<T>) {
        std::cout << value << std::endl;
    } else {
        std::cout << "[object cannot be printed]" << std::endl;
    }
}

6. Expression Templates

表达式模板，用于优化数值计算。

template <typename E>
class VecExpression {
public:
    double operator[](size_t i) const { return static_cast<const E&>(*this)[i]; }
    size_t size() const { return static_cast<const E&>(*this).size(); }
};

class Vec : public VecExpression<Vec> {
    std::vector<double> data;
public:
    double operator[](size_t i) const { return data[i]; }
    size_t size() const { return data.size(); }
    // ... 其他成员函数
};

template <typename E1, typename E2>
class VecSum : public VecExpression<VecSum<E1, E2>> {
    const E1& u;
    const E2& v;
public:
    VecSum(const E1& u, const E2& v) : u(u), v(v) {}
    double operator[](size_t i) const { return u[i] + v[i]; }
    size_t size() const { return u.size(); }
};

template <typename E1, typename E2>
VecSum<E1, E2> operator+(const VecExpression<E1>& u, const VecExpression<E2>& v) {
    return VecSum<E1, E2>(static_cast<const E1&>(u), static_cast<const E2&>(v));
}

7. NVI (Non-Virtual Interface)

非虚接口，用于模板方法模式。

class Base {
public:
    void execute() {
        preExecute();
        doExecute();
        postExecute();
    }
    virtual ~Base() = default;
private:
    virtual void doExecute() = 0;
    void preExecute() { /* 通用前置处理 */ }
    void postExecute() { /* 通用后置处理 */ }
};

class Derived : public Base {
private:
    void doExecute() override {
        // 具体实现
    }
};

8. Copy-and-Swap

拷贝并交换，用于实现异常安全的赋值操作。

class Resource {
    int* data;
    size_t size;
    
    void swap(Resource& other) noexcept {
        using std::swap;
        swap(data, other.data);
        swap(size, other.size);
    }
    
public:
    Resource(size_t size) : size(size), data(new int[size]) {}
    
    ~Resource() { delete[] data; }
    
    Resource(const Resource& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + size, data);
    }
    
    Resource& operator=(Resource other) {
        swap(other);
        return *this;
    }
    
    Resource(Resource&& other) noexcept : Resource() {
        swap(other);
    }
};

9. Rule of Zero/Five

零/五法则，现代C++资源管理准则。

// Rule of Zero - 使用智能成员变量，不需要自定义特殊成员函数
class RuleOfZero {
    std::unique_ptr<int> ptr;
    std::vector<int> data;
    std::string name;
    // 编译器生成的默认特殊成员函数足够好
};

// Rule of Five - 需要管理资源时，定义全部五个特殊成员函数
class RuleOfFive {
    int* data;
    size_t size;
    
public:
    explicit RuleOfFive(size_t size = 0) : size(size), data(size ? new int[size] : nullptr) {}
    
    ~RuleOfFive() { delete[] data; }
    
    RuleOfFive(const RuleOfFive& other) : size(other.size), data(size ? new int[size] : nullptr) {
        std::copy(other.data, other.data + size, data);
    }
    
    RuleOfFive(RuleOfFive&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
    
    RuleOfFive& operator=(RuleOfFive other) {
        swap(*this, other);
        return *this;
    }
    
    friend void swap(RuleOfFive& first, RuleOfFive& second) noexcept {
        using std::swap;
        swap(first.data, second.data);
        swap(first.size, second.size);
    }
};

10. Tag Dispatching

标签分发，用于基于类型特性的函数重载。

namespace tags {
    struct contiguous {};
    struct non_contiguous {};
}

template <typename Iterator>
void algorithm_impl(Iterator first, Iterator last, tags::contiguous) {
    std::cout << "Optimized version for contiguous memory\n";
}

template <typename Iterator>
void algorithm_impl(Iterator first, Iterator last, tags::non_contiguous) {
    std::cout << "Generic version for non-contiguous memory\n";
}

template <typename Iterator>
void algorithm(Iterator first, Iterator last) {
    using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
    
    if constexpr (std::is_same_v<iterator_category, std::random_access_iterator_tag>) {
        algorithm_impl(first, last, tags::contiguous{});
    } else {
        algorithm_impl(first, last, tags::non_contiguous{});
    }
}

11. Policy-Based Design

基于策略的设计，用于高度可配置的类。

template <typename OutputPolicy, typename LanguagePolicy>
class HelloWorld : private OutputPolicy, private LanguagePolicy {
public:
    void run() {
        OutputPolicy::output(LanguagePolicy::getMessage());
    }
};

class ConsoleOutput {
protected:
    void output(const std::string& msg) {
        std::cout << msg << std::endl;
    }
};

class English {
protected:
    std::string getMessage() {
        return "Hello, World!";
    }
};

class French {
protected:
    std::string getMessage() {
        return "Bonjour, le monde!";
    }
};

// 使用
HelloWorld<ConsoleOutput, English> hello;
hello.run(); // 输出: Hello, World!

12. Barton-Nackman Trick

Barton-Nackman技巧，用于在模板类中定义友元运算符。

template <typename T>
class Wrapper {
    T value;
public:
    Wrapper(const T& v) : value(v) {}
    
    friend bool operator==(const Wrapper& lhs, const Wrapper& rhs) {
        return lhs.value == rhs.value;
    }
    
    friend std::ostream& operator<<(std::ostream& os, const Wrapper& w) {
        return os << w.value;
    }
};

13. Virtual Constructor (Clone)

虚拟构造函数，用于多态复制对象。

class Shape {
public:
    virtual ~Shape() = default;
    virtual std::unique_ptr<Shape> clone() const = 0;
    virtual void draw() const = 0;
};

class Circle : public Shape {
    double radius;
public:
    explicit Circle(double r) : radius(r) {}
    std::unique_ptr<Shape> clone() const override {
        return std::make_unique<Circle>(*this);
    }
    void draw() const override {
        std::cout << "Circle with radius " << radius << std::endl;
    }
};

void cloneAndDraw(const Shape& shape) {
    auto cloned = shape.clone();
    cloned->draw();
}

14. Shrink-to-fit

收缩至合适大小，用于优化容器内存使用。

std::vector<int> v = {1, 2, 3, 4, 5};
v.erase(v.begin() + 2); // 删除第三个元素
v.shrink_to_fit(); // 释放未使用的内存

// 或者使用交换技巧（C++11前）
std::vector<int>(v).swap(v);

15. Empty Base Optimization (EBO)

空基类优化，用于无状态策略类的空间优化。

struct Empty {}; // 空类

// 没有EBO
struct NoEBO {
    Empty e;
    int x;
}; // 通常 sizeof(NoEBO) > sizeof(int)

// 使用EBO
template <typename Base>
struct WithEBO : Base {
    int x;
}; // sizeof(WithEBO<Empty>) == sizeof(int)

这些惯用法展示了 C++ 的强大功能和灵活性。掌握这些惯用法可以帮助你写出更高效、更可维护的 C++ 代码。根据具体场景选择合适的惯用法是成为高级 C++ 程序员的关键。

beyondmadman
关注
C++ 惯用法之 Nifty Counter
编程猿来如此
08-17 804
C++ 惯用法之 Nifty Counter
c++编程惯用法
03-31
本书的目的是帮助c++新手学习到那些在实践中最有效的惯用法。同时，也会在书中指出那些经常接触到的c++缺陷。
C++编程惯用法
05-23
C++编程惯用法
C++模板惯用法
把握自己。
08-24 1924
关于 C++ 模板编程的惯用法，note-to-self + keynote + idiom case + cross-reference 式笔记 目录 模板语法模板惯用法示例 堆栈上分配编译优化的开关推导数组元素个数推导常数隐式转换的显式函数 implicit_cast推导 callable 可调用物用成员模板实现继承隐喻假设模板基类中的成员CRTP 循环模板模式结合使
《C++编程惯用法》
极乐净土
04-03 947
第2章很不错，应该经常复习，并且用到实践中。第9章留在待用。 对，应该把第2章实践再实践。 第1章：抽象 使用CRC卡片来辅助设计，这个很不错 第2章：类 这是本人暂时觉得学习的一章，第9章的重用，主要是内存，资源觉得也不错，不过，段时间内貌似用不到 2.1：构造函数 2.2：赋值 2.3：公用数据 2.4：隐式类型转换 2.5：操作符重载：成员或非成员 2.6：重载
C++编程惯用法－高级程序员常用方法和技巧.pdf
09-12
### C++编程惯用法——高级程序员常用方法和技巧 #### 概述 《C++编程惯用法——高级程序员常用方法和技巧》是一本专为希望深入掌握C++编程技术的专业人士准备的书籍。本书旨在帮助读者了解并掌握一系列在实际开发...
C++编程惯用法.高级程序员常用方法和技巧.pdf
05-23
根据提供的文件内容，我们可以提炼出一些关于《C++编程惯用法.高级程序员常用方法和技巧》这本书的相关知识点。首先，这本书是由Robert B. Murray所著，他可能是一位在C++领域内有相当经验的高级程序员或技术专家。...
C++编程惯用法.高级程序员常用方法和技巧
04-10
C++编程惯用法.高级程序员常用方法和技巧
c++编程惯用法---------常用方法和技巧
qhxnls2的博客
08-27 204
c++电子书籍
《C++编程惯用法——高级程序员常用方法和技巧》——1.5　小结
weixin_34167043的博客
05-02 137
本节书摘来自异步社区出版社《C++编程惯用法——高级程序员常用方法和技巧》一书中的第1章，第1.5节，作者： 【美】Robert B. Murray ，更多章节内容可以访问云栖社区“异步社区”公众号查看。 1.5　小结 设计抽象模型和设计实现细节应该是两个独立且相关的行为。没有出现在抽象模型中的东西和出现在其中的东西一样重要。如果存在疑问，先不要去考虑...
C++编程惯用法.pdf
12-13
C++编程惯用法.C++编程惯用法.C++编程惯用法.
C++ 编程惯用法+高级程序员常用方法和技巧
11-27
C++ 编程惯用法+高级程序员常用方法和技巧 C++ 编程惯用法+高级程序员常用方法和技巧
《C++编程惯用法——高级程序员常用方法和技巧》导读
weixin_34392843的博客
05-02 528
前 言 C++编程惯用法——高级程序员常用方法和技巧C++是一门规模庞大的编程语言。只了解C++规则的程序员就和只知道棋子如何移动的棋手一样（失败）。为了获得成功，还要学习一些相关的法则和策略。 本书所面对的读者是使用C++语言的初级及中级程序员们，他们一方面期待学到更多有关使用这门语言的知识，一方面又没有时间去参加一个大学学期那么长的一门课程。...
C/C++惯用法
luckybat的专栏
03-03 595
map元素的两种访问方式：1) operator[] (const key_type&) -- 当元素不存在时自动创建，常用于表的构建过程；2) find (const key_value&) -- 当元素不存在时返回空，常用于表的使用过程；
C++编程惯用法----第1章 抽象(其他章节不咋样，不转载了)
tiewen的专栏
03-12 1504
第1章抽象     数据抽象（dataabstraction）是面向对象设计的一个重要概念。数据抽象要优先于面向对象的设计；然而，随着C++这样直接支持数据抽象的语言变得流行起来，它的应用范围也变得越来越广泛。     抽象数据类型（abstract data type,也称为ADT）是一种由用户定义、拥有明显不同的两部分的类型：     一个公用的接口（public interface），
C++惯用基本方法
shengzhe8688的专栏
08-09 407
C++ 字符差串操作的惯用操作
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值