C++复习之模板（自己要验证，才能更好掌握）

友元函数

#include <iostream>

using namespace std;

class Coordinate
{
    friend void printXY(Coordinate &c);
public:
    Coordinate(int x,int y);
private:
    int m_iX;
    int m_iY;
};
Coordinate::Coordinate(int x,int y)
{
    m_iX = x;
    m_iY = y;
}
void printXY(Coordinate &c)
{
    cout<<c.m_iX<<","<<c.m_iY;
}

int main()
{
    Coordinate coor(3,5);
    printXY(coor);
    return 0;
}

友元类

class Circle;
class Coordinate
{
    friend Circle;
    friend void printXY(Coordinate &c);
public:
    Coordinate(int x,int y);
private:
    int m_iX;
    int m_iY;
};

class Circle
{
public:
    void printXY()
    {
        cout<<m_coor.m_iX<<m_coor.m_iY;
    }
private:
    Coordinate m_coor;
};在这里插入代码片

友元关系不可传递；
友元关系具有单向性；
友元声明的形式和数量不受限制；
友元只是封装的补充，设计巧妙可以避开就更好，不然会暴露数据。

静态

#include <iostream>

using namespace std;

class Tank
{
public:
    Tank(){s_iCount++;}
    ~Tank(){s_iCount--;}
    static int getCount(){return s_iCount;}
    static int s_iCount;
private:
    string m_strCode;
};
int Tank::s_iCount = 0;

int main()
{
    cout<<Tank::getCount()<<endl;
    cout<<Tank::s_iCount<<endl;
    Tank tank;
    cout<<tank.getCount()<<endl;
    cout<<tank.s_iCount<<endl;
    return 0;
}

静态的成员函数只能操作静态数据。
因为静态是随类存在，编译的。
静态数据成员必须单独 初始化。
静态数据成员只有一份，且不依赖对象而存在，求一个对象的大小时是不包含静态数据的。

运算符重载

本质：函数重载
关键字：operator
一元运算符的重载

-负号的重载：
成员函数的重载：

#include <iostream>

using namespace std;

class Coordinate
{
public:
    Coordinate(int x, int y);
    Coordinate& operator-();
private:
    int m_iX;
    int m_iY;
};

Coordinate::Coordinate(int x, int y)
{
    m_iX = x;
    m_iY = y;
}

Coordinate& Coordinate::operator-()
{
    m_iX = -m_iX;
    m_iY = -m_iY;
    return *this;
}

int main()
{
    Coordinate coor1(3,5);

    -coor1;  //等价于coor1.operator-();
    return 0;
}

友元函数重载：

#include <iostream>

using namespace std;

class Coordinate
{
    friend Coordinate operator-(Coordinate &coor);
public:
    Coordinate(int x, int y);
private:
    int m_iX;
    int m_iY;
};

Coordinate::Coordinate(int x, int y)
{
    m_iX = x;
    m_iY = y;
}

Coordinate operator-(Coordinate &coor)
{
    coor.m_iX = -coor.m_iX;
    coor.m_iY = -coor.m_iY;
    return coor;
}

int main()
{
    Coordinate coor1(3,5);

    -coor1;  //等价于operator-(coor1);
    return 0;
}

后置++重载

#include <iostream>

using namespace std;

class Coordinate
{
public:
    Coordinate(int x, int y);
    Coordinate operator++(int);  //后置++，里面的int只是后置运算符的标志
private:
    int m_iX;
    int m_iY;
};
Coordinate::Coordinate(int x, int y)
{
    m_iX = x;
    m_iY = y;
}
Coordinate Coordinate::operator++(int)
{
    Coordinate old(*this);
    m_iX++;
    m_iY++;
    return old;
}

int main()
{
    Coordinate coor1(3,5);
    coor1++;  //coor1.operator++(0);
    return 0;
}

<<运算符重载

#include <iostream>

using namespace std;

class Coordinate
{
    friend ostream& operator<<(ostream &out, const Coordinate &coor);
public:
    Coordinate(int x, int y);
private:
    int m_iX;
    int m_iY;
};

Coordinate::Coordinate(int x, int y){
    m_iX = x;
    m_iY = y;
}

ostream& operator<<(ostream &out, const Coordinate &coor)
{
    out<<coor.m_iX<<","<<coor.m_iY;
    return out;
}

int main()
{
    Coordinate coor(3,5);
    cout<<coor;  //operator<<(cout,coor);
    return 0;
}

函数模板

#include <iostream>

using namespace std;

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

int main()
{
    int ival = maxx(100,99);
    char cval = maxx<char>('A','B');
    cout<<ival<<endl;
    cout<<cval<<endl;
    return 0;
}

变量作为函数模板

template <int size>
void display()
{
    cout<<size<<endl;
}
int main(){
    display<10>();
}

多参数函数模板

template <typename T, typename C>
void display(T a, C b)
{
    cout<<a<<" "<<b<<endl;
}
int main()
{
    int a=1024;
    string str = "hello world!";
    display<int, string>(a,str);
    return 0;
}

typename和class可以混用。

类模板

模板代码暂时不能分离编译。
得将所有代码都写在h文件里。