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;
}