前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >this指针和const

this指针和const

作者头像
DeROy
发布2020-05-13 14:51:21
1.5K0
发布2020-05-13 14:51:21
举报
文章被收录于专栏:编程学习基地
this指针和const

目录

this指针

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

  • 成员函数最终会被编译成与对象无关的普通函数。除了成员变量,丢失所有信息
  • 相同类型的不同对象共享同一份成员函数代码。因此,编译时在成员函数中添加一个隐藏参数,将当前调用对象首地址传入,用来关联成员函数和成员变量,这就是this指针
  • C++关键字,const指针,在类的成员函数,构造函数和析构函数中,对所有成员的访问,都是通过this指针
代码语言:javascript
复制
#include<iostream>
#include<string>
using namespace std;
class GirlFriend
{
    int m_age;
    string m_name;
public:
    GirlFriend(int age,string name)
    {
        m_age = age;    //等价 this->m_age =age;
        m_name = name;  //等价 this->m_name =name;
        introduce();    //等价 this->introduce();
        cout << this << endl;   //打印this的地址
    }
    void introduce()
    {
        cout << "My name is:" << m_name << ",My age is:" << m_age << endl;
    }
    //introduce函数在编译器看来是这个样子
    //void introduce(GirlFriend* const this)
    //{
    //  cout << "My name is:" << this->m_name << ",My age is:" << this->m_age << endl;
    //}
};
int main()
{
    GirlFriend girl(18,"女朋友");
    cout << &girl<< endl;   //打印girl对象的地址
    cin.get();
    return 0;
}
//打印结果
My name is:女朋友,My age is:18
00CFF8F4
00CFF8F4

在上述代码运行结果中可以看出this指针指向的就是对象的地址

const关键字在C语言中的应用

常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被修改的

const的普通用法
代码语言:javascript
复制
int const index = 10;    //const修饰的变量不能被修改,且必须初始化
const int index = 10;
初始化和赋值
代码语言:javascript
复制
/****初始化****/
int temp = 10;    //定义变量的同时初始化
/****赋值****/
int temp;
temp = 10;        //给变量赋值

这个在C语言的 基本数据类型 里面有说过

const修饰指针
常量指针

const修饰 *p

代码语言:javascript
复制
int const *p;    //const修饰 *p
const int* p;    //常量指针 不能通过指针修改p指向的内容(不能修改指向的内容)
指针常量

const 修饰 p

代码语言:javascript
复制
int temp =10;
int* const p = &temp;  //指针常量 不能修改p的指向 且必须初始化
const用于函数的形参
代码语言:javascript
复制
void fun(const int *p);

const用于形参时说明了形参在函数内部不会被改变

const关键字在C++中的应用

const修饰成员变量
代码语言:javascript
复制
class TEST
{
    const int m_tmp;  //常成员变量
public:
    TEST() :m_tmp(10)  //相当于 const int m_a = 10;
    {
        //m_a = 10; //赋值相当于修改值   常变量不能修改
    }
};

常成员变量必须使用初始化列表初始化

const修饰成员函数

类成员函数形参表之后,函数体之前加上const,这样的函数成为常函数

代码语言:javascript
复制
class TEST
{
    int m_money;  
public:
    TEST()  {
         m_money=1000;
    }
    void show() const
    {
        //常成员函数不能修改变量的值,下面是错误示范
        //cout << "资产:" << m_money++ << endl;
        cout << "资产:" << m_money << endl;    //常函数不能修改变量的值
    }
};
const修饰的是什么?

在C语言里面const是用来修饰变量的,那么在C++里面const是用来修饰什么,在C++lconst实际修饰的是this指针,上面的代码在编译器看来是下面这个样子的

代码语言:javascript
复制
class TEST
{
    int m_money;
public:
    TEST(/*TEST* const this*/){
        this->m_money = 100;
    }
    void show(/*const TEST* const this*/) const //修饰this
    {
        cout << "资产:" << this->m_money << endl;
    }
};
const修饰成员函数构成重载?

是的没错,构成重载,原因是形参不同,构成重载

函数原型相同的成员函数,常版本和非常版本构成重载

代码语言:javascript
复制
class TEST
{
    int m_money;  
public:
    TEST()  {
         m_money=1000;
    }
    void show(/*TEST* const this*/) //重载
    {
        cout<< "资产:" << m_money++ << endl;
    }
    void show(/*const TEST* const this*/) const
    {
        cout << "const 资产:" << m_money << endl;
    }
};
const成员函数的调用问题

常成员函数不能调用非常成员函数,非常成员函数可以调用常成员函数,如果有重载版本的非常函数,优先调用非常函数

代码语言:javascript
复制
#include<iostream>
using namespace std;
class TEST
{
    int m_money;
public:
    TEST() {
        m_money = 1000;
    }
    /***非常成员函数可以调用常成员函数,如果有重载版本的非常函数,优先调用非常函数***/
    void show(/*TEST* const this*/)
    {
        cout << "资产:" << m_money++ << endl;
        fun();
        foo();
    }
    /***********常成员函数不能调用非常成员函数***********/
    void show(/*const TEST* const this*/) const
    {
        cout << "const 资产:" << m_money << endl;
        //fun(this);    //错误原因不能将“this”指针从“const TEST”转换为“TEST &”   
        foo();
    }
    void fun(/*TEST* const this*/)
    {
        cout << "fun" << endl;
    }
    void foo()  const
    {
        cout << "const:fun" << endl;
    }
};
int main()
{
    TEST test;
    test.show();
    return 0;
}
打印结果:
资产:1000
fun
const:fun
  1. 常成员函数不能调用非常成员函数的原因:

是因为this指针的修饰符不同,在const成员函数里面的this指针被const修饰,在const成员函数里面调用非const成员函数时,相当于将const修饰的this指针传给非const成员函数。

  1. 非常成员函数可以调用常成员函数的原因:

这个涉及到编译器的原理:提高权限不安全,缩小权限是安全的

这个权限怎么理解:

代码语言:javascript
复制
/***********非常成员函数***********/
void show()
{    
    //this可读写
    cout << "资产:" << m_money++ << endl;
    fun();  //调用非常成员函数 this可读写
    foo();  //调用常成员函数 this可读
}
/***********常成员函数***********/
void show() const
{
    //this可读
    cout << "const 资产:" << m_money << endl;
    //fun(this);    //调用非常成员函数 this可读写  
    foo();          //调用常成员函数 this可读
}
void fun()
{
    cout << "fun" << endl;
}
void foo()    const
{
    cout << "const:fun" << endl;
}

this可读写代表可以访问和修改this里面的成员变量的值

this可读代表可以访问this里面的成员变量的值

  1. 非常成员函数可以调用常成员函数,如果有重载版本的非常函数,优先调用非常函数

这个从权限来讲,编译器坚定不移的执行了不背锅精神,编译器认为缩小权限是安全的,扩大权限是危险的,编译器会优先选择最合适的,最合适的就是既不缩小权限,又不扩大权限

const修饰对象

被const修饰的对象 意味着对象中的成员数据不可以改内容

  • 常对象不能调用非常成员函数,只能调用常函数
  • 非常对象(普通对象)可以调用常成员函数如果有重载版本的非常函数,优先非常

原理和const修饰成员函数的原理是一样的,理解了const修饰成员函数 这一部分,那么const修饰对象也很容易理解

关键字 mutable

在C++里面有个在const常成员函数中开VIP的存在,这就是mutable

代码语言:javascript
复制
mutable int m_money;//mutable修饰的变量可以在常成员函数中修改

思维导图:

来源xmind

End

本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2020-03-08,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 编程学习基地 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • this指针
  • const关键字在C语言中的应用
    • const的普通用法
      • 初始化和赋值
    • const修饰指针
      • 常量指针
      • 指针常量
    • const用于函数的形参
    • const关键字在C++中的应用
      • const修饰成员变量
        • const修饰成员函数
          • const修饰的是什么?
          • const修饰成员函数构成重载?
          • const成员函数的调用问题
        • const修饰对象
          • 关键字 mutable
          领券
          问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档