class学习（四）this指针,空指针调用成员函数,常对象,友元,+运算符重载

wanxiang_zx

已于 2022-05-07 16:06:17 修改

阅读量223

点赞数

分类专栏： c++之class 文章标签： c++

于 2021-11-04 16:58:08 首次发布

本文链接：https://blog.csdn.net/wanxiangzx/article/details/121106093

版权

c++之class 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.this指针指向被调用函数所属对象

当形参和成员变量同名时，可以用this来区分
在类的非静态成员函数中返回对象本身，可以return *this。

calss Person
{
public:
    Person(int age)
    {
        this->age=age;
    }
    Person& Personaddage(Person &p)
    {
        this->age+=p.age;
        return *this;
    }
    int age;
};
int main()
{
    Person p1(18);
    Person p2(20);
    p1.Personaddage(p2).Personaddage(p2).Personaddage(p2);//链式编程思想
}

2.this指针的本质是指针常量。即指针指向不可以修改 Person *const this

也可在成员函数后面加const,让指针指向的值也不可以修改本质为：const Person * const this

void showPerson() const              //常函数,这个const本质是修饰this指针，相当于const Person *const this
{
    m_a=20;          //错误，因为这句话本质为this->m_a=20,在函数后加const,就是说明不可以修改指针指向值
    m_b=100;
}
int m_a;

mutable int m_b;         //特殊变量，即使在常函数中也可以修改

const Person p;          //在对象前加const，变为常对象,常对象不可更改，除非它的某个属性是mutable

p.m_b=90;                //m_b是特殊值，在常对象下也可以修改

p.showPerson();          //常对象只能调用常函数，防止普通函数做修改值的操作

3.空指针也可以调用成员函数

class Person
{
public:
    void func()
    {
        cout<<"!!!"<<endl;
    }
    void func2()
    {
        cout<<age<<endl;  //默认为this->age
    }
    int age;
};
int main()
{
    Person *p=NULL;
    p->func();         //可以
    p->func2();        //错误
}

但不能做和this指针有关的操作，所以应判断

void func2()
{
    if(this==NULL)
        return;
    cout<<age<<endl;
}

4.友元的三种实现：全局函数做友元，类做友元，成员函数做友元

在class的第一行写 friend void test(int a,int b);

friend class goodGay; 告诉编译器goodGay类是本类的好朋友

可以访问本类的私有内容

friend void gooGay::visit();

#include<iostream>
#include<iomanip>
#include<string>
using namespace std;
class Build;
class Person
{
public:
    Build *a;
    Person();
    void visit2();

};
class Build
{
    friend void visit1(Build *a);       //全局函数作友元
    friend class goodgay;                  //类做友元
    friend void Person::visit2();//成员函数作友元
public:
    int sit=2;
private:
    int badroom=3;
};
Person::Person()
{
    a= new Build;
}
void Person::visit2()
{
    cout<<a->badroom;
}
class goodgay
{
public:
    void visit(Build *a);
};
void goodgay::visit(Build *a)
{
    cout<<a->badroom<<endl;
}


void visit1(Build *a)
{
    cout<<a->badroom<<endl;
}

int main()
{
    Person A;
    Build b;
    A.visit2();
    goodgay c;
    c.visit(&b);
    visit1(&b);
    return 0;
}

5.可在类外声明类的成员函数

void goodGay::visit()

{

}

但是要注意提前声明类的一个易错点：

可以声明一个类而不定义它
   class Screen;//declaration of the Screen class
   这个声明,有时候被称为前向声明(forward declaration),在程序中引入了类类型的Screen.在声明之后,定义之前,类Screen是一个不完全类型(incompete type),即已知Screen是一个类型,但不知道包含哪些成员.
   不完全类型只能以有限方式使用,不能定义该类型的对象,不完全类型只能用于定义指向该类型的指针及引用,或者用于声明(而不是定义)使用该类型作为形参类型或返回类型的函数.

6.+运算符重载

成员函数实现+运算符重载

Person operator+(const Person &p)
{                                
    Person temp;
    temp.m_a=this->m_a+p.m_a;
    temp.m_b=this->m_b+p.m_b;
    return temp;
}

全局函数实现+运算符重载

Person operator+(const Person &p1，const Person &p2)
{
    Person temp(0,0);
    temp.m_a=this->p1.m_a+p2.m_a;
    temp.m_b=this->p1.m_b+p2.m_b;
    return temp;
}

注意：运算符重载可以发生函数重载。