原创 DeRoy 编程学习基地 2020-03-08
点击蓝字 关注我们
this指针和const
目录
this指针
this 是 C++ 中的一个关键字，也是一个 const 指针，不可以修改指向。this指针指向当前对象，通过它可以访问当前对象的所有成员。
成员函数最终会被编译成与对象无关的普通函数。除了成员变量，丢失所有信息
相同类型的不同对象共享同一份成员函数代码。因此，编译时在成员函数中添加一个隐藏参数，将当前调用对象首地址传入，用来关联成员函数和成员变量，这就是this指针
C++关键字，const指针，在类的成员函数，构造函数和析构函数中，对所有成员的访问，都是通过this指针
#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
const关键字在C语言中的应用
常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被修改的
const的普通用法
int const index = 10; //const修饰的变量不能被修改，且必须初始化
const int index = 10;
初始化和赋值
/****初始化****/
int temp = 10; //定义变量的同时初始化
/****赋值****/
int temp;
temp = 10; //给变量赋值
const修饰指针
常量指针
const修饰 *p
int const *p; //const修饰 *p
const int* p; //常量指针 不能通过指针修改p指向的内容(不能修改指向的内容)
指针常量
const 修饰 p
int temp =10;
int* const p = &temp; //指针常量 不能修改p的指向 且必须初始化
const用于函数的形参
void fun(const int *p);
const关键字在C++中的应用
const修饰成员变量
class TEST
{
const int m_tmp; //常成员变量
public:
TEST() :m_tmp(10) //相当于 const int m_a = 10;
{
//m_a = 10; //赋值相当于修改值 常变量不能修改
}
};
const修饰成员函数
类成员函数形参表之后，函数体之前加上const,这样的函数成为常函数
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指针，上面的代码在编译器看来是下面这个样子的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修饰成员函数构成重载？
是的没错，构成重载，原因是形参不同，构成重载函数原型相同的成员函数，常版本和非常版本构成重载
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成员函数的调用问题
常成员函数不能调用非常成员函数，非常成员函数可以调用常成员函数,如果有重载版本的非常函数，优先调用非常函数
#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
常成员函数不能调用非常成员函数的原因：
非常成员函数可以调用常成员函数的原因：
/***********非常成员函数***********/
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;
}
非常成员函数可以调用常成员函数,如果有重载版本的非常函数，优先调用非常函数
const修饰对象
被const修饰的对象 意味着对象中的成员数据不可以改内容
常对象不能调用非常成员函数，只能调用常函数
非常对象(普通对象)可以调用常成员函数如果有重载版本的非常函数，优先非常
关键字 mutable
在C++里面有个在const常成员函数中开VIP的存在，这就是mutablemutable int m_money;//mutable修饰的变量可以在常成员函数中修改
