C++黑马程序员——P115-117. this指针；空指针访问成员函数；const修饰成员函数

• P115. 类和对象——对象特性——this指针的用途
• P116. 类和对象——对象特性——空指针访问成员函数
• P117. 类和对象——对象特性——const修饰成员函数
• P115

　　 

//this 指针用途
//1.解决名称冲突
//2.返回对象本身用*this

class Person
{
public:
    Person(int age)
    {
        age = age;　　//虽然我们的想法是：把传入的age赋值给类的age，但是编译器会认为这里的3个age都是同一份东西，和类的age没有关系
    }
    int age;
};

void test01()
{
    Person p1(18);
    cout << "p1的年龄为：" << p1.age << endl;
}

int main()
{
    test01();

    return 0;
}

运行结果：

　　

修改：

class Person
{
public:
    Person(int age)
    {
        //this指针指向 被调用的成员函数 所属的对象　　后面p1调用了Person构造函数Person(int age)(即被调用的成员函数)，此成员函数所属的对象是p1，所以后面的this指针指向p1
        this->age = age;
    }
    int age;
};

代码其他部分不变；

运行结果：

　　

 

2. 返回对象本身用*this

class Person
{
public:
    Person(int age)
    {
        //this指针指向 被调用的成员函数 所属的对象
        this->age = age;
    }
    Person& PersonAddAge(Person& p)        //为什么返回值是 Person& 不是 Person
        //如果返回的是 Person，它会创建一个新的对象，不是原来的
        //如果返回的是 Person&，不会创建新的对象，会一直返回调用的对象
    {
        this->age += p.age;
        return *this;
    }
    int age;
};

void test02()
{
    Person p1(10);
    Person p2(10);
    //链式编程思想
    p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
    cout << "p2的年龄为：" << p2.age << endl;
}

int main()
{
    test02();
    return 0;
}

运行结果：

　　

如果返回的是 Person 而不是 Person&

Person PersonAddAge(Person& p)        //为什么返回值是 Person& 不是 Person
        //如果返回的是 Person，它会创建一个新的对象，不是原来的
        //如果返回的是 Person&，不会创建新的对象，会一直返回调用的对象
    {
        this->age += p.age;
        return *this;
    }

运行结果：

　　

为什么是20不是40：

值方式返回局部对象，会调用拷贝构造函数（P108）

p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1) ，只有第一次的p2.PersonAddAge(p1)是作用于p2的，第一次调用完.PersonAddAge(p1)的函数后返回的不是p2而是p2的一个拷贝，所有后面两次PersonAddAge(p1)又分别是在两个不同的p2的拷贝上作用的，与实际的p2没有关系，所以p2.age=20;

 

• P116. 空指针访问成员函数

//空指针调用成员函数
class Person
{
public:
    void ShowClassName()
    {
        cout << "this is Person class" << endl;
    }

    void ShowPersonAge()
    {
        //为了提高代码的健壮性:
        if (this == NULL)
        {
            return;
        }
        cout << "age = " << m_age << endl;
    }

    int m_age;
};

void test01()
{
    Person* p = NULL;
    p->ShowClassName();    //没有问题
    p->ShowPersonAge();
    //报错，原因是传入的指针为NULL；cout << "age = " << m_age << endl 等价于 cout << "age = " << this->m_age << endl
    //ShowPersonAge()函数加了if语句判断this是否为空之后，就不会报错了
}

int main()
{
    test01();
    return 0;
}

运行结果：

　　

 

• P117. const修饰成员函数

　　

常对象也可以调用加关键字mutable的成员

常函数：

class Person
{
public:
    //this指针的本质是指针常量，指针的指向是不可以修改的(此时指针指向的值是可以修改的)
    //Person* const this
    //常函数
    void ShowPerson()const    //函数后加了const,this指针指向的值也不能修改了，此函数中的this指针本质上变为 const Person* const this
        //成员函数后面加const，修饰的是this指针，让this指针指向的值不可以修改
    {
        //m_A = 100;//报错; m_A 与 this->m_A 相同
        this->m_B = 100;
    }

    int m_A;
    mutable int m_B;　　//加了mutable后，常函数中可以修改此成员属性；常函数 和 常对象 都可以修改m_B的值
};

 常对象：

class Person
{
public:
    ...
    //普通成员函数
    void func1()
    {

    }

    int m_A;
    mutable int m_B;    //在 常函数 和 常对象 中都可以修改
};

void test02()
{
        //常对象
    const Person p2;//在对象前加const，变为常对象
    //p2.m_A = 100;    //报错，常对象不能修改普通的成员变量
    p2.m_B = 200;
    //常对象只能调用常函数
    p2.ShowPerson();
    //p2.func1();    //报错，func1不是常函数
}

(〃＞＿＜;〃)(〃＞＿＜;〃)(〃＞＿＜;〃)