18 c++ 用于大型程序的工具

刺骨的言语ヽ痛彻心扉 2023-03-01 09:18 4阅读 0赞

#include <iostream>
    #include <vector>
    #include <tuple>
    #include <bitset>
    #include <regex>
    #include <random>
    
    using namespace std;
    void exceptionTest();
    int main()
    { 
        exceptionTest();
    
        cout << "enter key" << endl;
        while (cin.get() != EOF) // ctrl + z
        { 
        }
    
        return 0;
    }
    
    void exceptionTest()
    { 
        try
        { 
            int n = 0;
            if (n < 0)
                throw logic_error("逻辑错误，n必须大于0");
        }
        catch (runtime_error error) // 运行时错误
        { 
        }
        catch (logic_error error) // 逻辑错误，一般由程序员抛出
        { 
            cout << error.what() << endl; // 打印错误消息
        }
        catch (exception error) // 错误
        { 
        }
    }
    
    // 如果我们的函数不会抛出异常，那么我们应该指定 noexcept 或 noexcept(true)
    // 如果指定我们的函数不会抛出异常，但函数却抛出了异常，那么该程序会终止
    void exceptionfun1() noexcept { };
    
    // 如果 exceptionfun1 不会抛出异常，那么 exceptionfun2 也承诺不会抛出异常
    void exceptionfun2() noexcept(noexcept(exceptionfun1)) {  exceptionfun1(); };

#ifndef Pack_H
    #define Pack_H
    
    #include <iostream>
    #include <string>
    
    // 指定命名空间 Sales
    // 同一个命名空间可以定义在不同的文件
    // 通常情况下，不将 #include 放在命名空间中
    namespace Sales
    { 
    
    class Pack
    { 
    private:
        /* data */
    public:
    };
    
    void Fun1();
    
    // 内联命名空间
    inline namespace Sales_Sub{ 
        void Fun2();
    }
    
    } // namespace Sale
    
    // 命名空间外定义成员需要加命名空间前缀
    void Sales::Fun1(){ };
    
    // 访问内联命名空间无需添加 Sales_Sub 前缀
    void Sales::Fun2(){ };
    
    // 头文件一般只在它的命名空间内或函数内使用 using 声明 或 指示
    void Fun3(){ 
        using Sales::Fun1;          // using 声明
        using namespace Sales;      // using 指示
    }
    
    void Fun4(){ 
        // 考虑如下问题，operator>>属于std命名空间，但这里为什么不加前缀也可以？？
        // 函数匹配规则如下：
        // 1.在当前作用域中查找
        // 2.在当前所使用的命名空间查找
        // 3.如果参数是类类型，则在参数所在的命名空间中查找
        // 参数 s 定义在 string 文件的 std 命名空间中，而我们下面使用的 operator>> 也在 string 文件的 std 命名空间中，所有匹配成功
        std::string s = "aa";
        operator>>(std::cin, s);
    }
    
    #endif
    
    
    #ifndef Programmer_H
    #define Programmer_H
    
    #include <string>
    
    // 多继承
    
    // 程序员
    class Programmer
    { 
    private:
        /* data */
    public:
    };
    
    // 前端
    // 这里对子类使用虚继承，表示 FrontEnd 愿意共享 Programmer
    // 虚基类在继承体系中只存在一个
    // 如果这里不使用虚继承，那么 FrontEnd 将独自拥有其继承的 Programmer
    class FrontEnd : public virtual Programmer
    { 
        public:
        std::string GetName(){  return "FrontEnd"; };
    };
    
    // 后端
    class BackEnd : public virtual Programmer
    { 
        public:
        std::string GetName(){  return "BackEnd"; };
    };
    
    // 全栈
    // 由于 FrontEnd，BackEnd 都使用虚继承 Programmer ，所以 Programmer 在 FullStack 的对象中只存在一份
    class FullStack : public FrontEnd, public BackEnd
    { 
    private:
    public:
        // 显示初始化所有基类
        // 由于两个子类都虚继承 Programmer，所以 Programmer 的初始化由当前类执行，并且放在第一位，如果我们没有显示调用 Programmer，则会调用Programmer的默认构造函数
        FullStack() : Programmer(), FrontEnd(), BackEnd(){ };
    
        // 基类都有 GetName 方法，所有为避免二义性，派生类应该也定义一个，隐藏基类的方法
        std::string GetName(){  
            return FrontEnd::GetName() + "+" + BackEnd::GetName(); 
        };
    };
    
    #endif