面向对象（二）——操作符重载 & 关键字this & 静态成员static

1.要想重载一个操作符，我们只需要编写一个成员函数，名为operator，后面跟我们要重载的操作符，遵循一下原型定义：

type  operator sign（parameters）；//如CVector operator+（Cvector）； 即函数operator+返回值类型的值
#include <iostream>
using namespace std;

class Cadd{
public:
    double x,y;
    Cadd(){};  //在这个例子中包括了一个空构造函数，而且将其定义成了无任何操作，因为例子中已经有其他的构造函数了。对于该构造函数，最好的方法应该是Cadd(){x=0,y=0}能够完成初始化。
    Cadd(double,double);//如果不像这样明确定义的话，就没有构造函数。
    Cadd operator +(Cadd);
};
Cadd::Cadd(double a,double b)
{
    x=a;
    y=b;
}
Cadd Cadd::operator +(Cadd param)
{
    Cadd temp;
    temp.x=x*param.x+x*param.y; //实现俩个二维数组的乘机
    temp.y=y*param.x+y*param.y;
    return (temp);
}
int main()
{
    Cadd a(2,3);//[2,3]
    Cadd b(3,4);//[3,4]T
    Cadd c=a+b;
    cout<<c.x<<c.y<<endl;
}
输出14 21

class Cadd的重载函数operator + （Cadd），这个函数可以用俩种方法调用：
c=a+b；
c=a.operator+(b);

但是对于默认拷贝函数而言，目前还比较模糊（在后面会稍微提及），这里是说包含一个对赋值操作符operator =的默认定义，该操作符用于俩个同类对象之间，这个操作符将其参数对象（右）的所有非静态成员赋值给其左边对象。

2.关键字this

this是C++中的一个关键字，也是一个const指针，即ClassName *const this，它指向当前对象，通过它可以访问当前对象的所有成员。

#include <iostream>
using namespace std;
class Student{
public:
    void setname(char *name);
    void setage(int age);
    void setscore(float score);
    void show();
private:
    char *name;
    int age;
    float score;
};
void Student::setname(char *name){
    this->name = name;
}
void Student::setage(int age){
    this->age = age;
}
void Student::setscore(float score){
    this->score = score;
}
void Student::show(){
    cout<<this->name<<"的年龄是"<<this->age<<"，成绩是"<<this->score<<endl;
}
int main(){
    Student *pstu = new Student;
    pstu -> setname("李华");
    pstu -> setage(16);
    pstu -> setscore(96.5);
    pstu -> show();

    return 0;
}

运行结果：
李华的年龄是16，成绩是96.5

this 只能用在类的内部，通过 this 可以访问类的所有成员，包括 private、protected、public 属性的。
本例中成员函数的参数和成员变量重名，只能通过 this 区分。以成员函数setname(char *name)为例，它的形参是name，和成员变量name重名，如果写作name = name;这样的语句，就是给形参name赋值，而不是给成员变量name赋值。而写作this -> name = name;后，=左边的name就是成员变量，右边的name就是形参，一目了然。

注意，this 是一个指针，要用->来访问成员变量或成员函数。

this 虽然用在类的内部，但是只有在对象被创建以后才会给 this 赋值，并且这个赋值的过程是编译器自动完成的，不需要用户干预，用户也不能显式地给 this 赋值。本例中，this 的值和 pstu 的值是相同的。

使用this需要注意的有几点：

this 是 const 指针，它的值是不能被修改的，一切企图修改该指针的操作，如赋值、递增、递减等都是不允许的。
this 只能在成员函数内部使用，用在其他地方没有意义，也是非法的。
只有当对象被创建后 this 才有意义，因此不能在 static 成员函数中使用。

this 到底是什么?

this 实际上是成员函数的一个形参，在调用成员函数时将对象的地址作为实参传递给 this。
不过 this 这个形参是隐式的，它并不出现在代码中，而是在编译阶段由编译器默默地将它添加到参数列表中。

this 作为隐式形参，本质上是成员函数的局部变量，所以只能用在成员函数的内部，并且只有在通过对象调用成员函数时才给 this 赋值。

3.静态成员（static members）

一个class可以包含静态成员，可以是数据，也可以是函数。
一个class的静态数据成员也被称作类变量，因为他们的内容不依赖于某个对象，对同一个class的所有对象具有同样的值。

#include <iostream>
using namespace std;
class Test{
public:
    static int n;//静态成员，相当于类的变量，只能申明，不能初始化
    Test(){n++;}   //每申明一次对象，都会调用一次构造函数
    ~Test(){n--;}
};
int Test::n=0;  //静态成员的初始化必须在类以外，出现在类外的函数定义不能指定关键字static
int main()
{
    Test a;
    Test d[5];
    Test *c=new Test; //开劈动态内存存放指针
    cout<<a.n<<endl;
    delete c;
    cout<<a.n<<endl;
    return 0;
}

其实静态成员就是个全局变量，只不过它的名字跟在了class后面，同样的我们也可以使用静态成员函数。

Static基本上的作用：

1. 修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区(全局区)，在main函数运行前就分配了空间，如果有初始值就用初始值优化它，如果没有初始值系统用默认值初始化它。
2. 修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命令函数重名，可将函数定位为static。
3. 修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，在类外进行赋值，而且不需要生成对象就可以访问该成员。
4. 修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是被static声明的函数，不能访问非静态成员。

类中静态成员的特性：

a.对于静态函数而言，static是全域函数，但是就像一个指定class的对象成员一样被调用，只能够引用static数据，永远不能引用class的非静态成员。也不能使用this，因为this实际上引用了一个对象指针，但是static函数和static成员并不属于对象，而是class 的直接成员。

b.静态成员可以相互访问，包括静态成员函数访问静态成员和访问静态成员函数。

c.非静态成员函数可以任意访问静态成员函数和静态数据。

4.static 的面向过程（即对于函数本身而言的），static的面向对象则是对于类而言的

1.静态全局变量
#include <iostream>
using namespace std;
void fun();
static int a;  //静态全局变量，未经初始化的默认为0
int main()
{
    a=20;
    cout<<a<<endl;
    fun();
    return 0;
}
void fun()
{
    a=8;
    cout<<a<<endl;
}
1.静态全局变量与全局变量的共同点是都储存在全局数据区中（已经初始化的在DATA区，未初始化的在DSS（名称不是很确定）中）
2.静态全局变量作用域为本文件，全局变量可通过extern与其他文件共享


2.静态函数

静态函数与普通函数不同，只能在申明它的文件中使用。

#include<iostream.h> static void fn();//声明静态函数 void main()
{ fn();
}
void fn()//定义静态函数时不用加static {
    intn=10;
    printf("%d",n);
}