C++thit指针
- C++中的成员变量和成员函数是分开存储的,每一个非静态成员函数只会诞生一份函数实例, 也就是说多个同类型的对象会共用一块代码
- C++通过提供特殊的对象指针,指针,解决上述问题,this指针是隐含在每一个非静态成员函数内的一种指针
- this指针的用途:
1.当形参和成员变量同名是,可以用this指针来区分2.在类的非静态函数中返回对象本身,可使用return *this
#include<iostream>
#include<string>
using namespace std;
//成员函数和成员变量分开存储
class Person
{
public:
Person(int age)
{
//this指针指向的是被调用的成员函数
this->age = age;
}
Person& PersonAddAge(Person &p)
{
this->age += p.age;
//this指向p2的指针,而*this指向的就是p2这个对象本体
return *this;
}
int age;
};
void test01()
{
Person p1(18);
cout << "P1的年龄为: " << p1.age << endl;
}
void test02()
{
Person p1(10), p2(10);
//链式编程思想
p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
cout << "p2的年龄: " << p2.age << endl;
}
int main()
{
test02();
system("pause");
return 0;
}
空指针调用成员函数
- C++中空指针也就是调用成员函数,但是也要注意有没有用到this指针。如果用到this指针,需要加以判断保证代码的健壮性
#include<iostream>
using namespace std;
class Person
{
public:
void showClassName()
{
cout << "this is Person class" << endl;
}
void showPersonAge()
{
//报错原因是传入的指针是为NULL
//解决方法
if (this == NULL)
{
return;
}
cout << "age = " << m_Age << endl;
}
int m_Age;
};
void test01()
{
Person * p = NULL;
p->showClassName();
p->showPersonAge();
}
int main()
{
test01();
system("pause");
return 0;
}
const修饰成员函数
常函数:
- 成员函数后加const后称之为常函数
- 常函数内不可以修改成员属性
- 成员属性声明时加关键字mutable后,在常函数中依然可以修改
常对象:
- 声明对象前加const称该对象为常对象
- 常对象只能调用常函数
//this指针的本质是指针常量 指针的指向是不可以修改的
//const Person * const this;
//在成员函数后面加const,修饰的是this指向, 让指针指向的值也是不可以修改的
class Person
{
public:
//this指针的本质是指针常量 指针的指向是不可以修改的
//const Person * const this;
//在成员函数后面加const,修饰的是this指向, 让指针指向的值也是不可以修改的
void showPerson() const
{
this->m_B = 100;
//this->m_Age = 100;
//this = NULL;//this指针不可以修改指向
}
int m_Age;
mutable int m_B; //特殊变量,即是在常函数中,也可以修改这个值
};
//特殊变量,即是在常函数中,也可以修改这个值
class Person
{
public:
//this指针的本质是指针常量 指针的指向是不可以修改的
//const Person * const this;
//在成员函数后面加const,修饰的是this指向, 让指针指向的值也是不可以修改的
void showPerson() const
{
this->m_B = 100;
//this->m_Age = 100;
//this = NULL;//this指针不可以修改指向
}
int m_Age;
mutable int m_B; //特殊变量,即是在常函数中,也可以修改这个值
};
- 常对象中,特殊常变量可以修改
class Person
{
public:
//this指针的本质是指针常量 指针的指向是不可以修改的
//const Person * const this;
//在成员函数后面加const,修饰的是this指向, 让指针指向的值也是不可以修改的
void showPerson() const
{
this->m_B = 100;
//this->m_Age = 100;
//this = NULL;//this指针不可以修改指向
}
int m_Age;
mutable int m_B; //特殊变量,即是在常函数中,也可以修改这个值
};
- 常对象只能调用常函数,常对象不可以调用普通成员函数,因为普通成员函数可以修改属性
class Person
{
public:
//this指针的本质是指针常量 指针的指向是不可以修改的
//const Person * const this;
//在成员函数后面加const,修饰的是this指向, 让指针指向的值也是不可以修改的
void showPerson() const
{
this->m_B = 100;
//this->m_Age = 100;
//this = NULL;//this指针不可以修改指向
}
void func()
{
}
int m_Age;
mutable int m_B; //特殊变量,即是在常函数中,也可以修改这个值
};
友元
- 全局函数做友元,访问函数私有成员
#include<iostream>
#include<string>
using namespace std;
class Building
{
//goodGay全局函数是Building好朋友,可以访问Building中的私有成员
friend void googGay(Building * building);
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
string m_SittingRoom;//客厅
private:
string m_BedRoom;//卧室
};
//全局函数
void googGay(Building * building)
{
cout << "这是好基友的全局函数 正在访问:" << building->m_SittingRoom << endl;
cout << "这是好基友的全局函数 正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
Building b1;
googGay(&b1);
}
int main()
{
test01();
system("pause");
return 0;
}
- 类做友元
#include<iostream>
#include<string>
using namespace std;
class Building
{
//类做友元,才能访问私有成员*****************
friend class GoodGay;
public:
Building();
string m_SittingRoom;//客厅
private:
string m_BedRoom;//卧室
};
class GoodGay
{
public:
GoodGay();
void visit();//参观参数 访问Building中的属性
Building * building;
};
void test01()
{
GoodGay G1;
G1.visit();
}
int main()
{
test01();
system("pause");
return 0;
}
GoodGay::GoodGay()
{
//创建建筑物对象
building = new Building;
}
void GoodGay::visit()
{
cout << "好基友类长在访问: " << building->m_SittingRoom << endl;
cout << "好基友类长在访问: " << building->m_BedRoom << endl;
}
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
- 类中的成员做友元
#include<iostream>
#include<string>
using namespace std;
class Building;
class GoodGay
{
public:
GoodGay();
void visit();//参观参数 访问Building中的属性
void visit2();//不可以访问Building中的私有成员
Building * building;
};
class Building
{
//告诉编译器GoodGay类下的visit成员函数作为本类的好朋友,可以访问私有成员
friend void GoodGay::visit();
public:
Building();
string m_SittingRoom;//客厅
private:
string m_BedRoom;//卧室
};
void test01()
{
GoodGay G1;
G1.visit();
G1.visit2();
}
int main()
{
test01();
system("pause");
return 0;
}
GoodGay::GoodGay()
{
//创建建筑物对象
building = new Building;
}
void GoodGay::visit()
{
cout << "好基友类长在访问: " << building->m_SittingRoom << endl;
cout << "好基友类长在访问: " << building->m_BedRoom << endl;
}
void GoodGay::visit2()
{
cout << "好基友类长在访问: " << building->m_SittingRoom << endl;
}
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}