c++的一些雜項

/**
    cwl:
    內容:c++非面向對象的一些雜項總結
        1, c++轉換函數

*/

#include <bits/stdc++.h>

using namespace std;

class Fraction
{
public:
    Fraction(int num, int den = 1)
        :m_numberator(num), m_denominator(den) {}
    operator double() const {
        return (double)((m_numberator * 1.0) / m_denominator);
    }

    Fraction operator + (const Fraction &f) {
        ///...
        return Fraction(0);
    }

private:
    int m_numberator;   ///分子
    int m_denominator;  ///分母
};

template<typename T>
void show(const T& firstArg)
{
    cout << firstArg << endl;
}

template<typename T, typename... Types>
void show(const T& firstArg, const Types&... args)
{
    cout << firstArg << endl;
    show(args...);
}

class A
{
public:
    void show() { cout << "A" << endl; }
};

class B: public A
{
public:
    void show() { cout << "B" << endl; }
};

int main()
{
    ///【1】轉換函數
    Fraction a = 3;
    printf("%f\n", (double)a);
    /**
    operator double() const {
        return (double)((m_numberator * 1.0) / m_denominator);
    }
    */

    ///【2】
    /**
    explicit Fraction(int num, int den = 1)
        :m_numberator(num), m_denominator(den) {}
    explicit避免構造函數在這個部分隱式轉換
    */

    ///【3】智能指針,一個像指針的類
    /**

    【第一類智能指針】
        template<class T>
        class Shared_ptr
        {
        public:
            T& operator*() const
            { return *px; }

            T& operator->() const
            { return px; }

            Shared_ptr(T* p):px(p) {}

        private:
            T* px;
            long *pn;
        };
        //注意這裏爲了清晰度沒有寫delete部分
        //    Shared_ptr<int>p = new int;
        //    *p = 1;

     【第二類迭代器】
        對指針重載++ --

    */

    /**
        【4】仿函數
        設計一個類，行爲像函數，重載()便可
        class Test {

            void operator () () {
                ///...
            }
        }
    */

    /**
        【5】
        模板可變參數

        template<typename T>
        void show(const T& firstArg)
        {
            cout << firstArg << endl;
        }

        template<typename T, typename... Types>
        void show(const T& firstArg, const Types&... args)
        {
            cout << firstArg << endl;
            show(args...);
        }
    */
    ///show(1, 3, 4, 5);

    /**
        由於泛型的緣由c++11重寫定義了auto。動態綁定類型

        另外一中拆包方式

        // 編譯這個代碼須要開啓 -std=c++14
        // 由於版本緣由，實驗環境中的 g++ 尚不支持此特性，此處可使用 clang++ 替代 g++
        template<typename T, typename... Args>
        auto print(T value, Args... args) {
            std::cout << value << std::endl;
            return std::initializer_list<T>{([&] {
                std::cout << args << std::endl;
            }(), value)...};
        }
        int main() {
            print(1, 2.1, "123");
            return 0;
        }

    */

    ///【5】子類調用父類函數
    B class_b;
    class_b.A::show();  ///子類中調用父類方法


    return 0;
}