static 注意事项

使用static 成员函数、成员变量语法

static 成员变量语法

友元类语法

友元类特性

在一个类中用到另一个类，需要在前面声明一下

cout << list1[i] << endl;//错误，list无法通过这种方式访问每一个元素
//可以使用迭代器进行访问
list<int>::iterator itor = list1.begin();
for(;itor != list.end();itor++){
    cout << *itor << endl;   //迭代器相当于是个指针
}

map中没有push_back，vector/list中都有

m.insert(p1);  //通过insert将一对pair插到m这个映射中

map也可以用迭代器遍历，但是不能直接用*itor输出，因为映射是一对（这样写计算机不知道该怎么输出）

//正确写法
cout << itor->first << endl; //first表示Key
cout << itor->second << endl; //second表示value
cout << endl;  //回车，加上比较好看(。

使用标准模板库时需要写相应头文件

#include <vector>

#include <map>

#include <list>

【标准模板库STL（Standard Template Lib）】

1、vector向量（本质：对数组的封装）（根据存储元素的个数自动变长or缩短，读取能在常数时间内完成）

※初始化【vector】对象的方法

vector<T> v1;  //vector保存类型为T的对象，默认构造函数v1为空
vector<T> v2(v1);  //v2是v1的一个副本
vector<T> v3(n,i);  //v3包含n个值为i的元素
vector<T> v4(n);  //v4包含有值初始化元素的n个副本

※ vector常用函数

empty();  //判断向量是否为空
begin();  //返回向量迭代器首元素
end();  //返回向量迭代器末元素的下一个元素
clear();  //清空向量
front();  //第一个数据
back();  //最后一个数据
size();  //获得向量中数据的大小
push_back(elem);  //将数据插入向量尾
pop_back();  //删除向量尾部数据

※ 遍历数组（例子）

1.

for(int k=0;k<vec.size();k++){
    cout<<vec[k]<<endl;
}

2.用迭代器（iterator）

vector v1;
v1.push_back("Hello");
vector<string>::iterator citer = v1.begin();//定义一个迭代器，<>中是数据类型
//citer是迭代器的变量名，begin指向迭代器首元素
for(;citer != v1.end();citer++){  //第一个条件可以不写
//end()是迭代器最后一个元素的下一个位置，所以可以这样写
    cout << *citer << endl;
}

2、list链表

一个节点也没有：空链表

存在多个节点，第一个是头节点

每个节点有两部分：数据部分+指针部分（将各个节点串联起来）

双链表：既可以从头找到尾，也可以从尾找到头

※ 特点：数据插入速度快

3、map映射

※ 数据结构

存储的数据都是成对出现：Key-键、Value-值

访问时可以通过键找到值

map<int,string> m;
pair<int,string> p1(10,"shanghai");  //通过pair定义若干对
pair<int,string> p2(20,"beijing");   //key是前面的值（10），value是后面的值（"beijing"）
//键也可以是string类型的
m.insert(p1);   //通过insert，将p1和p2这两对都放到m这个映射中
m.insert(p2);
cout<<m[10]<<endl;  //访问m映射中key=10的值，即shanghai
cout<<m[20]<<endl;

【类模板】

template<class T>
class MyArray{
public:
    void display();//若是类内定义则没什么特别的：void display(){...}
private:
    T *m_pArr;
};
//实现
template<class T>
void MyArry<T>::display(){
...
}
//使用
MyArray<int> arr;
arr.display();

【多参数的类模板】

template <typename T,int KSize>
class Container{
public:
    void display();
private:
    T m_obj;
}
//实现
template <typename T,int KSize>
void Container<T,KSize>::display(){
    for(int i=0;i<KSize;i++){
        cout << m_obj << endl;
    }
}
//使用
Container<int,10> ct1;
ct1.display();

【模板代码不能分离编译，必须都写在.h文件中】

int max(int a,int b){return(a>b) ? a:b;}  //比较大小

关键字：template typename class（class不是用来定义类的，是表明数据类型的）

template <class T>  //声明函数模板，推荐使用template<typename T>,跟用class一样
T max(T a, T b){
    return(a>b) ? a:b;
}
//使用，生成模板函数
int ival=max(100,99); //max后面没有指定类型，系统自动指定（此处是int）
char cval=max<char>('A','B');//max后面指定为char，则传入的参数必须是char类型的

如果仅仅有模板而没有模板函数，则不会产生任何数据

template<typename T>
void swap(T& a,T& b){   //数据互换
    T tmp=a;a=b;b=tmp;
}

【变量作为模板参数】

template <int size>   //传入的不是类型，而是变量
void display(){
    cout << size << endl;
}
//使用：
display<10>();  //实例化后传入的这个变量就是一个常数

【多参数函数模板】

template<typename T,typename C>  //多个参数，逗号隔开,两个typename都必须写
void display(T a,C b){
    cout << a << " " << b << endl;
}
//使用
int a=10;
string str="Hello";
display<int,string>(a,str);

【函数模板之间没有相互重载的关系，只有使用时产生的函数之间才是】

+的成员函数重载

Coordinate operator+(const Coordinate &coor);
//实现
Coordinate Coordinate::operator+(const Coordinate &coor){
    Coordinate temp(0,0);
    temp.m_iX = this->m_iX + coor.m_iX;
    temp.m_iY = this->m_iY + coor.m_iY;
    return temp;
}

二元运算符重载

【+号运算符】

1、友元函数重载

friend Coordinate operator+(const Coordinate &c1,const Coordinate &c2);
public:
private:
//实现
Coordinate operator+(const Coordinate &c1,const Coordinate &c2){
    Coordinate temp;
    temp.m_iX = c1.m_iX + c2.m_iX;    
    temp.m_iY = c1.m_iY + c2.m_iY;
    return temp;
}
//调用
Coordinate coor1(1,2);
Coordinate coor2(3,4);
Coordinate coor3(0,0);
coor3=coor1+coor2;//operator+(coor1,coor2)

2、成员函数重载

Coordinate operator+(const Coordinate &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 temp;
}
//调用
Coordinate coor1(3,5);
Coordinate coor2(2.4);
Coordinate coor3(0,0);
coor3=coor1+coor2;//coor1.operator+(coor2)

【<<号（输出符号）运算符】

1、友元函数重载

friend ostream& operator<<(ostream &out,const Coordinate &coor);
//out可以用任意一个合法的符号代替
//实现
ostream& operator<<(ostream &out,const Coordinate &coor){
    out<< coor.m_iX<<","<<coor.m_iY;  //用ostream后面的out（如果是其他符号就用其他符号）替代cout
    return out;
}
//调用
Coordinate coor(3,4);
cout<<coor; //operator<<(cout,coor)

2、输出运算符<<，不能用成员函数进行重载

成员函数重载只传入一个参数（第二个加数）（比如在+运算符中，第一个加数是当前的对象）

但是输出运算符的第一个对象必须是ostream（不能是this指针，即不能是当前对象）

【[ ]索引运算符】

1、成员函数重载

public:
    Coordinate(int x,int y);
    int operator[](int index);
private:
//实现
int Coordinate::operator[](int index){
    if(0==index){return m_iX;}
    if(1==index){return m_iY;}
}
//调用
Coordinate coor(3,4);
cout<<coor[0];//coor.operator[](0);
cout<<coor[1];//coor.operator[](1);

2、索引运算符不能使用友元函数重载

友元函数重载的第一个参数可以是this指针，也可以是其他值，但是索引运算符中，第一个参数必须是this指针（这个索引必须表达当前对象中的成员）

【运算符重载】给原有运算符赋予新功能，本质是 函数重载

定义运算符重载的关键字：operator

【-（负号）的重载】：

1、友元函数重载

friend Coordiante& operator-(Coodinate &coor);
public:
private:
//实现
Coordinate& operator-(Coordinate &coor){
    coor.m_iX=-coor.m_iX;
    coor.m_iY=-coor.m_iY;
    return *this;
}

2、成员函数重载

public:
    Coordinate(int x,int y);
    Coordinate& operator-();
//实现
Coordinate& Coordinate::operator-(){
    m_iX = -m_iX;
    m_iY = -m_iY;
    return *this;
}
//使用
Coordinate coor1(3,4);
-coor1;  //coor1.operator-();

【++符号的重载】

Coordinate& operator++();  //前置++
//实现
Coordinate& Coordinate::operator++(){
    m_iX ++;
    m_iY ++;
    return *this
}
//调用时
++coor1;//coor1.operator++();

Coordinate operator++(int);  //后置++（不加引用符&），int只是一个标识：当前是后置重载
//实现
Coordinate operator(int){
    Coordinate old(*this);
    m_iX ++;
    m_iY ++;
    return old;
}
//调用
coor1++;//coor1.operator++(0);

static int getCount() const;//错误

const的本质是给this指针加const，但是static类型没有this指针