c-＞c++(二):class
本文主要探讨C++类的相关知识。
构造和析构函数
构造函数(可多个)：对象产生时调用初始化class属性、分配class内部需要的动态内存
析构函数（一个）：对对象消亡时调用回收分配动态内存
C++提供默认构造和析构,构造函数可重载,析构函数不需重载
构造和析构函数不需要返回值类型,构造函数可带参或不带参,析构函数不带参
无其他构造函数时默认构造函数可省略,有构造函数时默认构造函数不能省
class声明时可给构造函数形参赋默认值,调用时不传参则使用默认值,调用不能有重载歧义
所有参数都带默认值构造函数,可以表示所有构造函数
拷贝构造函数：用对象来初始化对象,函数不需重载
浅拷贝:普通成员变量初始化的拷贝构造函数(默认提供),有动态内存分配时出错
深拷贝:浅拷贝无法拷贝对象的成员指针已分配的内存空间,深拷贝可以
拷贝显式提供copy constructor为深拷贝,拷贝构造函数用原来的析构函数
权限
public类内、类外可访问,子类可访问父类公共成员
protected类内可访问,类外不可,子类可访问父类保护成员
private类内可访问,类外不可,子类不可访问父类私有成员
默认是private继承,struct是public继承
继承中父类所有权限继承给子类
public继承：父类成员在子类中保持原有访问权限
private继承：父类成员在子类中变为private权限
protected继承：父类public变protected,protected为protected,private为private
struct和class
C不支持成员函数,C++支持
C不支持static成员,C++中支持
C默认public,C++默认public,c++可指定public/private/protected权限
C不支持继承(通过包含结构体指针实现),C++支持且struct和class可互相继承
C++中struct和class:struct默认public,class默认private,struct和class交叉继承权限取决子类
派生类和基类
派生类不继承基类构造和析构函数,只继承成员变量和成员方法,派生类有自己构造和析构
派生类构造函数执行前,先调用基类构造函数,再调用自己构造函数
派生类先执行自己析构函数,再执行基类析构函数
派生类覆盖基类同名成员(重定义),父类的同名成员存在且被隐藏,可通过全域路径调用被隐藏的方法,可添加派生类独有成员
派生类是基类的超集,基类对象放大成派生类可能出错,派生类赋值给基类可正常使用(类似char和int的兼容性)
多继承二义性和多态
C多继承A和B,A和B有同名成员、菱形继承(B1:A, B2:A, C:B1,B2)造成二义性
全域路径调用方法,重定义子类方法,重写虚函数解决二义性
基类方法声明为virtual,派生类重写同名方以实现多态
重载函数名相同参数列表不同,重定义子类实现父类同名方法后把父类方法隐藏
重写子类去实现父类同名virtual方法实现多态特性
虚函数
抽象类:有纯虚函数的类,抽象类只能为基类派生新类,不可实例化对象
派生类必须实现基类纯虚函数才能用于实例化对象,否则派生类仍为基类
接口：类中所有成员函数是public且是纯虚函数
无虚构造函数,包含虚函数的类只能作为基类派生新类,无法实例化对象,构造函数是在实例化的时候被调用的,故无虚构造函数
抽象基类(接口)指针指向派生类(new派生类对象：person *p = new man; delete p;),抽象基类(接口)析构函数需要为虚,才可删除指针时能正确调用派生类析构函数,否则不会调用派生类析构函数
抽象基类(接口)指针指向派生类(定义好的派生类man m;person *p = &m;),抽象基类(接口)析构函数是否为虚,都能正常调用派生类析构函数,一般抽象基类(接口)的析构函数都定义为虚
运算符重载
运算符重载是重定义对象运算符对应函数
赋值运算符=默认提供,重载有指针成员时涉及浅拷贝和深拷贝
++a对应Type& operator++(void);
a++,对应Type& operator++(int x);
不可重载运算符: .,.*, ->*,sizeof,?,:,#
静态成员
静态成员属于class本身,不属于对象
静态成员变量在类的多个对象中均可访问,且是同一个
静态成员变量和方法可以用对象调用,也可不产生对象的本身调用
静态数据成员不在类中初始化,类只定义模版
静态数据成员不在类构造函数中初始化,构造函数用于构建对象时初始化对象成员
静态数据成员值默认0,遵循public，private，protected访问准则
静态方法只访问静态成员变量和方法,不能直接访问非静态,需要通过函数传参访问非静态
静态成员变量可用于统计对象数
静态类:内部全是静态成员,不能被实例化,不包括构造函数,不能实现接口(不能被继承),不能有实例成员
静态类成员不能有protected或protected internal访问保护修饰符
友元函数
友元函数不是本类成员函数,是外部函数
友元函数在private或protected或public都可
可以通过类来访问友元函数,不能直接通过友元函数访问类(常用传参访问)
友元函数破坏了封装机制,实现类之间数据共享时减少系统开销,提高效率
运算符重载可用友元函数除=,->,[],()
类间的数据共享可用友元函数
demo1：
类成员权限，构造和析构函数，深拷贝和浅拷贝
目录：
run.sh
#!/bin/bash if [ -f ./Makefile ] then make clean fi cmake . make echo "---------------------------------" ./proCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求 SET(CMAKE_CXX_COMPILER "g++") #设置g++编译器 PROJECT(CLASS) #设置工程名 MESSAGE(STATUS "class test") #打印消息 ADD_EXECUTABLE(pro main.cpp person.cpp) #生成可执行文件person.hpp
#ifndef __PERSON_HPP__ #define __PERSON_HPP__ #include <iostream> using namespace std; namespace People { class Person { public: string name; int age; string sex; string description; int *luck_num; Person(); Person(string name = "xxx",int age = 0,string sex = "none",string description = "none"); Person(const Person &p); ~Person(); void set_info(string name,int age,string sex,string description); void print_info(); void set_income(int income); int get_income(); void set_savings_account(int savings_account); int get_savings_account(); private: int income; int savings_account; }; } #endifperson.cpp
#include "person.hpp" #include <iostream> using namespace std; void People::Person::set_info(string name,int age,string sex,string description) { this->name = name; this->age = age; this->sex = sex; this->description = description; } void People::Person::print_info() { cout << "name :" << this->name << endl; cout << "age :" << this->age << endl; cout << "sex :" << this->sex << endl; cout << "description :" << this->description << endl; cout << "income " << get_income() << endl; cout << "savings_account " << get_savings_account() << endl; cout << "luck_num : " << this->luck_num[0] << " " << this->luck_num[1] << endl; } void People::Person::set_income(int income) { this->income = income; } int People::Person::get_income() { return this->income; } void People::Person::set_savings_account(int savings_account) { this->savings_account = savings_account; } int People::Person::get_savings_account() { return this->savings_account; } People::Person::Person() { cout << "default constructor function" << endl; } People::Person::Person(string name,int age,string sex,string description):name(name),age(age),sex(sex),description(description) { this->luck_num = new int[2]; cout << "user define constructor function" << endl; } People::Person::~Person() { delete [] this->luck_num; cout << "user define destructor function" << endl; } People::Person::Person(const Person &p):name(p.name),age(p.age),sex(p.sex),description(p.description) { luck_num = new int(*p.luck_num); cout << "user define deep copy constructor function" << endl; }main.cpp
#include <iostream> #include "person.hpp" using namespace std; using namespace People; int main() { Person p1("xiaoming",23,"male","high"); p1.set_income(50); p1.set_savings_account(100); p1.luck_num[0] = 2; p1.luck_num[1] = 7; p1.print_info(); Person p2(p1); p2.set_income(20); p2.set_savings_account(10); p2.luck_num[0] = 36; p2.luck_num[1] = 72; p2.print_info(); Person p3 = p2; p3.set_income(10); p3.set_savings_account(40); p3.luck_num[0] = 5; p3.luck_num[1] = 8; p3.print_info(); return 0; }结果示例：
demo2：
继承和多态,虚函数，抽象类，接口
目录：
run.sh
#!/bin/bash if [ -f ./Makefile ] then make clean fi cmake . make echo "---------------------------------" ./procheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求 SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项 PROJECT(CLASS) #设置工程名 MESSAGE(STATUS "class test") #打印消息 ADD_EXECUTABLE(pro main.cpp person.cpp man.cpp) #生成可执行文件person.hpp
#ifndef __PERSON_HPP__ #define __PERSON_HPP__ #include <iostream> using namespace std; namespace People { class Person { public: string name; int age; void print_info(); Person(); Person(string name,int age); ~Person(); private: int income; protected: }; class person { public: string name; virtual void play() = 0; virtual ~person(); }; class machine { public: virtual void introduce() = 0; virtual ~machine(); }; } #endifperson.cpp
#include "person.hpp" #include <iostream> using namespace std; void People::Person::print_info() { cout << "name : " << this->name << endl; cout << "age : " << this->age << endl; } People::Person::Person() { cout << "Person constructor" << endl; } People::Person::Person(string name,int age):name(name),age(age) { cout << "user define Person constructor" << endl; } People::Person::~Person() { cout << "Person destructor" << endl; } People::person::~person() { cout << "user define person desturctor" << endl; } People::machine::~machine() { cout << "machine virtual function" << endl; }man.hpp
#ifndef __MAN_HPP__ #define __MAN_HPP__ #include "person.hpp" class Man:public People::Person { public: string description; void do_job(); void print_info(); Man(); Man(string name,int age,string description); ~Man(); private: protected: }; class man:private People::Person { public: using Person::name; using Person::age; using Person::print_info; }; class gamer:public People::person { public: void play(); gamer(); ~gamer(); }; class sportsman:public People::person { public: void play(); sportsman(); ~sportsman(); }; class robot:public People::machine { public: void introduce(); robot(); ~robot(); }; #endifman.cpp
#include "man.hpp" #include <iostream> using namespace std; void Man::do_job() { cout << this->name << " working" << endl; } void Man::print_info() { cout << "name :" << this->name << endl; cout << "age :" << this->age << endl; cout << "description :" << this->description << endl; } void gamer::play() { cout << this->name << " playing game" << endl; } gamer::gamer() { cout << "user define gamer consturctor function" << endl; } gamer::~gamer() { cout << "user define gamer desturctor function" << endl; } sportsman::sportsman() { cout << "user define sportsman consturctor function" << endl; } sportsman::~sportsman() { cout << "user define sportsman desturctor function" << endl; } void sportsman::play() { cout << this->name << " playing ping-pong" << endl; } void robot::introduce() { cout << "i am robot" << endl; } robot::robot() { cout << "robot consturctor function" << endl; } robot::~robot() { cout << "robot desturctor function" << endl; } Man::Man() { cout << "man constructor" << endl; } Man::Man(string name = "xxx",int age = 0,string description = "xxx"):Person(name,age),description(description) { cout << "user define man constructor" << endl; } Man::~Man() { cout << "man destructor" << endl; }main.cpp
#include "person.hpp" #include "man.hpp" using namespace People; using namespace std; int main() { Man m1; //父类构造->子类构造->子类析构->父类析构 Man m2("xiaoming",23,"height"); m2.print_info(); m2.do_job(); m2.Person::print_info(); //全域路径访问隐藏父类方法 Person p1 = m2; //子类初始化父类 p1.print_info(); man m3; m3.name = "xiaohua"; m3.age = 27; m3.print_info(); //using放开保护继承(class A :private/protected B) //需要保证抽象基类的析构函数为虚才能正常调用派生类析构函数 person *p = new gamer; p->name = "gamer"; p->play(); delete p; //抽象基类的析构函数是否为虚都能调用派生类析构函数 sportsman s; s.name = "sportsman"; person *t = &s; t->play(); //接口和抽象基类的析构函数一般定义为虚 robot r; r.introduce(); return 0; }结果示例：
demo4:
运算符重载
目录：
run.sh
#!/bin/bash if [ -f ./Makefile ] then make clean fi cmake . make echo "---------------------------------" ./procheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proclean.sh
#!/bin/bash rm -rf CMakeFiles pro Makefile CMakeCache.txt cmake_install.cmakeCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求 SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项 PROJECT(CLASS) #设置工程名 MESSAGE(STATUS "class test") #打印消息 ADD_EXECUTABLE(pro main.cpp) #生成可执行文件main.cpp
#include <iostream> using namespace std; class coordinate { public: int *px; int *py; coordinate(); coordinate(const coordinate &cd); coordinate(int x,int y); ~coordinate(); void print_coordinate(); coordinate operator+(const coordinate & other); coordinate operator=(const coordinate & other); coordinate operator++(int x); //i++ coordinate operator++(void); //++i bool operator==(const coordinate & other); friend void operator+=(coordinate & a,const coordinate & b); //友元函数只能传参方式调用类成员 }; coordinate::coordinate() { this->px = new int(0); this->py = new int(0); } coordinate::coordinate(int x,int y) { this->px = new int(x); this->py = new int(y); } coordinate::coordinate(const coordinate &cd) { cout << "copy" << endl; this->px = new int(*(cd.px)); this->py = new int(*(cd.py)); } coordinate::~coordinate() { delete this->px; delete this->py; } void coordinate::print_coordinate() { cout << "(" << *(this->px) << "," << *(this->py) << ")" << endl; return; } coordinate coordinate::operator+(const coordinate & other) { cout << "+" << endl; coordinate tmp; *(tmp.px) = *(this->px) + *(other.px); *(tmp.py) = *(this->py) + *(other.py); return tmp; } coordinate coordinate::operator=(const coordinate & other) { cout << "=" << endl; if(this != &other) { *(this->px) = *(other.px); *(this->py) = *(other.py); } return *this; } coordinate coordinate::operator++(void) { *(this->px) += 1; *(this->py) += 1; return *this; } coordinate coordinate::operator++(int x) { coordinate tmp; *(tmp.px) = *(this->px); *(tmp.py) = *(this->py); *(this->px) += 1; *(this->py) += 1; return tmp; } void operator+=(coordinate & a,const coordinate & b) { *(a.px) += *(b.px); *(a.py) += *(b.py); return; } bool coordinate::operator==(const coordinate & other) { if(*(this->px) == *(other.px) && *(this->py) == *(other.py)) return true; return false; } int main() { coordinate c1(1,1); coordinate c2(2,2); cout << "------------3" << endl; coordinate c3; c3 = c1 + c2; //先定义再赋值时,先调用加法,在调用自定义=,在调用自定义拷贝(深浅拷贝均相同,浅拷贝时若为定义=和拷贝,则调用默认) c3.print_coordinate(); cout << "------------4" << endl; coordinate c4 = c1 + c2; //只调用+(深浅拷贝均相同) c4.print_coordinate(); cout << "------------5" << endl; coordinate c5 = c1; //调用自定义拷贝(浅拷贝调用默认) c5.print_coordinate(); cout << "------------6" << endl; coordinate c6(c1); //调用自定义拷贝(浅拷贝调用默认) c6.print_coordinate(); cout << "tmp------------7" << endl; coordinate tmp; coordinate c7; tmp = c7++; tmp.print_coordinate(); cout << "tmp------------8" << endl; coordinate c8; tmp = ++c8; tmp.print_coordinate(); cout << "------------9" << endl; coordinate c9(1,1); operator+=(c9,c9); c9.print_coordinate(); cout << "------------10" << endl; coordinate c10(1,1); bool res = (c10 == c1); cout << boolalpha << res << endl; return 0; }结果示例：
demo5:
类静态成员
目录：
run.sh
#!/bin/bash if [ -f ./Makefile ] then make clean fi cmake . make echo "---------------------------------" ./proclean.sh
#!/bin/bash rm -rf CMakeFiles pro Makefile CMakeCache.txt cmake_install.cmakecheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求 SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项 PROJECT(CLASS) #设置工程名 MESSAGE(STATUS "class test") #打印消息 ADD_EXECUTABLE(pro main.cpp) #生成可执行文件main.cpp
#include <iostream> using namespace std; class Person { public: string name; Person(); Person(string name); static int objetcion_num; static void print_obj_num(); static void print_name(string name); //静态方法传参访问非静态成员 }; //静态类 class constant { public: static int week_day_num; //一周的天数 static int earth_radius; //地球半径 static void print_info(); }; int constant::week_day_num = 7; int constant::earth_radius = 6371; void constant::print_info() { cout << "days of the week :" << constant::week_day_num << endl; cout << "radius of the earth :" << constant::earth_radius << endl; } int Person::objetcion_num = 0; //<==>int objetcion_num; //类中静态成员的访问方式 Person::Person() { objetcion_num++; } Person::Person(string name) { this->name = name; this->objetcion_num++; } void Person::print_obj_num() { cout << "obj_num :" << Person::objetcion_num << endl; } void Person::print_name(string name) { cout << "person name :" << name << endl; } int main() { //类外静态成员的访问方式 Person p1; cout << "obj_num :" << p1.objetcion_num << endl; Person p2("xaioming"); cout << "obj_num :" << Person::objetcion_num << endl; Person p3("xaiohua"); p3.print_obj_num(); constant::print_info(); return 0; }结果示例：
demo6:
友元函数，友元类
目录：
run.sh
#!/bin/bash if [ -f ./Makefile ] then make clean fi cmake . make echo "---------------------------------" ./procheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proclean.sh
#!/bin/bash rm -rf CMakeFiles pro Makefile CMakeCache.txt cmake_install.cmakeCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求 SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项 PROJECT(CLASS) #设置工程名 MESSAGE(STATUS "class test") #打印消息 ADD_EXECUTABLE(pro main.cpp) #生成可执行文件main.cpp
#include <iostream> using namespace std; //前置申明解决友元类未定义 class Father; class Son; class Father { public: string name; int age; Father(); Father(string name,int age); void print_name(string name); friend class Son; }; class Son { public: string name; int age; Son(); Son(string name,int age); void print_age(int age); friend class Father; }; Father::Father(string name,int age) { this->name = name; this->age = age; } void Father::print_name(string name) { cout << name << endl; } Son::Son(string name,int age) { this->name = name; this->age = age; } void Son::print_age(int age) { cout << age << endl; } int main() { Father f("xiaoming",40); Son s("xiaohua",20); f.print_name(s.name); s.print_age(f.age); return 0; }结果示例：