三分钟读完《Essential C++》

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#ifdef __cplusplus

#if __cplusplus <= 201103L
namespace std {
    template<typename T, typename... Args>
    std::unique_ptr<T> make_unique(Args&&... args) {
        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
    }
}
#endif

#endif


// 规则1: 避免使用宏定义
// 不使用宏定义

// 规则2: 使用const来限制变量的修改
const int MAX_VALUE = 100;

// 规则3: 使用引用传递参数
void modifyValue(int& value) {
    value = 42;
}

// 规则4: 使用C++风格的类型转换
int intValue = static_cast<int>(3.14);

// 规则5: 使用const成员函数
class MyClass {
public:
    void modifyData() {
        data_ = 42;
    }

    int getData() const {
        return data_;
    }

private:
    int data_;
};

// 规则6: 尽量使用初始化列表
class AnotherClass {
public:
    AnotherClass(int value) : value_(value) {}

private:
    int value_;
};

// 规则7: 避免使用裸指针
std::unique_ptr<int> createIntPtr() {
    return std::make_unique<int>(42);
}

// 规则8: 使用std::string代替C风格字符串
std::string str = "Hello, world!";

// 规则9: 使用std::vector代替数组
std::vector<int> numbers = {1, 2, 3, 4, 5};

// 规则10: 使用std::array或std::vector代替C风格数组
std::array<int, 3> arr = {1, 2, 3};

// 规则11: 使用std::unique_ptr或std::shared_ptr管理动态内存
std::unique_ptr<int> ptr = std::make_unique<int>(42);

// 规则12: 使用范围for循环
void printNumbers(const std::vector<int>& nums) {
    for (const auto& num : nums) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

// 规则13: 避免使用goto语句
void someFunction() {
    bool condition = true;
    if (condition) {
        // do something
    } else {
        // do something else
    }
}

// 规则14: 使用自定义类型代替布尔型标志
enum class Status { OK, ERROR };

// 规则15: 将多个相关变量组织成结构体或类
struct Person {
    std::string name;
    int age;
};

// 规则16: 避免跨文件的全局变量
namespace {
    int internalVariable = 42;
}

// 规则17: 使用enum class代替enum
enum class Color { RED, GREEN, BLUE };

// 规则18: 将类的成员函数定义和声明分离
class MyClass2 {
public:
    void memberFunction(); // 在类的声明中只声明函数

private:
    int data_;
};

void MyClass2::memberFunction() {
    // 在类的定义中实现函数
}

// 规则19: 使用虚函数实现多态
class Base {
public:
    virtual void doSomething() {
        std::cout << "Base::doSomething()" << std::endl;
    }
};

class Derived : public Base {
public:
    void doSomething() override {
        std::cout << "Derived::doSomething()" << std::endl;
    }
};

// 规则20: 使用override关键字显式地重写虚函数
class Base2 {
public:
    virtual void doSomething() {
        std::cout << "Base2::doSomething()" << std::endl;
    }
};

class Derived2 : public Base2 {
public:
    void doSomething() override {
        std::cout << "Derived2::doSomething()" << std::endl;
    }
};

// 规则21: 使用final关键字禁止继承
class Base3 final {
public:
    virtual void doSomething() {
        std::cout << "Base3::doSomething()" << std::endl;
    }
};

// 规则22: 使用默认成员初始化
class MyClass3 {
public:
    MyClass3() = default; // 使用默认构造函数
    MyClass3(int value) : value_(value) {}

private:
    int value_ = 0; // 使用默认成员初始化
};

// 规则23: 使用std::initializer_list进行初始化
class MyClass4 {
public:
    MyClass4(std::initializer_list<int> values) {
        for (int value : values) {
            values_.push_back(value);
        }
    }

private:
    std::vector<int> values_;
};

// 规则24: 使用拷贝控制成员函数
class MyClass5 {
public:
    MyClass5(const MyClass5& other) {
        // 拷贝构造函数
    }

    MyClass5& operator=(const MyClass5& other) {
        if (this != &other) {
            // 拷贝赋值运算符
        }
        return *this;
    }

    ~MyClass5() {
        // 析构函数
    }
};

// 规则25: 使用移动语义提高性能
class MyClass6 {
public:
    MyClass6(MyClass6&& other) noexcept {
        // 移动构造函数
    }

    MyClass6& operator=(MyClass6&& other) noexcept {
        if (this != &other) {
            // 移动赋值运算符
        }
        return *this;
    }
};

// 规则26: 使用RAII资源管理
class File {
public:
    explicit File(const std::string& filename) {
        // 打开文件
    }

    ~File() {
        // 关闭文件
    }

    // 其他成员函数
};

// 规则27: 使用智能指针进行资源管理
void manageResource() {
    std::shared_ptr<int> ptr = std::make_shared<int>(42);
    // 使用智能指针ptr
}

// 规则28: 使用标准库容器进行数据管理
void manageData() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // 使用numbers进行数据管理
}

// 规则29: 使用std::function实现函数对象
int add(int a, int b) {
    return a + b;
}

std::function<int(int, int)> func = add;

// 规则30: 使用Lambda表达式实现匿名函数
auto f30 = [](){
    std::vector<int> nums = {1, 2, 3, 4, 5};
    int sum = 0;
    std::for_each(nums.begin(), nums.end(), [&](int num) {
        sum += num;
    });
};

// 规则31: 使用std::algorithm进行常见操作
std::vector<int> nums2 = {1, 2, 3, 4, 5};
int max = *std::max_element(nums2.begin(), nums2.end());

// 规则32: 使用异常处理错误
void process() {
    try {
        // 可能引发异常的代码
    } catch (const std::exception& e) {
        // 异常处理代码
    }
}

// 规则33: 使用异常规范声明函数可能抛出的异常
void func2() noexcept {
    // 不会抛出异常的函数
}

// 规则34: 使用std::mutex和std::lock_guard进行互斥访问
std::mutex mtx;
int sharedData = 0;

void updateSharedData() {
    std::lock_guard<std::mutex> lock(mtx);
    // 更新共享数据
}

// 规则35: 使用std::condition_variable进行线程同步
std::mutex mtx2;
std::condition_variable cv;
bool ready = false;

void waitForSignal() {
    std::unique_lock<std::mutex> lock(mtx2);
    cv.wait(lock, [] { return ready; });
    // 执行等待后的操作
}

void sendSignal() {
    std::lock_guard<std::mutex> lock(mtx2);
    ready = true;
    cv.notify_one();
}

// 规则36: 使用std::atomic进行原子操作
std::atomic<int> atomicValue{0};

void incrementAtomicValue() {
    atomicValue++;
}

// 规则37: 避免使用未定义行为
auto p37 = [](){
int x = 5;
int y = 0;
int result = x / y; // 未定义行为：除以0
};

// 规则38: 避免使用强制类型转换
double d = 3.14;
int i = static_cast<int>(d);

// 规则39: 使用命名空间进行组织和避免命名冲突
namespace MyNamespace {
    int value = 42;
}

// 规则40: 使用头文件保护
#ifndef MY_HEADER_H
#define MY_HEADER_H

// 头文件的内容

#endif

// 规则41: 避免滥用宏定义
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int maxValue = MAX(5, 10);

// 规则42: 使用迭代器进行数据遍历和操作
auto f42=[](){
    std::vector<int> numbers2 = {1, 2, 3, 4, 5};
    for (auto it = numbers2.begin(); it != numbers2.end(); ++it) {
        *it *= 2;
    }
};

// 规则43: 使用合适的容器选择算法
auto f43 = [](){
    std::vector<int> numbers3 = {1, 2, 3, 4, 5};
    std::sort(numbers3.begin(), numbers3.end());
};

// 规则44: 使用关联容器进行高效查找
auto f44 = [](){
std::map<std::string, int> scores = {{"Alice", 100}, {"Bob", 90}};
int aliceScore = scores["Alice"];
};

// 规则45: 使用std::tuple进行多值组合
std::tuple<std::string, int, double> data = std::make_tuple("Alice", 25, 3.14);
std::string name = std::get<0>(data);
int age = std::get<1>(data);
double value = std::get<2>(data);

// 规则46: 使用std::pair进行键值对存储
std::pair<std::string, int> student = {"Alice", 25};
std::string studentName = student.first;
int studentAge = student.second;

// 规则47: 使用std::set进行排序和去重
auto f47 = [](){
    std::set<int> uniqueNumbers = {2, 1, 3, 2, 4, 3, 5, 1};
    for (int num : uniqueNumbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
};

// 规则48: 使用std::map进行键值映射
std::map<std::string, int> ageMap = {{"Alice", 25}, {"Bob", 30}};
int aliceAge = ageMap["Alice"];

// 规则49: 使用std::unordered_set进行高效查找
std::unordered_set<int> numberSet = {1, 2, 3, 4, 5};
bool containsThree = numberSet.find(3) != numberSet.end();

// 规则50: 使用std::unordered_map进行高效键值映射
std::unordered_map<std::string, int> scoreMap = {{"Alice", 100}, {"Bob", 90}};
int aliceScore2 = scoreMap["Alice"];

// 规则51: 使用智能指针管理资源
std::shared_ptr<int> ptr2 = std::make_shared<int>(42);
// 使用智能指针ptr2

// 规则52: 使用std::reference_wrapper进行引用传递
void modifyValue(std::reference_wrapper<int> valueRef) {
    valueRef.get() = 42;
}

auto f52 = [](){
    int refValue = 10;
    modifyValue(refValue);
};

// 规则53: 使用std::tie进行元组解包
auto f53 = [](){
    std::tuple<std::string, int, double> studentData = std::make_tuple("Alice", 25, 3.14);
    std::string name2;
    int age2;
    double value2;
    std::tie(name2, age2, value2) = studentData;
};

// 规则54: 使用std::enable_if进行模板条件编译
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type addOne(T value) {
    return value + 1;
}

// 规则55: 避免使用裸new和delete
std::unique_ptr<int> dynamicInt = std::make_unique<int>(42);

int main() {
    return 0;
}