C++中有许多常见且贯用的编程技巧和设计模式，帮助开发者提高代码的可读性、可维护性以及性能。

1. RAII（Resource Acquisition Is Initialization）

这种方法确保资源的分配和释放与对象的生命周期绑定。通过构造函数分配资源，析构函数释放资源，可以避免资源泄漏问题。 示例：使用智能指针管理动态内存。

 #include <memory>
 
 void example() {
     std::unique_ptr<int> ptr = std::make_unique<int>(10); // 自动管理内存
     // ptr 在作用域结束时自动释放资源
 }

2. Pimpl（Pointer to Implementation）

这种方法隐藏类的实现细节以降低耦合，提高二进制兼容性和编译效率。你可以参考之前我提供的详细文章了解。

3. Singleton 模式

保证一个类只有一个实例，并提供一个全局访问点。虽然 Singleton 模式有争议，但在某些场景下非常实用，比如配置管理。

 class Singleton {
 public:
     static Singleton& getInstance() {
         static Singleton instance;
         return instance;
     }
     void doSomething() {}
 
 private:
     Singleton() {} // 私有构造函数
 };

4. 智能指针（Smart Pointer）

使用 std::shared_ptr 和 std::unique_ptr 替代传统裸指针，以便更好地管理内存，减少内存泄漏风险。

 #include <memory>
 
 std::shared_ptr<int> sharedResource = std::make_shared<int>(42);

5. 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() {
         // 子类实现
     }
 };

6. SFINAE（Substitution Failure Is Not An Error）

SFINAE 是 C++ 模板的一个特性，用于条件编译代码。结合 std::enable_if 和模板技术，它可以实现复杂的类型检查和限制。

 #include <type_traits>
 
 template <typename T>
 typename std::enable_if<std::is_integral<T>::value>::type
 doSomething(T value) {
     // 只有当 T 是整数类型时，这段代码会被编译
 }

7. 移动语义（Move Semantics）

通过 std::move 和右值引用优化资源的转移，而不是拷贝，提高性能。

 #include <vector>
 
 std::vector<int> createLargeVector() {
     return std::vector<int>(1000, 42); // 使用移动语义减少内存拷贝
 }
 
 auto vec = createLargeVector();

8. Lambda 表达式

C++ 的 Lambda 函数能够方便地定义匿名函数，尤其是在函数式编程场景中，例如排序或回调。

 #include <algorithm>
 #include <vector>
 
 std::vector<int> vec = {1, 5, 3};
 std::sort(vec.begin(), vec.end(), [](int a, int b) { return a < b; });

9. 范围 for 循环（Range-Based For Loop）

一种更简洁的遍历容器的方法，在 C++11 中引入。

 #include <vector>
 
 std::vector<int> vec = {1, 2, 3};
 for (const auto& val : vec) {
     // 逐元素访问
 }

10. 设计模式（Design Patterns）

C++ 中广泛使用的设计模式包括：

• 工厂模式：创建对象的抽象方式。
• 观察者模式：事件驱动的应用场景。
• 适配器模式：接口间的转换。
• 策略模式：行为封装和动态替换。

11. 标准库容器

优先使用 std::vector、std::map 等标准容器，而不是传统数组和手动实现的链表，借助标准库提高效率和安全性。

#include <vector>

std::vector<int> numbers = {1, 2, 3};

12. C++20 的协程（Coroutines）

协程是一种轻量级的线程，可以简化异步编程的代码。

#include <coroutine>
#include <iostream>

struct Generator {
    struct promise_type {
        int current_value;
        auto get_return_object() { return Generator{this}; }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend() noexcept { return std::suspend_always{}; }
        auto yield_value(int value) {
            current_value = value;
            return std::suspend_always{};
        }
        void return_void() {}
        void unhandled_exception() { std::exit(1); }
    };

    using handle_type = std::coroutine_handle<promise_type>;
    handle_type coro;

    Generator(promise_type* p)
        : coro(handle_type::from_promise(*p)) {}
    ~Generator() { coro.destroy(); }

    int getNext() {
        coro.resume();
        return coro.promise().current_value;
    }
};

Generator sequence() {
    co_yield 1;
    co_yield 2;
    co_yield 3;
}

int main() {
    auto gen = sequence();
    std::cout << gen.getNext() << "\n";
    std::cout << gen.getNext() << "\n";
    std::cout << gen.getNext() << "\n";
}

13. Namespace 的正确使用

通过命名空间避免名称冲突，同时可以简化组织代码的结构。

namespace MathUtils {
    double add(double a, double b) { return a + b; }
}

double result = MathUtils::add(3.0, 4.0);

14. 函数模板（Function Templates）

定义通用函数，避免冗余的代码。

template <typename T>
T add(T a, T b) {
    return a + b;
}

int sum = add(5, 6);

以上只是 C++ 中管用法的一部分，每种惯用法都有其适用场景和限制。根据具体需求选择合适的技巧和设计模式，可以显著提高代码质量和开发效率。如果你想深入探讨某一项技术，我们可以展开进一步讨论。