C++面向对象高级编程学习小结

C++面向对象高级编程学习小结

1 conversion function，转换函数

class Fraction
{
public:
    Fraction(int num, int den = 1)
    : m_numerator(num), m_denominator(den){}
    operator double() const
    {
        return (double)(m_numerator / m_denominator);
    }
private:
    int m_numerator;    //分子
    int m_denominator;  //分母
};

Fraction f(3, 5);
double d = 4 + f;  //调用operator double()

2 non-explicit one argument constructor

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

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

Fraction f(3, 5);
Fraction d2 = f + 4;  //调用non-explicit ctor将4转换为Fraction

explicit表示构造函数需要明确定义，不允许编译器自动转换

3 pointer-like classes，关于智能指针

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

shared_ptr<Foo> sp(new Foo);
Foo f(*sp);
sp->method(); === px->method();

4 pointer-like classes，关于迭代器

reference operator*() const
{return (*node).data;}
pointer operator->() const
{return &(operator*());}

5 function-like classer，仿函数

6 member template，成员模板

template<class T1, class T2>
struct pair{
    typedef T1 first_type;
    typedef T2 second_type;
    T1 first;
    T2 second;
    
    pair() : first(T1()), second(T2()){}
    pair() : first(const T1& a, const T2& b){} : first(a), second(b){}
    
    //member template
    template<class U1, class U2>
    pair(const pair<U1, U2>& p) : first(p.first), second(p.second);
}

智能指针的例子

template<typename _Tp>
class shared_ptr:public __shared_ptr<_Tp>
{
...
    template<typename _Tp1>
    explict shared_ptr(_Tp1* __p)
    : __shared_ptr<_Tp>(__p){}
...
};

Base* ptr = new Derived; //up-cast
shared_ptr<Base>sptr(new Derive);

7 variadic templates 数量不定的模板参数

1.void print()
{
}
2.template<typename T, typename... Types>
void print(const T& firstArg, const Types&... args)
{
    cout << firstArg << endl;
    print(args...);   //类似递归调用
}

print(7.5, "hello", bitset<16>(377), 42);

…就是所谓的pack(包)

8 reference 引用

reference通常不用于声明变量，而用于参数类型和返回类型的描述

9 复合&继承关系下的构造和析构

Inheritance继承关系下的构造和析构：

构造由内而外：Derived的构造函数首先调用Base的default构造函数，然后才执行自己

Derived::Derived(...):Base(){...};

析构由外而内：Derived的析构函数首先执行自己，然后才调用Base的析构函数

Derived::~Derived(){...~Base()};

Composition复合关系下的构造和析构

构造由内而外：Container的构造函数首先调用Component的default构造函数，然后才执行自己

Container::Container(...):Component(){...};

析构由外而内：Derived的析构函数首先执行自己，然后才调用Base的析构函数

Container::~Container(...){...~Component()};

Inheritance+Composition关系下的构造和析构

构造由内而外：Derived的构造函数首先调用Base的default构造函数，然后调用Component的default构造函数，然后才执行自己

Derived::Derived(...):Base(), Component();

析构由外而内：Derived的析构函数首先执行，然后调用Component的析构函数，然后调用Base的析构函数

Derived::~Derived(...){...~Component(), ~Base()};

10 对象模型

10.1 关于vptr和vtbl

关键词：多态、虚函数、动态绑定、up-cast

10.2 关于this指针

动态绑定的三个条件：
1. is a pointer
2. up-cast：父指针type指向子类
3. call virtual function

10.3 关于Dynamic Binding

静态绑定

动态绑定

11 谈谈const和static

const

static

静态成员函数没用this指针，只能处理静态数据