c++高级开发（下）侯捷笔记大全

转换函数

1.  operator double() const   //这里的const不是非要加，但是由于转换函数一般不修改值，所以一般都加const
    {
        return (double) (m_numerator / m_denominator);
    }
    //在任何时候需要把它变成double的时候会自动调用这个函数

2. non-explicit - one - argument ctor 没有explicit参数，并且只需要至少一个实参即可的函数

    Fraction (int num,int den = 1)
    : m_numerator(num),m_denominator(den){ }
    //当某个时刻调用的时候可以把int转为Fraction

3. explicit - argument ctor

    explict Fraction (int num.int den = 1)  //如果这里不加explict，编译器会不知道调哪一个函数，加了以后表示除了构造函数都不用这个
    : m_numerator(num),m_denominator(den){ }
    ​
    operator double() const   //这里的const不是非要加，但是由于转换函数一般不修改值，所以一般都加const
    {
        return (double) (m_numerator / m_denominator);
    }

4. pointer - like classes 智能指针(写出来一个像类的指针)

    //指针所允许的都允许  ( *  &  -> )
    ​
    //类函数
    template<class T>
    class shared_ptr
    {
    public:
        T& operator*() const
        {
            return *px;
        }
        T* operator-> const
        {
            return px;
        }
    private:
        T* px;
        long* pn;
    }
    ​
    //主代码
    shared_ptr<Foo> sp;
    ​
    Foo f(*sp);
    //这里的*在被用来调用出原本的指针以后,仍会保留继续作用,直到彻底作用结束以后
    sp->method();  //这里相当于 px->method();
    //这里的&号同上

5. pointer - like classes ,关于迭代器(用于遍历容器)

    ​

6. function-like classes 仿函数

   在小小的类里面重载小括号

   c++标准库中有很多,他们大多都继承了一些奇奇怪怪的库

7. 如果变量名或者别的东西有冲突,可以将其放置在不同的命名空间里

8. class template 类模板

   当写函数的人不确定变量种类时 可以用

    //定义前加
    template<typename T>
    ​
    //使用的时候
    complex<double> c1;  //需在尖括号里指定种类

9. function template, 类模板

    template<class T>
    const T& min(const T& a,const T& b)
    {
        ...;
    }
    ​
    ​
    r3 = min(r1,r2);  //不需要指明种类,编译器会进行推导

10. member template , 成员模板

     template <class T1,class T2>
     struct pair
     {
         ...;    
         T1 first;
         T2 second;
         
         template<class U1,class U2>
         pair (const pair<U1,U2>&p):first(p.first),second(p.second)  //它允许你拿别的东西来构造这个类,但是前提是你能过这个赋值函数,就比如传进去"麻雀"可以用来赋值并创建"鸟类"一样
         {
             ...;
         }
     }
     ​

11. specialization 模板特化

     //模板泛化
     templatr<class Key>  //任意类型都可以调这个代码
     struct hash{ };
     ​
     //模板特化
     template<>           //但当类型是char或者int时,就会调下面这两段代码  (优先特化)
     struct hash<char>
     {
         ...;
     }
     ​
     template<>
     struct hash<int>
     {
         ...;
     }

12. partial specialization 模板偏特化

    1. 个数的偏

        template<typename T,typename Alloc = bool>  //当Alloc的类型为int的时候,优先调用这个函数
        class vector
        {
            ...;
        }
        //一般用于不需要单独开一个字节的数据类型节省空间 比如bool

    2. 范围上的偏

        template <typename T>
        class C
        {
            ,,,;
        }
        ​
        template <typename T>
        class C<T*>     //当T为一个指针时,优先使用这个(但是指针指向什么不做要求)
        {
            ...;
        }

13. template template parameter , 模板模板参数

     template<typename T,template <typename T> ,class Coinainer>
     class XCls
     {
     private:
         Container<T> c;
     public:
         ...;
     }
         
     template<typename T>   //修改这里生成的就不是链表了
     using Lst = list<T,allocator<T>>;
     ​
     //函数里只需要写下面这个
     XCls<string, Lst> mylst;    //允许用户创建各种元素种类的链表
     //为了提高泛用性
     template<typename T,template <typename T> ,class SmartPtr>
     class XCls
     {
     private:
         Container<T> sp;
     public:
         XCls() : sp(new T) { };
     }
         
     ​
     ​
     //函数里只需要写下面这个
     XCls<string, shared_ptr> p1;   
     XCls<long ,auto_ptr> p2;

14. variadic templates(since C++11) 数量不定的模板参数

     void print()   //我叫最上面的代码
     {
         ...;
     }
     ​
     ​
     template <typename T,typename... Types>
     void print(const T& firstArg,const Types&... args)  //每次都会把输入进来的东西变成一个和一包,这个包再次调用,再次被分为一个和一包...用类似递归的方式来输出所有,最后一个进去的时候就会变成一个和零个,输出以后零个便无法调用这个了,便会开始调用最上面的代码(不需要输入的print函数)
     {
         cout<<firstArg<<endl;
         print(args...);
     }