笔记:C++引用类型，友元，重载运算符

引用类型举例：

void demo(int& arg)

{

 arg=1;//与指针的差别 前面可以不用加*  给指针指向的地址赋值.相当于给main那里的a赋值

}

int main(int argc,char* argv[])

{

int a=10;

 demo(a);//在c++中  demo的参数a有可能是int 类型 有可能会是int类型的引用  这里直接传变量

return 0;

}

在反汇编中 上面的反汇编代码同下面的指针类型没差别：

void demo(int* arg)

{

 *arg=1;

}

int main(int argc,char* argv[])

{

int a=10;

 demo(&a);//在c++中  demo的参数a有可能是int 类型 有可能会是int类型的引用 这里需要传变量地址

return 0;

}

唯一的区别就是指针传参，指针可以指向别的地方（乱指会出错）.

而引用的话 编译器不允许再指向别的地方

总结：

1.引用类型是c++里面的类型

2.引用类型只能赋值一次,不能重新赋值.（引用类型存储的是当前对象的地址）,引用类型需要初始化

3.引用类型只是变量的一个别名

4.引用类型可以理解城市编译器维护的一个指针，但并不占用空间（反汇编代码里看不到引用的影子，也就是并没有单独给它一个地址什么之类的，纯属编译器限制）

5.使用引用可以像指针一样区访问，修改对象的内容，但更加安全.

友元函数

class person

{

private://私有的 外部可以使用和访问

        int x;

        int y;

public://公开的 外部可以调用

 person(int x,int y)

        { 

       this-> x=10;

        this->y=20;

        }

//友元函数的声明：

friend void function(const person& p);关键词friend 告诉编译器这个函数可以在外部访问私有成员

}

void function(const person& p) //const告诉编译器这个参数我们只读它的值，不修改它的值 .const 常量

        {

         printf("%d",p.x);//由于x在类里面是私有成员 所以正常是无法读取的，需要声明友元函数

        }

还有友元类，本质都是在需要使用的类里面声明外部某函数 某类是朋友，可以调用本类中的私有成员.  

什么情况下需要友元函数：

1.运算符重载的某些场合需要使用友元。

2.两个类要共享数据的时候

友元函数和类的成员函数的区别。

1.成员函数有this指针，而友元函数没有this指针  因为它不是类的成员

2.友元函数是不能被继承的，就像父亲的朋友未必是儿子的朋友.

运算符重载：

class demo

{

private:

        int a;

        int b;

public:

        void print();

       demo();//定义构造函数

        demo operator ++(); //运算符重载 就是给函数取一个运算符的名字. 本质上就是一个成员函数

//写运算符重载一定要注意，因为它本身也是一个函数,是函数就有返回值.它的这个运算返回值必须是它自己的类型   Int i; i++  i加完还是int  所以 这里运算符重载的子程序运算完后 返回值类型应该还是demo

 //但是如果重载的是大于这类的运算符，返回值类型应该是逻辑类型

       demo operator +(const demo& Pdemo);//重载加号运算符

        bool operator >(const demo& Pdemo);//重载大于号 注意返回值类型 设置的bool逻辑型

//其他的 -- * /  ==就不列举了

}           

//--------------------------大于号重载的实现

bool  demo::operator >(const demo& Pdemo)

{

                if(this->a > Pdemo.a)//如果结构体成员a  大于  参数 Pdemo.a

               {

                return true;

                }

                 return false;

}

 

//-------------------------------加号运算符实现 

  demo  demo::operator +(const demo& Pdemo)

        {

                this->a=Pdemo.a+this->a;

                this->b=Pdemo.a+this->b;

                return *this;

        }

//----------------++实现

demo demo::operator ++()//外部实现

{

        a++;

        b++;

        return *this;//返回当前这个指针的地址

}

demo::demo()//外部实现

{

        this->a=3;

        this->b=4;

}

void demo::print()//结构体内部定义 外部实现

{

printf("%d  %d",a,b);

}

int main(int argc,char* argv[])

{

  demo n;

  demo n2;

   bool  da;

n++;//运算符重载，调用的是demo结构里面的++函数

n=n + n2;//运算符重载，调用的是demo结构里面的+函数

da=n > n2;//大于号重载，调用的是demo结构里面的>函数

if (n > n2)printf("n里的a(this->a)大 ");

return 0;

}

运算符重载就是函数替换， . ::?: suzeof # 不能重载

除了在结构体内部定义，使用友元函数也可以实现（++--这种需要用到this指针的不适用）

有些情况下，一定要用到友元函数..