类模板：一个参数

// 声明
template<class T>
class MyArray
{
private:
    T *m_pArr;
}
// 定义
// template 和 lei<T> 共同唯一定义了该方法
template<class T>
void MyArray<T>::display()
{ ... }
// 使用
MyArray<int> arr; // 初始化时也要传递<T>的类型
arr.display();

多变量作为模板参数

template <typename T,typename C>
void display(T a,C b)
{
    cout << a << " " << b << endl;
}

等于以下

template<typename T,class U>
T minus(T* a,U b);

混用

template <typename T,int size>
void display(T a)
{
    cout << size <<endl;
}

变量作为模板参数

template <int size>
void display()
{
    cout << size << endl;
}
// 使用
display<10>();

template<typename T> 的定义方法，和 class 的基本类似

函数模板

template <class T>
T max(T a,T b)
{
    return (a > b)?a:b;
}

[] 运算符

// 声明
int operator[](int index);
// 定义
int Coordinate::operator[](int index)
{
    if(0 == index)
    {return m_iX;}
    if(1 == index)
    {return m_iY;}
}
// 使用
cout << coor[0]; // 相当于 coor.operator[](0);

<< 运算符重载：

friend ostream& operator<<(ostream &out,const Coordinate &coor)
{
    out << coor.m_iX << "," << coor.m_iY;
    return out;
}
// 使用
cout << coor; // 相当于 operator<<(cout,coor);

+ 号成员函数实现：

Coordinate operator+(Coordinate &coor1,Coordinate &coor2)
{
    Coordinate temp;
    temp.m_iX = coor1.m_iX + coor2.m_iX;
    temp.m_iY = coor1.m_iY + coor2.m_iY;
    return temp
}

+ 号成员函数重载：

声明：
Coordiante operator+(const Coordiante &coor);
定义：
Coordinate operator+(const Coordinate &coor)
{
    Coordinate temp;
    temp.m_iX = this->m_iX + coor.m_iX;
    temp.m_iY = this->m_iY + coor.m_iY;
    return tem;
}
// 使用
Coordinate coor1(1,2);
Coordinate coor2(2,3);
Coordinate coor3(0,0);
coor3 = coor1 + coor2; // 相当于： coor1.operator+(coor2);

Coordinate &Coordinate::operator-()

{

    m_iX = - m_iX;

    this->m_iX = -this->m_iX;

    return *this; // 别忘了星号

}

前置++ 和 后置++

- 前置++

     - 与成员函数重载一致

- 后置++

Coordinate operator++(int); // 返回对象，而不是引用；传入的 int 只是一个标志，不使用
// 定义
Coordinate operator++(int)
{
    Coordinate old(*this);
    m_iX++;
    m_iY++;
    
    return old; // return 的是 old，保证后置++当前返回的不变，而 this 指向的已变
}
// 即
Coordinate coor1(3);
coor1++; // coor1.operator++(0)

友元函数重载：

friend Coordinate& operator-(Coordinate &coor);

实现

Coordinate& operator-(Coordiante &coor) // 传了一个引用进来
{
    coor.m_iX = -coor.m_iX;
    
    return coor; // 视频错误写完 *this
}
//调用
Coordiante coor1(3);
-coor1; // operator-(coor1);

成员函数重载：

Coordinate& operator-();
有隐形 this 指针
Coordinate& Coordinate::operator-()
{
    m_iX = -m_iX;
    return *this;
}
使用
Coordinate coor1(3);
-coor1; // 等价于coor1.operator-();

Tank t1("a");
cout << t1.getCount() << endl; // 11
// or 
Tank.getCount();
// 析构测试

Tank *t1 = new Tank("a");
cout << Tank::getCount() << endl;
Tank *t2 = new Tank("b");
cout << t1->getCount() << endl;
delete t1;
delete t2;
cout << Tank::getCount() << endl;

在调用的时候，可以直接用 Tank.getCount() 来执行 static 函数