类和对象是C++的重要特性,也是其面向对象的基本,类的类容很多,本文只是简单介绍,包括类的定义、构造函数、析构函数、常量函数、仿函数、继承、多态、静态成员和类模板等
1. 类的定义
类是自定义的类型,基本形式如下所示,类的末尾有分号";"
class Master {
public: Master(); //构造函数 ~Master(); //析构函数 //成员函数 public: void addBloodVolume(); void reduceBloodVolume(); void showBloodVolume(); //在类的内部实现,默认是inline void setBloodVolume(int32_t bloodVolume) {
m_blood_volume = bloodVolume; } void addManaVolume(); void reduceManaVolume(); void showManaVolume(); //在类的内部实现,默认是inline void setManaVolume(int32_t manaVolume) {
m_mana_volume = manaVolume; } //成员变量 private: int32_t m_blood_volume; int32_t m_mana_volume; };
讯享网
2. 构造函数与析构函数
构造函数
构造函数决定了我们定义类对象的方式,默认是public,可以有多个
讯享网//第一种: *.h文件 Master(); *.cc文件 Master::Master() {
} //第二种: *.h文件 Master(){
}; //第三种: Master() = default; //编译器会自动生成默认的函数定义体
构造函数支持重载
Master() = default; Master(int32_t bloodVolume, int32_t manaVolume); //类对象的定义: Master master; //或 Master master(100, 90);
构造函数的初始化列表
讯享网Master(int32_t bloodVolume, int32_t manaVolume) : m_blood_volume(bloodVolume), m_mana_volume(manaVolume){
/* code */}; //构造函数
初始化 const 成员变量的一种方法就是使用初始化列表
//m_blood_volume如果为const,则该成员变量支持初始化列表赋值 const int32_t m_blood_volume;
析构函数
析构函数只能有1个,不能重载,一个类只能有一个析构函数,对象在销毁的时候自动调用;如果用户没有定义,则系统会自动生成
讯享网~Master();
空类,编译器一般会给类生成默认的6个函数;如果不使用的话,可以将其定义为private,并且在后面加delete
public: Master(); //默认构造函数 ~Master(); //默认析构函数 private: Master(const Master &)=delete; //默认拷贝构造函数 Master(Master &&)=delete; //默认移动构造函数 Master &operator=(const Master &)=delete; //默认赋值函数 Master &operator=(Master &&)=delete; //默认移动赋值构造函数
3. public/private/protect
类的成员函数和成员变量有3种属性
讯享网class Games {
//公有 public: Games(); ~Games(); //私有 private: //保护 protected: };
- 公有(public):在类内以及通过类的实例都可以访问
- 私有(private):在类内可以访问,类的实例不可以访问,子类不可以访问
- 保护(protect):在类内可以访问,类的实例不可以访问,子类可以访问
一般情况下,将对外的接口定义为public,其余定位为private,尤其是成员变量;protect根据使用情况而定;
4. 虚函数与纯虚函数
虚函数的关键字virtual;如果一个函数声明为虚函数,则允许基类的指针指向子类的该函数,该函数需要在子类中实现
基类
//声明 virtual void skill_q(); //实现 void Master::skill_q() {
std::cout<<"skill q belong to master!"<<std::endl; }
子类
讯享网class Karthus : public Master {
public: Karthus() = default; ~Karthus(){
}; public: void skill_q(); void skill_w(); void skill_e(); void skill_r(); }; 实现 void Karthus::skill_q() {
std::cout<<"skill q belong to karthus!"<<std::endl; }
使用
int main(int argc, char *argv[]) {
Master *pmaster = new Master; pmaster->skill_q(); delete pmaster; Master *pmaster1 = new Karthus; pmaster1->skill_q(); delete pmaster1; return 0; }
输出
讯享网skill q belong to master! skill q belong to karthus!
纯虚函数
如果一个函数被声明为纯虚函数,则说明该类为抽象类,无法创建对象、也无法实例化(纯虚函数没有函数体,不是完整的函数)。抽象类通常是作为基类,让派生类去实现纯虚函数,抽象类通常作为对外接口,不暴露实现。
virtual void skill_w()=0; //该函数需要在子类中实现
5. 常量函数
在类的成员函数后面加上const,则该函数则被成为常量函数,常量函数的声明和实现都需要加上const;常量函数不允许修改成员变量,避免修改对象的内容,可以将函数定义为常量函数;
讯享网//声明 void addManaVolume() const; //实现 void Master::addManaVolume() const {
std::cout<<this->m_blood_volume<<std::endl; }
void Master::addManaVolume() const {
//showBloodVolume(); //不允许,常量函数不允许调用非常量函数 reduceManaVolume(); //允许,常量函数可以调用常量函数 std::cout<<this->m_blood_volume<<std::endl; } void Master::showBloodVolume() {
std::cout<<"blood volume is: "<<m_blood_volume<<std::endl; } void Master::reduceManaVolume() const {
std::cout<<"const test!"<<std::endl; }
类的对象也可以声明为const,为常对象,常对象只能访问const成员变量和const成员函数;
讯享网const Karthus karthus;
6. 仿函数
仿函数就是仿造的函数,本质还是类,但是有了函数的特性,也叫做函数对象;仿函数需要重载operator()运算符;
举例说明仿函数的作用:
#include <iostream> #include <string> #include <vector> #include <algorithm> class MyFunc {
public: bool operator()(int32_t x, int32_t y){
return x > y;} }; int main(int argc, char *argv[]) {
std::vector<int32_t> v = {
12, 11, 3, 4, 5, 23}; MyFunc myfunc; std::sort(v.begin(), v.end(), myfunc); for(auto au : v) {
std::cout<<au<<" "; } std::cout<<std::endl; }
当然也可以通过lambda表达式来实现
讯享网#include <iostream> #include <string> #include <vector> #include <algorithm> int main(int argc, char *argv[]) {
std::vector<int32_t> v = {
12, 11, 3, 4, 5, 23}; std::sort(v.begin(), v.end(), [](int32_t x,int32_t y){
return x > y;}); for(auto au : v) {
std::cout<<au<<" "; } std::cout<<std::endl; }
7. 继承
class <派生类名> : <继承方式(public/protected/private)> <基类名>
- public:子类可以访问基类中的public和protected成员,其属性不变,不能访问private成员;
- protected:基类中的public和protect成员将成为子类中的protected成员;
- private:基类中的public和protect成员将成为子类中的private成员;
使用
讯享网class Master {
public: Master() = default; //Master(); //默认构造函数 Master(int32_t bloodVolume, int32_t manaVolume) : m_blood_volume(bloodVolume), m_mana_volume(manaVolume){
}; //构造函数 ~Master(); //默认析构函数 private: Master(const Master &)=delete; //默认拷贝构造函数 Master(Master &&)=delete; //默认移动构造函数 Master &operator=(const Master &)=delete; //默认赋值函数 Master &operator=(Master &&)=delete; //默认移动赋值构造函数 public: virtual void skill_q(); virtual void skill_w(); void skill_e(); void skill_r(); void addBloodVolume(); void reduceBloodVolume(); //void showBloodVolume() = delete; void showBloodVolume(); void setBloodVolume(int32_t bloodVolume) {
//m_blood_volume = bloodVolume; this->m_blood_volume = bloodVolume; } void addManaVolume() const; void reduceManaVolume() const; void showManaVolume(); void setManaVolume(int32_t manaVolume) {
m_mana_volume = manaVolume; } public: static int32_t m_count; private: int32_t m_blood_volume; int32_t m_mana_volume; }; class Karthus : public Master {
public: Karthus() = default; ~Karthus(){
}; public: void skill_q(); void skill_w(); void skill_e(); void skill_r(); };
一般情况下,继承方式会使用public;例如基类中的缓存队列,子类可以通过public的成员函数进行存储和获取;
8. 多态
什么是多态,多态就是让基类的指针可以访问子类的成员函数,基类中的方法需要定义为虚函数(virtual);
基类可以调用自身的方法,可以调用子类的方法,表现为多种形态,即为多态;
如果不使用多态的话,类Karthus、Syndra 和 Ryze都需要定义一遍,如果使用多态只需要将基类的指针指向子类即可;
头文件
#include <iostream> #include <string> class Master {
public: Master() = default; Master(int32_t bloodVolume, int32_t manaVolume) : m_blood_volume(bloodVolume), m_mana_volume(manaVolume){
}; //构造函数 ~Master(); //默认析构函数 private: Master(const Master &)=delete; //默认拷贝构造函数 Master(Master &&)=delete; //默认移动构造函数 Master &operator=(const Master &)=delete; //默认赋值函数 Master &operator=(Master &&)=delete; //默认移动赋值构造函数 public: virtual void skill_q(); virtual void skill_w(); virtual void skill_e(); virtual void skill_r(); void addBloodVolume(); void reduceBloodVolume(); void showBloodVolume(); void setBloodVolume(int32_t bloodVolume) {
this->m_blood_volume = bloodVolume; } void addManaVolume() const; void reduceManaVolume() const; void showManaVolume(); void setManaVolume(int32_t manaVolume) {
m_mana_volume = manaVolume; } public: static int32_t m_count; private: int32_t m_blood_volume; int32_t m_mana_volume; }; class Karthus : public Master {
public: Karthus() = default; ~Karthus(){
}; public: //以下函数在.cc中实现 void skill_q(); void skill_w(); void skill_e(); void skill_r(); }; class Syndra : public Master {
public: Syndra() = default; ~Syndra() {
} public: void skill_q(){
std::cout<<"skill q belong to Syndra!"<<std::endl;} void skill_w(){
std::cout<<"skill w belong to Syndra!"<<std::endl;} void skill_e(){
std::cout<<"skill e belong to Syndra!"<<std::endl;} void skill_r(){
std::cout<<"skill r belong to Syndra!"<<std::endl;} }; class Ryze : public Master {
public: Ryze() = default; ~Ryze(){
} public: void skill_q(){
std::cout<<"skill q belong to Ryze!"<<std::endl;} void skill_w(){
std::cout<<"skill w belong to Ryze!"<<std::endl;} void skill_e(){
std::cout<<"skill e belong to Ryze!"<<std::endl;} void skill_r(){
std::cout<<"skill r belong to Ryze!"<<std::endl;} };
main.cc
讯享网/* class test * g++ -g class.h class.cc main.cc -o d -std=c++11 */ #include <iostream> #include <string> #include <vector> #include <algorithm> #include "class.h" int main(int argc, char *argv[]) {
Master *master = new Karthus; master->skill_q(); master->skill_w(); master->skill_e(); master->skill_r(); std::cout<<std::endl; master = new Syndra; master->skill_q(); master->skill_w(); master->skill_e(); master->skill_r(); std::cout<<std::endl; master = new Ryze; master->skill_q(); master->skill_w(); master->skill_e(); master->skill_r(); std::cout<<std::endl; return 0; }
输出
skill q belong to karthus! skill w belong to karthus! skill e belong to karthus! skill r belong to karthus! skill q belong to Syndra! skill w belong to Syndra! skill e belong to Syndra! skill r belong to Syndra! skill q belong to Ryze! skill w belong to Ryze! skill e belong to Ryze! skill r belong to Ryze!
9. void
void一般会翻译为无、空白等,这里主要介绍void作为参数的使用,void可以指向任何类型的地址
将多态main.cc的输出函数改一下
讯享网void show(void *ptr) {
//Master *pMaster = (Master*)ptr; Master *pMaster = reinterpret_cast<Master*>(ptr); pMaster->skill_q(); pMaster->skill_w(); pMaster->skill_e(); pMaster->skill_r(); std::cout<<std::endl; } int main(int argc, char *argv[]) {
Master *master = new Karthus; show(master); master = new Syndra; show(master); master = new Ryze; show(master); return 0; }
10. this指针
this是一个const指针,只能在类的内部使用,可以访问所有的成员变量和函数(public/private/protect)
void setBloodVolume(int32_t bloodVolume) {
//m_blood_volume = bloodVolume; this->m_blood_volume = bloodVolume; }
11. 静态成员变量与静态成员函数
静态成员变量
静态成员变量在定义的时候需要加上static,是一种特殊的成员变量,无论该类创建多少个对象,静态成员变量只有1个,且共享
声明
讯享网class Karthus : public Master {
public: Karthus() = default; ~Karthus(){
}; public: void skill_q(); void skill_w(); void skill_e(); void skill_r(); void showCount() {
std::cout<<"m_count value is: "<<m_count<<std::endl; } private: static int32_t m_count; };
初始化(必须在类外进行初始化),静态成员变量内存的分配是在初始化的时候,且分配一次;
//main.cc文件中 int32_t Karthus::m_count = 36;
使用(直接访问,通过对象或指针)
讯享网std::cout<<Karthus::m_count<<std::endl; //直接访问,当然m_count的属性需要为public Karthus karthus; karthus.showCount(); //通过对象访问
静态成员函数
静态成员函数在定义的时候需要加上static,其没有this指针,只能访问静态成员变量或静态成员函数
定义
class Karthus : public Master {
public: Karthus() = default; ~Karthus(){
}; public: void skill_q(); void skill_w(); void skill_e(); void skill_r(); static void skill_g(); static void skill_h(); void showCount() {
std::cout<<"m_count value is: "<<m_count<<std::endl; } private: static int32_t m_count; };
讯享网void Karthus::skill_g() {
m_count++; std::cout<<"m_count(g) value is: "<<m_count<<std::endl; } void Karthus::skill_h() {
//skill_e(); //不允许,会报错 skill_g(); m_count++; std::cout<<"m_count(h) value is: "<<m_count<<std::endl; }
使用
int main(int argc, char *argv[]) {
Karthus karthus; karthus.showCount(); karthus.skill_g(); karthus.skill_h(); return 0; }
输出
讯享网m_count value is: 36 m_count(g) value is: 37 m_count(g) value is: 38 m_count(h) value is: 39
12. 关键字override和final
override
override关键字,会让编译器检查是否正确覆写父类的虚函数;建议子类中需要覆写的虚函数加上override,这是个好习惯
实例
class Student {
public: Student() = default; ~Student(){
} public: virtual void showInfo() {
std::cout<<"the class is Student."<<std::endl; } }; class Girl : public Student {
public: Girl() = default; ~Girl(){
} public: void showInfo() {
std::cout<<"the class is Girl."<<std::endl; } }; int main(int argc, char *argv[]) {
Student *ptr = new Girl; ptr->showInfo(); return 0; }
输出
讯享网the class is Girl.
修改class Student的showInfo,修改内容如下所示
class Student {
public: Student() = default; ~Student(){
} public: virtual void showInfo() const {
std::cout<<"the class is Student."<<std::endl; } };
输出
讯享网the class is Student.
如果加上override,则会报错,提示没有覆写基类中的showInfo()
class Student {
public: Student() = default; ~Student(){
} public: virtual void showInfo() const {
std::cout<<"the class is Student."<<std::endl; } }; class Girl : public Student {
public: Girl() = default; ~Girl(){
} public: void showInfo() override {
std::cout<<"the class is Girl."<<std::endl; } };
final
final表示该类禁止被继承,该关键字在使用的时候需要特别注意;
以下代码无法编译通过,Student无法被继承
讯享网class Student final {
public: Student() = default; ~Student(){
} public: virtual void showInfo() {
std::cout<<"the class is Student."<<std::endl; } }; class Girl : public Student {
public: Girl() = default; ~Girl(){
} public: void showInfo() override {
std::cout<<"the class is Girl."<<std::endl; } };
13. 类模板
template<class T1, class T2> class Man {
public: void setValue(T1 name,T2 age) {
m_nmae = name; m_age = age; } void showInfo() {
std::cout<<"name is: "<<m_nmae<<std::endl; std::cout<<"age is: "<<m_age<<std::endl; } private: T1 m_nmae; T2 m_age; }; int main(int argc, char *argv[]) {
Man<std::string, int32_t> man; man.setValue("xiaoming",18); man.showInfo(); Man<int32_t, int32_t> man1; man1.setValue(01, 20); man1.showInfo(); return 0; }
输出
讯享网name is: xiaoming age is: 18 name is: 1 age is: 20
class Person {
public: void show() {
std::cout<<"person"<<std::endl; } }; template<class T> class Boy {
public: void show() {
t.show(); } private: T t; }; int main(int argc, char *argv[]) {
Boy<Person> boy; boy.show(); return 0; }
输出
讯享网person

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/114954.html