美文网首页
BOOLAN C++ 下1

BOOLAN C++ 下1

作者: 长江小杨 | 来源:发表于2017-08-10 21:47 被阅读0次

    1.导读

    2.Conversion function

    3.non-explicit-one-argument ctor

    4.point-link classes

    5.function-like classes

    6.namespace 经验谈

    7.class template 类模板

    8.function template 函数模板

    9.member template 成员模板

    10.specialization 模板特化

    11.模板偏特化

    12.模板模板参数

    13.关于C++标准库

    14.三个主题

    15.Reference

    1.Conversion Function转换函数

    class Fraction{

    public:

    operator double() const {//转换不可能改变类里的成员,通常加上const

    return (double)(m_numerator / m_denominator);

    }//把Fraction对象转换成double类型,double()不可有参数,返回类型不用写

    private:

    int m_numerator;

    int m_denominator;

    };

    Fraction f(3,5);

    double d=4+f;//调用operator double()将f转为0.6

    2.non-explict it one arguement construct

    //可以把别的东西转换为这种东西

    class Fraction{

    public:

    Fraction(int num,int den=1):m_numerator(num),m_denominator(den) {  }

    operator double const {

    return (double)(m_numerator / m_denominator);

    }

    Fraction operator+(constFraction& f) {

    return

    Fraction(...);

    private:

    int m_numerator;

    int m_denominator;

    };

    Fraction f(3,5);

    Fractiond2=f+4;//调用non_explict ctor将4转为Fraction,然后调用operator+

    template

    calss vector//模板的先特化,容器里的每个元素都是ool值

    {

    public:

    typedef __bit_reference reference;

    protected:

    reference operator[](size type n){//代表本来真正传回来的东西

    return *(begin() +diffenece_type(n));

    }

    struct __bit_reference

    {

    unsigned int* p;

    unsigned int mask;

    ...

    public:

    operator bool() const { return !(!(*p * mask));}

    };

    3.pointer-like classes,

    template

    class shared_ptr{

    public:

    T& operator*() const

    {

    return *px;

    }

    T* operator->() const{

    return px;

    }

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

    private:

    T* px;//指向T的指针,什么类型都接受

    long* pn;

    };

    lass Foo{

    ...

    void method(void) {...}

    };

    shared_ptr sp(new Foo);

    Foo f(*sp);

    sp->method();//调用method()

    px->method();//通过这个对象调用这个函数

    箭头符号有一个特殊的行为:作用下去得到的结果,这个箭头符号会继续作用下去

    智能指针里头一定带着一个一般的指针,而智能指针一定要带*和->符号

    point-class这种类型

    4迭代器

    主要用来遍历容器

    template

    struct _list_iterator//链表的迭代器

    {

    typedef _list_iterator self;

    typedef Ptr pointrt;

    typedef Ref reference;

    typedef _list_node* linx_type;//指向结点的指针

    link_type node;

    bool operator == (const self& x) const {return node == x.node;}

    bool operator != (const self& x) const {return node != x.node;}

    reference operator*() const {return (*node}.data;}

    pointer operator-> const {return &(operator*());}

    self& operator++() {node = (link_type)((*node).next);return *this;}

    self operator++(int) {self tmp = *this; ++*this; return tmp;}

    self& operator--() {node = (link_type)((*node).prev;return *this;}

    self operator--(int) {self tmp = *this; --*this; return tmp;}

    };

    5 Function - like class

    template

    struct identity : public unart_function{

    const T& operator()(const T& x) const { return x;}

    };

    template

    struct selectst{//取出第一个

    const typename Pair::first_type& operator() (const Pair& x) const

    {

    return x.first;

    }

    };

    template

    Struct select2nd : publicunart_function{//取出第二个

    const typename Pair::second_type& operator()(const Pair& x) const

    {

    return x.second;

    }

    };

    template

    struct pair: publicunart_function{

    T1 first;

    T2 second;

    pair() : first(T1()),second(T2()) {}

    pair(const T1& a,const T2& b):first(a),second(b) { }

    };

    6.class template类模板和fumction template函数模板

    template//复数的类模板

    class complex{

    public:

    complex(T r=0,T i=0):re(r),im(i) {}

    complex & operator += (const complex&);

    T real() const {return re;}

    T imag() const {return im;}

    private:

    T re,im;

    friend complex& __doapl(complex*,const complex&);

    };

    {

    complex c1(2.5,1.5);

    complex c2(2,6);

    }

    函数模板:

    class stone{

    public:

    stone(int w,int h,int we):_w(w),_h(h),_weight(we) {}

    bool operator<<(const stone& rhs) const {

    return _weight < rhs._weight;

    }

    private:

    int _w,_h,_weight;

    };

    template

    inline const T& min(const T& a, const T& b)

    {  return b;}

    函数模板在使用的时候不必指明type,能够通过调用时传递的实参推出来类型

    member template成员模板

    template

    struct pair{

    typedef T1 first_type;

    typedef T2 second_type;

    T1 first;

    T2 second;

    pair():first(T1()),second(T2()) {}

    pair(const T1 &a,const T2 &b)

    :first(a),second(b) {}

    template   //成员模板

    pair(const pait &p)//T1和T2类型确定了以后,U1和U2也能进行确定

    :first(p.first),second(p.second) {}

    }

    7.模板特化specialization

    Template

    struct hash ();

    template<>

    struct hash{

    size_t operator() (char x) const {return x;}//重载

    };

    template<>

    struct hash{

    size_t operator() (int x) const {return x;}

    };

    template<>

    struct hash{

    size_t operator() (long x) const {return x;}

    };

    作者:孙浩_9bfd

    链接:http://www.jianshu.com/p/5f845320f773

    來源:简书

    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    相关文章

      网友评论

          本文标题:BOOLAN C++ 下1

          本文链接:https://www.haomeiwen.com/subject/drskrxtx.html