【C++ 语言】面向对象 ( 成员函数 | 常量函数 | 友元函数 | 友元类 | 单例类 )
成员函数
此处继续上一篇博客继续向后讲解C++面向对象
类成员方法 , 除了定义构造方法与析构方法之外 , 还可以定义普通的成员方法 , 如设置 int age
变量的方法 , 这里声明一个成员方法 , 传入参数 int age
, 给成员变量 int age
赋值 ;
使用共有函数访问私有成员变量 , 在类中私有的成员变量时不允许从外部直接访问的 , 需要通过共有函数来访问 , 在共有函数中调用 this->成员变量
进行访问 ; 这里的访问是指获取成员变量的值 , 或修改成员变量的值 ;
成员函数中申请内存 , 需要在析构函数中将内存释放 , 不管在构造函数 , 还是在成员函数中申请的内存 , 都需要在析构函数中 , 将内存释放掉 ;
Student.h 中相关声明 :
//默认作用域 : 如果没有指定作用域, 其作用域默认是 private 私有的
//类中的属性定义
int age;
//声明共有的成员方法 , 该方法需要实现
public :
void setAge(int age);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
Student.cpp 实现上述声明的方法 :
void Student::setAge(int age) {
//使用 this 关键字访问成员变量 , 并给成员变量赋值
this->age = age;
}
- 1
- 2
- 3
- 4
常量函数
外部访问类中的私有成员变量 , 有两种方法 , 一种是使用共有的成员方法访问 , 另一种是在友元函数中访问 ;
常量函数 , 在头文件中函数定义时 , 在方法后面加上 const 关键字 , 这个函数就变成了常量函数 , 该函数中不允许修改类中的成员变量 , 一般获取成员变量值的函数可以定义成常量函数 ;
成员函数声明时可以直接实现 , 可以在类中声明成员函数的位置 , 直接实现该函数 , 这样就不同在 Student.cpp 中实现了 ;
Student.h 中声明并实现成员方法 :
//默认作用域 : 如果没有指定作用域, 其作用域默认是 private 私有的
//类中的属性定义
int age;
//声明共有的成员方法 , 该方法需要实现
public :
//在函数后加上 const , 该函数就变成了常量函数
//常量函数中是不允许修改成员变量的
//函数在声明的时候也可以实现
int getAge()const {
return this->age;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
友元函数
外部访问类中的私有成员变量 , 有两种方法 , 一种是使用共有的成员方法访问 , 另一种是在友元函数中访问 ;
友元函数 , 在友元函数中 , 可以从类的外部访问类中的私有成员变量 , 友元函数声明方法 friend 返回值类型 方法名称 ( 参数列表 ) ;
;
Student.h 中友元函数声明
//友元函数声明 , 可以在外部修改类中的私有成员变量
friend void changeAge(Student*);
- 1
- 2
友元函数实现 , 友元函数并不与类实现写在一起 , 而是在使用的位置进行实现 , 这里在 main() 函数所在的文件中进行实现 , 在该实现的友元函数中 , 可以访问类对象的私有成员变量和方法 ;
003_Object_Oriented.cpp ( main函数定义文件 ) 中友元函数实现
//引用 Student 类声明的头文件
#include "Student.h"
//友元函数实现 , 在类的外部修改类中的私有成员变量 age
void changeAge(Student* student){
student->age = 88;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
new 创建对象
使用 new 创建对象 , 表示在堆中申请内存 , 将其定义成 Student 类型 , new 与 mallloc 作用类似 , 当对象不使用之后 , 需要使用 delete 对象名 , 对象会自动调用析构函数 , 将该对象销毁 ; 下面的代码中展示了 , 创建对象 , 使用对象 , 销毁对象的过程 ;
- 创建对象 ,
new Student(18, 1);
使用 new 关键字 , 在堆内存中创建对象 , 注意这种对象使用完毕后需要手动调用delete 对象名
进行释放 ; - 友元函数 ,
changeAge(student);
是调用友元函数修改对象的私有成员变量 ; - 常量函数 ,
student->getAge()
调用共有的常量函数 , 获取私有成员变量值 , 注意常量函数中不允许修改成员变量值 , 只允许获取该值 ; - 释放内存 ,
delete student
作用是, 释放使用 new 申请的堆内存中的内存 ;
//使用 new 创建对象 , 注意该对象在堆内存中创建的
//用完之后需要使用 delete 释放该对象
Student* student = new Student(18, 1);
//调用友元函数, 修改 student 对象类私有变量 age 的值
changeAge(student);
//调用 getAge() 常量函数获取 student 对象的 age 成员变量值
//并将该值打印出来
cout<< "age : " << student->getAge() <<endl;
//释放使用 new 申请的堆内存中的内存
delete student;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
代码执行结果
Student() 构造方法
age : 88
~Student() 析构方法
- 1
- 2
- 3
友元类
友元类 , 友元类中所有的成员函数都是该类的友元函数 , 可以访问该类对象的私有成员变量 ;
友元类声明 , 声明友元类方法 friend class 友元类名称;
, 友元类中所有的成员函数都是该类的友元函数 ;
Student.h 中友元类声明
//声明友元类 , 可以在友元类中访问修改类中的私有成员变量
//友元类中的所有的成员函数都是友元函数
friend class Teacher;
- 1
- 2
- 3
友元类定义与实现 , 友元类中定义的方法都是 Student 类的友元函数 , 其中需要传入 Student*
参数来访问 Student 对象的私有成员变量 ; 可以在定义的时候 , 直接将该方法实现 ;
//Student 中的友元类 , 该友元类中的所有函数都是 Student 对象的友元函数
class Teacher {
public:
//友元类中声明方法 , 修改 Student 中的 id 编号
void setId(Student* student, int id) {
student->id = id;
}
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
单例类
单例类三要素
- ① 私有静态单例类类型的静态成员变量 ;
- ② 私有构造函数 ;
- ③ 静态共有方法 , 该方法中调用私有构造方法创建唯一一个单例类对象 ;
单例类声明 , 创建 Instance 单例类 ;
- ① 声明一个私有的静态成员变量 , 外部不能直接访问该成员变量 ;
private : static Instance* instance;
; - ② 声明私有构造函数 , 外部不能直接调用构造方法创建该类对象 ;
private : Instance();
; - ③ 声明静态共有的方法 , 在该方法中调用私有构造函数创建单例对象 ,
public : static Instance* getInstance();
, 注意创建的这个单例对象是唯一的 , 只能创建一个 ;
Instance.h 单例类声明
#pragma once
class Instance {
//声明一个私有的静态成员变量 , 及构造方法
//外部不能直接调用构造方法创建该类对象
private :
static Instance* instance;
Instance();
//声明共有静态方法
//该方法中可调用私有构造方法并返回 Instance 对象
public :
static Instance* getInstance();
public :
int number = 888;
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
单例类实现 , 在实现中 , 首先给 Instance::instance
静态成员变量赋值初始值 0 , 静态成员变量可以使用 类名::静态成员变量名
访问 ; 然后实现私有的构造函数 , 最后实现共有的单例类获取函数 , 在该函数中首先判定单例类对象是否已经创建 , 如果已经创建 , 直接返回该单例类对象 , 如果没有创建那么先创建该单例类对象 , 再返回该单例对象 instance
;
//设置Instance 静态成员变量 初始值值
//静态成员变量可以使用 类名::静态成员变量名 访问
Instance* Instance::instance = 0;
//实现构造函数
Instance::Instance() {
}
//实现 getInstance 静态成员函数
//方法的实现中 , 可以使用 this-> 调用成员变量或成员方法
//静态的成员变量和成员函数可以直接调用
Instance* Instance::getInstance() {
if (!instance) {
instance = new Instance();
}
return instance;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
单例类使用 , 首先在 CMakeList.txt 中配置上面的 Instance.h 和 Instance.cpp 两个文件 , 然后在 main() 函数所在文件 , 包含 Instance.h 头文件 , 即可在 main() 中使用该单例类了 ; 调用 Instance::getInstance();
可创建单例类 , 注意单例类使用完毕后要释放该类 , 否则会造成内存泄漏 ;
//创建单例对象
Instance* instance = Instance::getInstance();
//打印单例对象中的变量值
cout << "单例 instance->number : " << instance->number << endl;
//释放单例类
delete instance;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
代码执行结果 :
单例 instance->number : 888
- 1
文章来源: hanshuliang.blog.csdn.net,作者:韩曙亮,版权归原作者所有,如需转载,请联系作者。
原文链接:hanshuliang.blog.csdn.net/article/details/99620153
- 点赞
- 收藏
- 关注作者
评论(0)