07.类和对象
目录介绍
- 7.1 面向对象思想
- 7.1.1 类的含义
- 7.1.2 struct和class区别
- 7.2 类定义和对象
- 7.2.1 类的定义
- 7.2.2 创建对象
- 7.2.3 访问类成员
- 7.2.4 对象指针
- 7.2.5 案例实践
- 7.3 类成员属性
- 7.3.1 成员变量
- 7.3.2 成员函数
- 7.3.3 访问权限
- 7.3.4 成员设置私有
- 7.3.5 案例实践
- 7.4 对象初始化
- 7.4.1 构造和析构函数
- 7.4.2 构造函数分类
- 7.4.3 拷贝构造函数
- 7.4.4 构造调用规则
- 7.4.5 初始化列表
- 7.5 类对象使用
- 7.5.1 类对象作为类成员
- 7.6 对象模型和this指针
- 7.6.1 变量和函数存储
- 7.6.2 this指针概念
- 7.6.3 空指针访问成员函数
- 7.6.4 const修饰成员函数
- 7.7 友元函数和友元类
- 7.7.1 友元的三种实现
- 7.7.2 全局函数做友元
- 7.7.3 类做友元
- 7.7.4 成员函数做友元
7.1 面向对象思想
C++面向对象的三大特性为:==封装、继承、多态==
C++认为==万事万物都皆为对象==,对象上有其属性和行为
例如:
- 人可以作为对象,属性有姓名、年龄、身高、体重...,行为有走、跑、跳、吃饭、唱歌...
- 车也可以作为对象,属性有轮胎、方向盘、车灯...,行为有载人、放音乐、放空调...
- 具有相同性质的==对象==,我们可以抽象称为==类==,人属于人类,车属于车类
7.1.1 类的含义
类和对象是 C++ 的重要特性,它们使得 C++ 成为面向对象的编程语言,可以用来开发中大型项目。
类是创建对象的模板,一个类可以创建多个对象,每个对象都是类类型的一个变量;创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例(Instance),拥有类的成员变量和成员函数。
与结构体一样,类只是一种复杂数据类型的声明,不占用内存空间。而对象是类这种数据类型的一个变量,或者说是通过类这种数据类型创建出来的一份实实在在的数据,所以占用内存空间。
7.1.2 struct和class区别
在C++中 struct和class唯一的区别就在于 默认的访问权限不同
- struct 默认权限为公共
- class 默认权限为私有
class C1 {
int a; //默认是私有权限
};
struct C2 {
int a; //默认是公共权限
};
int main() {
C1 c1;
//c1.a = 10; //错误,访问权限是私有
C2 c2;
c2.a = 10; //正确,访问权限是公共
return 0;
}
7.2 类定义和对象
7.2.1 类的定义
类是用户自定义的类型,如果程序中要用到类,必须提前说明,或者使用已存在的类(别人写好的类、标准库中的类等),C++语法本身并不提供现成的类的名称、结构和内容。
在设计类的时候,属性和行为写在一起,表现事物。
语法: class 类名{ 访问权限: 属性 / 行为 };
一个简单的类的定义:
class Student{
public:
//成员变量
char *name;
int age;
float score;
//成员函数
void say(){
cout<<name<<"的年龄是"<<age<<",成绩是"<<score<<endl;
}
};
类只是一个模板(Template),编译后不占用内存空间,所以在定义类时不能对成员变量进行初始化,因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存,这个时候就可以赋值了。
7.2.2 创建对象
在创建对象时,class 关键字可要可不要,但是出于习惯我们通常会省略掉 class 关键字。除了创建单个对象,还可以创建对象数组:
例如:
void test2_2(){
class Student yc1; //正确
Student yc2; //同样正确
Student yc3[100]; //创建对象数组
}
7.2.3 访问类成员
创建对象以后,可以使用点号.来访问成员变量和成员函数,这和通过结构体变量来访问它的成员类似,如下所示:
class Student{
public:
string name;
int age;
float score;
void say() {
cout << name << "的年龄是" << age << "分数是" << score << endl;
}
};
int main() {
Student stu;
stu.name = "打工充";
stu.age = 30;
stu.score = 100;
stu.say();
return 0;
}
打印结果如下所示:
打工充的年龄是30分数是100
stu 是一个对象,占用内存空间,可以对它的成员变量赋值,也可以读取它的成员变量。
7.2.4 对象指针
C语言中经典的指针在 C++ 中仍然广泛使用,尤其是指向对象的指针,没有它就不能实现某些功能。
创建的对象 stu 在栈上分配内存,需要使用&获取它的地址,例如:
Student stu;
Student *pStu = &stu;
也可以在堆上创建对象,这个时候就需要使用前面讲到的new关键字
Student *pStu = new Student;
在栈上创建出来的对象都有一个名字,比如 stu,使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了,它在堆上分配内存,没有名字,只能得到一个指向它的指针,所以必须使用一个指针变量来接收这个指针,否则以后再也无法找到这个对象了,更没有办法使用它。也就是说,使用 new 在堆上创建出来的对象是匿名的,没法直接使用,必须要用一个指针指向它,再借助指针来访问它的成员变量或成员函数。
栈内存是程序自动管理的,不能使用 delete 删除在栈上创建的对象;堆内存由程序员管理,对象使用完毕后可以通过 delete 删除。在实际开发中,new 和 delete 往往成对出现,以保证及时删除不再使用的对象,防止无用内存堆积。
class Student {
public:
string name;
int age;
float score;
void say() {
cout << name << "的年龄是" << age << ",成绩是" << score << endl;
}
};
int main() {
Student *pStu = new Student;
pStu->name = "打工充";
pStu->age = 30;
pStu->score = 92.5f;
pStu->say();
delete pStu; //删除对象
return 0;
}
7.2.5 案例实践
**示例1:**设计一个圆类,求圆的周长
示例代码:
//圆周率
const double PI = 3.14;
//1、封装的意义
//将属性和行为作为一个整体,用来表现生活中的事物
//封装一个圆类,求圆的周长
//class代表设计一个类,后面跟着的是类名
class Circle
{
public: //访问权限 公共的权限
//属性
int m_r;//半径
//行为
//获取到圆的周长
double calculateZC()
{
//2 * pi * r
//获取圆的周长
return 2 * PI * m_r;
}
};
int main() {
//通过圆类,创建圆的对象
// c1就是一个具体的圆
Circle c1;
c1.m_r = 10; //给圆对象的半径 进行赋值操作
//2 * pi * 10 = = 62.8
cout << "圆的周长为: " << c1.calculateZC() << endl;
system("pause");
return 0;
}
**示例2:**设计一个学生类,属性有姓名和学号,可以给姓名和学号赋值,可以显示学生的姓名和学号
示例2代码:
//学生类
class Student {
public:
void setName(string name) {
m_name = name;
}
void setID(int id) {
m_id = id;
}
void showStudent() {
cout << "name:" << m_name << " ID:" << m_id << endl;
}
public:
string m_name;
int m_id;
};
int main() {
Student stu;
stu.setName("德玛西亚");
stu.setID(250);
stu.showStudent();
system("pause");
return 0;
}
7.3 类成员属性
7.3.1 成员变量
普通成员变量
- 类中的成员变量,也称为实例变量或对象变量。
- 普通成员变量定义在类的内部,通常在类的声明中声明,并在类的定义或实现中进行初始化。
静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明,类外初始化
示例:静态成员变量
class Person{
public:
static int a; //静态成员变量
int c; //普通成员变量
private:
static int b; //静态成员变量也是有访问权限的
};
int Person::a = 10;
int Person::b = 10;
int main() {
//1、通过对象
Person p1;
p1.a = 100;
cout << "p1.a = " << p1.a << endl;
Person p2;
p2.a = 200;
p2.c = 300;
cout << "p1.a = " << p1.a << endl; //共享同一份数据
cout << "p2.a = " << p2.a << endl;
cout << "p1.c = " << p1.c << endl;
cout << "p2.c = " << p2.c << endl;
//2、通过类名
cout << "a = " << Person::a << endl;
//cout << "b = " << Person::b << endl; //私有权限访问不到
}
打印结果如下所示
p1.a = 100
p1.a = 200
p2.a = 200
p1.c = 1
p2.c = 300
a = 200
7.3.2 成员函数
普通成员函数
- 普通成员函数是类中的成员函数,也称为实例方法或对象方法。
- 普通成员函数定义在类的内部,通常在类的声明中声明,并在类的定义或实现中进行定义。
静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量
示例:静态成员函数
class Person {
public:
static int a;
int b;
static void func() {
cout << "func调用,可以直接用类调用,也可以用对象调用" << endl;
a = 100;
//b = 100; //错误,不可以访问非静态成员变量
}
void func3() {
cout << "普通func调用,必须用对象调用" << endl;
}
private:
//静态成员函数也是有访问权限的
static void func2() {
cout << "func2调用" << endl;
}
};
int Person::a = 10;
int main() {
//1、通过对象
Person p1;
p1.func();
p1.func3();
//2、通过类名
Person::func();
//Person::func2(); //私有权限访问不到
return 0;
}
7.3.3 访问权限
类在设计时,可以把属性和行为放在不同的权限下,加以控制。
访问权限有三种:
- public 公共权限
- protected 保护权限
- private 私有权限
示例:
//三种权限
//公共权限 public 类内可以访问 类外可以访问
//保护权限 protected 类内可以访问 类外不可以访问
//私有权限 private 类内可以访问 类外不可以访问
class Person {
//公共权限
public:
string name;
//保护权限
protected:
string car;
//私有权限
private:
int password;
public:
void func() {
name = "打工充";
car = "雅阁";
password = 123456;
}
};
int main() {
Person p;
p.name = "逗比";
//p.car = "奔驰"; //保护权限类外访问不到
//p.password = 123; //私有权限类外访问不到
return 0;
}
7.3.4 成员设置私有
数据抽象是指,只向外界提供关键信息,并隐藏其后台的实现细节,即只表现必要的信息而不呈现细节。
- **优点1:**将所有成员属性设置为私有,可以自己控制读写权限
- **优点2:**对于写权限,我们可以检测数据的有效性
数据抽象是一种面向对象编程的概念,用于隐藏类的内部实现细节,只暴露必要的接口给外部使用。通过数据抽象,可以将类的实现细节与接口分离,提高代码的可维护性和安全性。
示例:
class Person {
private:
string name; //可读可写 姓名
int age; //只读 年龄
string lover; //只写 情人
public:
string getName() {
return name;
}
void setName(string name) {
Person::name = name;
}
int getAge(){
return age;
}
void setAge(int age) {
Person::age = age;
}
void setLover(string lover) {
this->lover = lover;
}
};
int main() {
Person p;
//姓名设置
p.setName("张三");
cout << "姓名: " << p.getName() << endl;
//年龄设置
p.setAge(50);
cout << "年龄: " << p.getAge() << endl;
//情人设置
p.setLover("逗比");
//cout << "情人: " << p.lover << endl; //只写属性,不可以读取
return 0;
}
7.3.5 案例实践
练习案例1:设计立方体类
设计立方体类(Cube),求出立方体的面积和体积,分别用全局函数和成员函数判断两个立方体是否相等。
练习案例2:点和圆的关系
设计一个圆形类(Circle),和一个点类(Point),计算点和圆的关系。
7.4 对象初始化
7.4.1 构造和析构函数
对象的初始化和清理也是两个非常重要的安全问题
- 一个对象或者变量没有初始状态,对其使用后果是未知
- 同样的使用完一个对象或变量,没有及时清理,也会造成一定的安全问题
c++利用了构造函数和析构函数解决上述问题,这两个函数将会被编译器自动调用,完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情,因此如果我们不提供构造和析构,编译器会提供
编译器提供的构造函数和析构函数是空实现。
- 构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无须手动调用。
- 析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作。
构造函数语法:类名(){}
- 构造函数,没有返回值也不写void
- 函数名称与类名相同
- 构造函数可以有参数,因此可以发生重载
- 程序在调用对象时候会自动调用构造,无须手动调用,而且只会调用一次
析构函数语法: ~类名(){}
- 析构函数,没有返回值也不写void
- 函数名称与类名相同,在名称前加上符号 ~
- 析构函数不可以有参数,因此不可以发生重载
- 程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用一次
class Person {
public:
Person(){
cout << "Person的构造函数调用" << endl;
}
~Person() {
cout << "Person的析构函数调用" << endl;
}
};
int main() {
Person p;
return 0;
}
7.4.2 构造函数分类
两种分类方式:
- 按参数分为: 有参构造和无参构造
- 按类型分为: 普通构造和拷贝构造
三种调用方式:
- 括号法
- 显示法
- 隐式转换法
示例:
class Person {
public:
int age;
public:
//无参(默认)构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p) {
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
}
};
//调用无参构造函数
void test01() {
Person p; //调用无参构造函数
}
//调用有参的构造函数
void test02() {
//1.括号法,常用
Person p1(10);
//注意1:调用无参构造函数不能加括号,如果加了编译器认为这是一个函数声明
//Person p2();
//2.显式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后,马上析构
//3隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2:不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);
}
int main() {
test01();
test02();
return 0;
}
7.4.3 拷贝构造函数
C++中拷贝构造函数调用时机通常有三种情况
- 使用一个已经创建完毕的对象来初始化一个新对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
示例:
class Person {
public:
int age;
public:
Person() {
cout << "无参构造函数!" << endl;
age = 0;
}
Person(int age) {
cout << "有参构造函数!" << endl;
age = age;
}
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
age = p.age;
}
//析构函数在释放内存之前调用
~Person() {
cout << "析构函数!" << endl;
}
};
//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test1() {
Person man(80);//p对象已经创建完毕
Person newman1(man); //调用拷贝构造函数
Person newman2 = man; //拷贝构造
Person newman3;
newman3 = man;//不是调用拷贝构造函数,赋值操作
}
//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p) {
cout << "给函数参数传值 " << &p << endl;
}
void test2() {
Person p; //无参构造函数
doWork(p);
}
Person doWork2() {
Person p1;
cout << (int *)&p1 << endl;
return p1;
}
//3. 以值方式返回局部对象
void test3() {
Person p = doWork2();
cout << (int *)&p << endl;
}
int main() {
test1();
test2();
test3();
return 0;
}
7.4.4 构造调用规则
默认情况下,c++编译器至少给一个类添加3个函数
- 默认构造函数(无参,函数体为空)
- 默认析构函数(无参,函数体为空)
- 默认拷贝构造函数,对属性进行值拷贝
构造函数调用规则如下:
- 如果用户定义有参构造函数,c++不在提供默认无参构造,但是会提供默认拷贝构造
- 如果用户定义拷贝构造函数,c++不会再提供其他构造函数
示例:
class Person {
public:
int age;
public:
Person() {
cout << "无参构造函数!" << endl;
}
Person(int a) {
age = a;
cout << "有参构造函数!" << a << endl;
}
Person (Person& p) {
age = p.age;
cout << "拷贝构造函数!" << &p << endl;
}
~Person() {
cout << "析构函数" << endl;
}
};
void test1() {
Person p1(10);
//如果不写拷贝构造,编译器会自动添加拷贝构造,并且做浅拷贝操作
Person p2(p1);
cout << "p2的年龄为: " << p2.age << endl;
}
void test2() {
//如果用户提供有参构造,编译器不会提供默认构造,会提供拷贝构造
Person p1; //此时如果用户自己没有提供默认构造,会出错
Person p2(10); //用户提供的有参
Person p3(p2); //此时如果用户没有提供拷贝构造,编译器会提供
//如果用户提供拷贝构造,编译器不会提供其他构造函数
Person p4; //此时如果用户自己没有提供默认构造,会出错
Person p5(10); //此时如果用户自己没有提供有参,会出错
Person p6(p5); //用户自己提供拷贝构造
}
int main() {
test1();
test2();
return 0;
}
7.4.5 初始化列表
作用:
C++提供了初始化列表语法,用来初始化属性
语法:构造函数():属性1(值1),属性2(值2)... {}
示例:
class Person {
private:
int a;
int b;
int c;
public:
// Person(int a , int b , int c) {
// //this.a = a;
// this->a = a;
// this->b = b;
// this->c = c;
// }
Person(int a , int b , int c) : a(a), b(b) , c(c) {
cout << "有参构造函数!" << endl;
}
void printPerson() {
cout << "a:" << a << endl;
cout << "b:" << b << endl;
cout << "b:" << c << endl;
}
};
int main() {
Person p(1,2,3);
p.printPerson();
return 0;
}
7.5 类对象使用
7.5.1 类对象作为类成员
C++类中的成员可以是另一个类的对象,我们称该成员为——>对象成员
例如:B类中有对象A作为成员,A为对象成员
class A {};
class B {
A a;
};
思考:那么当创建B对象时,A与B的构造和析构的顺序是谁先谁后?示例:
#include "iostream"
using namespace std;
class Phone {
public:
string phoneName;
public:
Phone(string name) {
cout << "Phone构造" << endl;
phoneName = name;
}
~Phone() {
cout << "Phone析构" << endl;
}
};
class Person{
public:
string name;
Phone phone;
public:
Person(string userName , string phoneName): name(userName), phone(phoneName){
cout << "Person构造" << endl;
}
~Person(){
cout << "Person析构" << endl;
}
void playGame(){
cout << name << " 使用" << phone.phoneName << " 牌手机! " << endl;
}
};
int main() {
//当类中成员是其他类对象时,我们称该成员为 对象成员
//构造的顺序是 :先调用对象成员的构造,再调用本类构造
//析构顺序与构造相反
Person p("打工充" , "苹果X");
p.playGame();
return 0;
}
打印结果如下所示:
Phone构造
Person构造
打工充 使用苹果X 牌手机!
Person析构
Phone析构
7.6 对象模型和this指针
7.6.1 变量和函数存储
在C++中,类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上
class Person {
public:
//非静态成员变量占对象空间
int a;
//静态成员变量不占对象空间
static int b;
public:
Person() {
a = 0;
}
//函数也不占对象空间,所有函数共享一个函数实例
void func() {
cout << "a:" << this->a << endl;
}
//静态成员函数也不占对象空间
static void sfunc() {
cout << "静态成员函数也不占对象空间" << endl;
}
};
int main() {
cout << sizeof(Person) << endl; //4
Person p;
cout << sizeof(p) << endl; //4
Person *p2 = new Person();
cout << sizeof(&p2) << endl; //8
cout << sizeof(int) << endl; //4
return 0;
}
7.6.2 this指针概念
我们知道在C++中成员变量和成员函数是分开存储的。每一个非静态成员函数只会诞生一份函数实例,也就是说多个同类型的对象会共用一块代码!
那么问题是:这一块代码是如何区分那个对象调用自己的呢?
c++通过提供特殊的对象指针,this指针,解决上述问题。this指针指向被调用的成员函数所属的对象
this指针是隐含每一个非静态成员函数内的一种指针。this指针不需要定义,直接使用即可!
this指针的用途:
- 当形参和成员变量同名时,可用this指针来区分
- 在类的非静态成员函数中返回对象本身,可使用return *this
class Person {
public:
int age;
Person(int age) {
//当形参和成员变量同名时,可用this指针来区分
this->age = age;
}
Person& addPerson(Person person) {
this->age += person.age;
//返回对象本身
return *this;
}
};
int main() {
Person p1(10);
cout << "p1.age = " << p1.age << endl; //p1.age = 10
Person p2(20);
p2.addPerson(p1).addPerson(p1);
cout << "p2.age = " << p2.age << endl; //p2.age = 40
return 0;
}
7.6.3 空指针访问成员函数
C++中空指针也是可以调用成员函数的,但是也要注意有没有用到this指针
如果用到this指针,需要加以判断保证代码的健壮性
示例:
//空指针访问成员函数
class Person {
public:
int age;
public:
void showClassName() {
cout << "我是Person类!" << endl;
}
void showPerson() {
cout << this->age << endl;
}
};
void test() {
Person *p = NULL;
p->showClassName(); //空指针,可以调用成员函数
p->showPerson(); //但是如果成员函数中用到了this指针,就不可以了
}
int main() {
test();
return 0;
}
7.6.4 const修饰成员函数
常函数:
- 成员函数后加const后我们称为这个函数为常函数
- 常函数内不可以修改成员属性
- 成员属性声明时加关键字mutable后,在常函数中依然可以修改
常对象:
- 声明对象前加const称该对象为常对象
- 常对象只能调用常函数
示例:
//const修饰成员函数
class Person {
public:
int a;
mutable int b;//可修改 可变的
public:
Person() {
a = 0;
b = 0;
}
//this指针的本质是一个指针常量,指针的指向不可修改
//如果想让指针指向的值也不可以修改,需要声明常函数
void const showPerson() {
//const Type* const pointer;
//this = NULL; //不能修改指针的指向 Person* const this;
this->a = 100; //但是this指针指向的对象的数据是可以修改的
//const修饰成员函数,表示指针指向的内存空间的数据不能修改,除了mutable修饰的变量
this->b = 100;
}
void myFunc() const {
//a = 10000;
//this->a = 10000;
}
};
//const修饰对象 常对象
void test() {
const Person person; //常量对象
//person.a = 100; //常对象不能修改成员变量的值,但是可以访问
cout << person.a << endl;
person.b = 200; //但是常对象可以修改mutable修饰成员变量
cout << person.b << endl;
//常对象访问成员函数
person.myFunc(); //常对象不能调用const的函数
}
int main() {
test();
return 0;
}
7.7 友元函数和友元类
生活中你的家有客厅(Public),有你的卧室(Private)。
客厅所有来的客人都可以进去,但是你的卧室是私有的,也就是说只有你能进去。但是呢,你也可以允许你的好闺蜜好基友进去。
在程序里,有些私有属性 也想让类外特殊的一些函数或者类进行访问,就需要用到友元的技术
友元的目的:就是让一个函数或者类,可以访问另一个类中私有成员。
友元的关键字为 ==friend==
7.7.1 友元的三种实现
友元的三种实现
- 全局函数做友元
- 类做友元
- 成员函数做友元
7.7.2 全局函数做友元
//友元:目的就是让一个函数或者类,可以访问另一个类中私有成员。
class Building {
//告诉编译器 goodGay全局函数 是 Building类的好朋友,可以访问类中的私有内容
friend void goodGay(Building * building);
public:
Building() {
this->sittingRoom = "客厅";
this->bedRoom = "卧室";
}
public:
string sittingRoom;//客厅
private:
string bedRoom; //卧室
};
//全局函数做友元
void goodGay(Building * building){
cout << "好基友正在访问: " << building->sittingRoom << endl;
cout << "好基友正在访问: " << building->bedRoom << endl; //可以访问类中私有函数
}
int main() {
Building b;
goodGay(&b);
return 0;
}
7.7.3 类做友元
class Building;
class goodGay{
public:
goodGay();
void visit();
private:
Building *building;
};
class Building{
//告诉编译器 goodGay类是Building类的好朋友,可以访问到Building类中私有内容
friend class goodGay;
public:
Building();
public:
string sittingRoom;//客厅
private:
string bedRoom; //卧室
};
Building::Building() {
this->sittingRoom = "客厅";
this->bedRoom = "卧室";
}
goodGay::goodGay() {
building = new Building;
}
void goodGay::visit(){
cout << "好基友正在访问" << building->sittingRoom << endl;
cout << "好基友正在访问" << building->bedRoom << endl;
}
int main() {
goodGay gg;
gg.visit();
return 0;
}
7.7.4 成员函数做友元
class Building;
class goodGay {
public:
goodGay();
void visit(); //只让visit函数作为Building的好朋友,可以发访问Building中私有内容
void visit2();
private:
Building *building;
};
class Building {
//告诉编译器 goodGay类中的visit成员函数 是Building好朋友,可以访问私有内容
friend void goodGay::visit();
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom;//卧室
};
Building::Building() {
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
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;
//cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void test01() {
goodGay gg;
gg.visit();
}
int main() {
test01();
return 0;
}