企业网站模板建站流程,做网站一个月工资,在线购物网站,淮南市潘集区信息建设网站1.内存分区模型
/* 面向对象编程** 内存分区模型* 1.代码区#xff1a;存放函数体的二进制代码#xff0c;由操作系统进行管理的* 2.全局区#xff1a;存放全局变量和静态变量以及常量* 3.栈区#xff1a;由编译器自动分配释放#xff0c;存放函数的参数值…1.内存分区模型
/* 面向对象编程** 内存分区模型* 1.代码区存放函数体的二进制代码由操作系统进行管理的* 2.全局区存放全局变量和静态变量以及常量* 3.栈区由编译器自动分配释放存放函数的参数值局部变量等* 4.堆区由程序员分配和释放若程序员不释放程序结束时由操作系统回收** 1.1程序运行前* 在程序编译后生成了exe可执行程序未执行该程序前分为两个区域* 代码区* 1.存放cpu执行的机器指令* 2.代码区是共享的共享的目的是对于频繁被执行的程序只需要在内存中存在一份即可* 3.代码区是只读的使其只读的原因是防止程序以外地修改了他的指令* 全局区* 1.全局变量和静态变量存放在此* 2.全局区还包含了常量区字符串常量区和其他常量也存放在此* 3.该区域的数据在程序结束后由操作系统释放。** 1.2程序运行后* 栈区* 1.由编译器自动分配释放存放函数的参数值局部变量等* 注意事项不要返回局部变量的地址栈区开辟的数据由编译器自动释放** 堆区* 1.由程序员分配释放若程序员不释放程序结束时由操作系统回收* 在C中主要利用new在堆区开辟内存*/
//创建全局变量;全局变量在函数外面
int g_a10;
//const修饰的全局变量
const int c_g_a10;
int main() {//静态变量static int s_a10;//常量//字符串常量 引起来的都是字符串常量//const//const修饰的局部变量 在堆区const int a10;//堆区int * pintnew int(10);coutpint*pintendl;return 0;
}
2.newdelete引用
/** new 语法** 堆区的数据 由程序员管理释放* 如果想释放堆区的数据利用关键字 delete** 引用* 作用给变量起别名* 语法数据类型 别名 原名;* 注意* 1.引用必须初始化* 2.引用在初始化后不可以改变** 引用做函数参数* 作用函数传参时可以利用引用的技术让形参修饰实参* 优点可以简化指针修改实参** 引用做函数返回值* 作用引用是可以作为函数的返回值存在的* 注意不要返回局部变量引用* 用法函数调用作为左值 test04()1000;** 引用的本质* 本质引用的本质在C内部实现是一个指针常量** 常量引用* 作用常量引用主要用来修饰形参防止误操作* 在函数参数列表中可以加const修饰形参防止形参改变实参*/
int * func(){//在堆区创建整型数据//new返回是 该类型数据的指针int *pnew int(10);return p;
}
void test01(){int *pfunc();cout*pendl;delete p;
// cout*pendl; //内存已被释放再次访问是非法操作
}
//2.在堆区医用new开辟数组
void test02(){//创建10整型数据的数组在堆区int *arrnew int[10];//10代表数组有十个元素for(int i0;i10;i){arr[i]i100;}for(int i0;i10;i){coutarr[i]endl;}//释放堆区数组//释放数组的时候要加[]delete[] arr;
}//交换函数
//值交换
void mysqap01(int a,int b){int tempa;ab;btemp;
}
//地址交换
void mysqap02(int *a,int *b){int temp*a;*a*b;*btemp;
}
//引用交换
void mysqap03(int a,int b){int tempa;ab;btemp;
}//引用做函数的返回值
//1.不要返回局部变量的引用
int test03(){int a10;//局部变量 存放在栈区函数结束释放return a;
}
//2.函数的调用可以作为左值
int test04(){static int a110; //静态变量 全局区程序结束系统释放return a;
}
int main() {//1.new的基本语法test01();//2.在堆区利用new开辟数组test02();coutendl;cout引用endl;int a10;int ba;b20;coutaaendl;coutbbendl;
// int c; //错误没有初始化//引用一旦初始化了就不可以更改了int c15;bc; //赋值操作而不是更改引用给b赋值了
// bc; 报错coutendl;cout引用在函数中的应用endl;int aa10;int bb20;mysqap01(aa,bb);cout值交换aaaa;bbbb;endl;mysqap02(aa,bb);cout地址交换aaaa;bbbb;endl;mysqap03(aa,bb);cout引用交换aaaa;bbbb;endl;coutendl;cout引用做函数返回值endl;int reftest03();coutrefrefendl;coutrefrefendl;int staticReftest04();coutstaticRefstaticRefendl;coutendl;cout常量引用endl;const int reef10;
// reef20; //加入const之后变为只读不能修改return 0;
}
3.函数提高
/*** 函数提高** 函数默认参数* 在C中函数的形参列表中的形参是可以有默认值的。* 语法返回值类型 函数名 (参数默认值){}* 注意* 1.默认参数必须从右往左不能跳过参数* 2.若果函数声明有默认参数函数实现就不能有默认参数** 函数占位参数* C中函数的形参列表里可以有占位参数用来做占位调用函数时必须填补该位置* 语法返回值类型 函数名 (数据类型){}** 函数重载* 作用函数名可以相同提高复用性* 函数重载满足条件* 1.同一个作用域下* 2.函数名称相同* 3.函数参数类型不同 或者 个数不同 或者 顺序不同* 注意函数的返回值不可以作为函数重载的条件* 函数重载的注意事项* 1.引用作为重载的条件* 2.函数重载碰到默认参数* return*///1.默认形参
void text01(int a10){cout默认值aaendl;
}
//2.函数占位参数 后面课程会用到
//占位参数还可以有默认值
void text02(int a,int){//如何使用 第二个参数 疑问
}
void text03(int a,int20){}//重载
void text04(int a,double b){}
void text04(double b,int a){}
void text04(int a,int b,int c){}
void text04(double a,double b){}
int main() {text01();text01(15);text02(10,12);return 0;
}4.类和对象
/** 类和对象** 三大特性封装、继承、多态 【与java一个样】*///设计一个圆类求圆的周长
//圆求周长的公式:2*PI*半径
//class 代表设计一个类类后面紧跟着的就是类名称
const double PIQ3.1415;
#define PIAA 3.1415
class Circle{//访问权限
public://属性int m_r;//行为double calculateZC(){return 2*PIQ*m_r;}double calculateZC2(){return 2*PIAA*m_r;}
};
int main() {Circle c1;c1.m_r5;cout圆的周长为:c1.calculateZC()endl;cout圆的周长为:c1.calculateZC2()endl;return 0;
}
5.封装struct与class的区别
/** 封装* 类在设计时可以把属性和行为放在不同权限下加以控制** 访问权限 与java一样* 1.public 公公权限* 成员在类内可以访问类外可以访问* 2.protected 保护权限* 类内可以访问类外不能访问 子类可以访问父类的保护内容* 3.private 私有权限* 成员类内可以访问类外不可以访问子类不能访问父类的内容** struct和class区别* 唯一区别默认访问权限不同* 1.struct默认权限为共有* 2.class默认权限为私有** 成员属性设置为私有* 1.可以自己控制读写权限* 2.对于写可以检测数据的有效性*/
struct C2{int m_A; //默认是公共权限
};
class Person{int m_A; //默认权限 私有
public://公共权限string m_Name;protected://保护权限string m_Car;private://私有权限int m_Password;
public:void func(){m_Name张三;m_Car丰田;m_Password981201;}
};
//成员属性设置为私有 与java 一样
// 1.可以自己控制读写权限
// 2.对于写可以检测数据的有效性
class Person22{string m_Name;int m_Age;string m_Lover; //情人
public://设置姓名void setName(string name){m_Namename;}string getName(){return m_Name;}
};
int main() {//实例化具体对象cout权限学习endl;Person p1;p1.m_Name李四;//p1.m_Car拖拉机;//访问不到//p1.m_Password123; //不可以访问coutendl;cout成员属性设置为私有endl;Person22 p2;p2.setName(张三);coutp2.m_Namep2.getName()endl;return 0;
}
6.案例 长方体求面积和体积两个是否相同
/** 案例** 设计立方体类* 求出立方体的面积和体积* 分别用全局函数和局部函数判断两个立方体是否相等*/
class Cube{//长宽高 默认属性privateint along;int awidth;int ahigh;public://长宽高 set get 函数//若要精细可以添加上对输入的判断是否复合要求void setAlong(int chang){alongchang;}int getAlong(){return along;}void setAwidth(int kuan){awidthkuan;}int getAwidth(){return awidth;}void setHigh(int gao){ahighgao;}int getAHigh(){return ahigh;}//计算面积函数int area(){return along*ahigh*2along*awidth*2ahigh*awidth*2;}//计算体积int volume(){return along*awidth*ahigh;}//判断两个立方体是否相等bool equal(Cube cube){//第一种可以自己写长宽高对比 简单//第二种校验是否真实的相等 玛法}
};
int main() {Cube c1;c1.setAlong(2);c1.setAwidth(3);c1.setHigh(4);cout面积为c1.area()endl;cout体积为c1.volume()endl;return 0;
}
7.对象的初始化和清理
构造函数 析构函数1
/*** 对象的初始化和清理** 生活中我们买的电子产品都基本会有出厂设置在某一天我们不用时候也会删除一些自己信息数据保证安全* C中的面向对象来源于生活每个对象也都会有初始设置以及对象销毁前的清理数据的设置。** 构造函数和析构函数* 对象的初始化和清理是两个非常重要的安全问题* 1.一个对象或者变量没有初始状态对其使用后果未知* 2.使用完一个对象或者变量没有及时清理也会造成安全问题* 构造函数和析构函数会被编译器自动调用完成对象初始化和清理工作* 对象的初始化和清理工作是编译器强制要我们做的事情因此如果我们不提供析构和构造编译器是会提供析构函数和构造函数的空实现** 构造函数主要作用在于创建对象时为对象的成员属性赋值构造函数由编译器自动调用无需手动调用。* 语法 类名(){}* 1.构造函数没有返回值也不写 void* 2.函数名称与类名相同* 3.构造函数可以有参数因此可以发生重载* 4.程序在调用对象时候会自动调用构造无需手动调用而且只会调用一次* 析构函数主要作用于对象销毁前系统自动调用执行一些清理工作。* 语法 ~类名(){}* 1.析构函数没有返回值也不写 void* 2.函数名称与类名相同在类名前加上 ~* 3.析构函数不可以有参数因此不可以发生重载* 4.程序在对象销毁前自动调用无需手动调用而且只会调用一次** 构造函数分类及调用* 参数分类有参构造和无参构造* 类型分类普通构造和拷贝构造* 调用方式* 括号法* 显示法* 隐式转换法** return*///构造函数和析构函数
class Person{
public://1.1构造函数Person(){cout构造函数endl;}//析构函数~Person(){cout析构函数endl;}
};//构造函数分类及调用
class Person22{
public:int age;Person22(){cout无参构造函数endl;}Person22(int a){agea;cout有参构造函数endl;}//拷贝构造函数 const 限制防止修改Person22(const Person22 p){agep.age;cout拷贝构造函数endl;}~Person22(){cout析构函数endl;}
};
//调用
void text01(){//1.括号法Person22 p22; //默认构造Person22 p23(10); //有参构造Person22 p24(p22); //拷贝构造函数coutp22地址为p22endl;coutp24地址为p24endl;//2.显示法Person22 p222; //默认构造Person22 p223Person22(10); //有参构造Person22 p224Person22(p22); //拷贝构造函数Person22(10); //匿名对象 特点当前执行结束后系统会立即回收掉匿名对象//3.隐式转换法Person22 p410; //相当于 Person22 p4Person(10);Person22 p5p4;
};//拷贝构造函数调用时机
class Person2{Person2(){}};
int main() {Person p;coutendl;cout构造函数分类及调用endl;text01();coutendl;return 0;
}
构造函数 析构函数2
/** 拷贝构造函数调用时机** C中拷贝构造函数调用时机通常有三种情况* 1.使用一个已经创建完毕的对象来初始化一个新对象* 2.值传递的方式给函数参数传值* 3.以值方式返回局部对象** 构造函数调用规则* 默认情况下c编译器至少给一个类添加三个函数* 1.默认构造函数(无参函数体为空)* 2.默认析构函数无参函数体为空* 3.默认拷贝构造函数对属性进行值拷贝** 构造函数调用规则* 1.用户定义了有参构造函数c默认不再提供无参构造函数但是会提供默认拷贝构造函数* 2.定义了拷贝构造函数c不再提供其他构造函数*/class Person {
public:int m_Age;Person() {cout Person默认构造函数 endl;}Person(int age) {cout Person有参构造函数 endl;m_Age age;}Person(const Person p) {cout Person拷贝构造函数 endl;m_Age p.m_Age;}
};// 1.使用一个已经创建完毕的对象来初始化一个新对象
void test01() {Person p1(20);Person p2(p1);
}// 2.值传递的方式给函数参数传值
void doWork(Person p) {cout p p.m_Age endl;
}void test02() {Person p;doWork(p);
}// 3.以值方式返回局部对象
Person doWork2() {Person p1;return p1;
}void test03() {Person p doWork2();
}int main() {cout 拷贝构造函数调用时机 endl;
// test01();
// test02();test03();return 0;
}
8.深拷贝 浅拷贝
/** 深拷贝 浅拷贝* 浅拷贝简单的赋值拷贝操作【编译器提供的默认拷贝构造函数为浅拷贝函数】* 深拷贝在堆区重新申请空间进行拷贝操作*/
class Person{
public:int age;int *height;Person(){coutPerson默认构造函数endl;}Person(int agea,int heighta){coutPerson有参构造函数endl;ageagea;heightnew int(heighta);
// heightheighta;}//自定义深拷贝构造函数Person(Person p){coutPerson 深拷贝 构造函数endl;agep.age;
// heightp.height; //浅拷贝编译器默认执行的代码heightnew int(*p.height);}~Person(){coutPerson的析构函数endl;//析构代码 将堆区开辟数据做释放操作if(height!NULL){delete height;heightNULL;}}
};
void test01(){Person p1(18,160);coutp1的年龄为:p1.ageheight*p1.heightp1.height的地址为p1.heightendl;Person p2(p1);coutp2的年龄为:p2.ageheight*p2.heightp2.height的地址为p2.heightendl;
}
int main() {test01();return 0;
}
9.初始化列表
/** 初始化列表* 作用C提供了初始化列表语法用来初始化属性* 语法构造函数():属性1值1,属性2(值2)...{}*/
class Person{
public:string name;int age;Person(string _name,int _age){name_name;age_age;}Person():name(张三),age(18){cout我被初始化了endl;}
};
void test01(){Person person;coutperson.nameperson.name;person.ageperson.ageendl;
}
int main() {test01();return 0;
}10.类对象作为类成员
包含构造函数顺序和析构函数顺序
/** 类对象作为类成员* 类中的成员可以是另一个类的对象我们称为 对象成员** 当其他类对象作为本类成员构造时候先构造类对象再构造自身* 析构函数先释放自己类对象再释放其他类对象*/
class Phone{
public:string pName;Phone(string name){cout我是Phone构造函数endl;pNamename;}~Phone(){cout我是Phone析构函数endl;}
};
class Person{
public :string name;Phone phone;//Phone phonepName 隐式转换法 直接调用 Phone中的构造方法赋值Person(string name,string pName):name(name),phone(pName){cout我是Person构造函数endl;}~Person(){cout我是Person析构函数endl;}
};
void test01(){Person p(张三,苹果max);coutp.namep.name;p.phonep.phone.pNameendl;
}
int main() {test01();return 0;
}
/** 打印输出结果为:* 我是Phone构造函数* 我是Person构造函数* p.name张三;p.phone苹果max* 我是Person析构函数* 我是Phone析构函数*/
11.静态成员变量静态成员函数
成员变量
/** 静态成员** 静态成员就是在成员变量和成员函数前加上关键字static称为静态成员* 静态成员分为* 1.静态成员变量* 所有对象共享同一份数据* 在编译阶段分配内存* 类内声明类外初始化* 2.静态成员函数* 所有对象共享同一个函数* 静态成员函数只能访问静态成员变量** 静态变量不属于某一个对象* 访问方式* 1.通过对象进行访问* 2.通过类名进行访问** 静态成员变量也有访问权限*/
class Person {
public:static int a; //静态成员不能直接赋值 类内声明
};int Person::a 10; //类外初始化void test01() {Person p;
// p.a;cout p.a p.a endl;
}//访问方式
void test02() {//1.通过对象进行访问Person p;cout p.a endl;//2.通过类名进行访问cout Person::a endl;
}int main() {
// test01();test02();return 0;
}
成员函数
/** 静态成员函数** 静态成员函数也有访问权限和普通函数访问权限一样*/
class Person {
public:static int a;int b;//静态成员函数static void func() {a 200; //静态成员函数可以访问 静态成员变量
// b20; //静态成员函数 不可以访问 非静态成员变量cout static void fun 被调用 endl;}
};int Person::a 100;//访问方式
void test01() {//1.通过对象访问Person p;p.func();//2.通过类名访问Person::func();
}int main() {test01();return 0;
}
/** 输出结果:* static void fun 被调用* static void fun 被调用*/12.C对象模型 this
C对象模型
/** C对象模型** 成员变量和成员函数分开存储** 在C中类中的成员变量和成员函数分开存储* 只有非静态成员变量才属于类的对象上*/
class Person {
public://非静态成员变量占用对象空间int a;//静态成员变量不占用对象空间static int b;Person() {a 0;}//函数也不占对象空间所有函数共享一个函数实例void func() {cout a a ;bb endl;}
};
int Person::b12;
void text01() {Person p;p.func();Person p1;p1.func();
}int main() {text01();coutendl;coutthis指针endl;return 0;
}
this指针
/** this指针* this指针指向被调用的成员函数所属的对象* this指针是隐含每一个非静态成员函数内的一种指针* this指针不需要定义直接使用即可** this指针用途* 1.当形参和成员变量同名时可用this指针来区分* 2.在类的非静态成员函数中返回对象本身可以使用 return *this*/
class Person {
public:int age;Person(int age) {//this指针指向被调用的成员函数 所属的对象this-age age;}Person PersonAddAge(Person p) {this-age p.age;return *this;}
};void test() {Person p(15);cout p.age p.age endl;
}void test02() {Person p1(10);Person p2(10);p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1); //链式编程cout p2的年龄为 p2.age endl;
}int main() {
// test();test02();return 0;
}
/** 运行结果:* p2的年龄为40*/空指针访问成员函数
/** 空指针访问成员函数** C中空指针也是可以调用成员函数的但是也要注意有没有用到this指针** 如果用到this指针需要加以判断保证代码的健壮性*/
class Person{
public:void showClassName(){coutthis is a Personendl;}void showPersonAge(){//报错原因传入的指针是NULLif(thisNULL){ //提高代码健壮性return;}coutageageendl; ///coutagethis.ageendl; 属性默认前面有this}int age;
};
void test01(){Person * p NULL;p-showClassName();p-showPersonAge();
}
int main() {test01();return 0;
}
const 修饰成员函数 常对象
/** const 修饰成员函数* 常函数* 1.成员函数后加 const后我们称这个函数为 常函数* 2.常函数内不可以修改成员属性* 3.成员属性声明时加关键字 mutable 后在常函数中依然可以修改* 常对象* 1.声明对象前加 const 称该对象为常对象* 2.常对象只能调用常函数**/
class Person {
public:string m_A;mutable string m_b; //成员属性声明时加关键字 mutable 后在常函数中依然可以修改//this指针的本质 是指针常量 指针的指向是不可以修改的//Person * const this;//在成员函数后面加 const修饰的是this指向让指针指向的值也不可以修改void showPerson() const {
// this-m_A100; //报错不可以修改
// thisNULL; //错误this指针不可以修改指针的指向this-m_b qwe; //变量加入 mutable 关键字可以修改了}void func() {}
};//常对象
void test02() {const Person p; //在对象前加 const变为常对象
// p.m_Aaaa; //报错该值不可以修改p.m_b bbb; //m_b是特殊值mutable关键字 修饰在常对象下也可以修改//常对象只能调用常函数p.showPerson();
// p.func(); //错误常对象不能调用普通函数
}int main() {test02();return 0;
}13.友元
友元让其他类可以访问本类中的私有变量
1全局函数做友元
/** 友元** 在程序里有些私有属性也想让类外特殊的一些函数或者类进行访问就需要用到友元的技术** 友元的目的就是让一个函数或者类访问另一个类中私有成员** 关键字friend** 友元的三种实现:* 1.全局函数做友元* 2.类做友元* 3.成员函数做友元*/
class Building {//goodGay全局函数是 Building 好朋友可以访问 Building中的私有成员//该行代码作用是给 goodGay 全局函数开权限friend void goodGay(Building *building);public:Building() {m_sittingRoom 客厅;m_BedRom 卧室;}string m_sittingRoom; //客厅
private:string m_BedRom;
};//全局函数
void goodGay(Building *building) {cout 好基友的全局函数 正在访问 sittingRoom building-m_sittingRoom endl;cout 好基友的全局函数 正在访问 BedRoom building-m_BedRom endl;}void test01() {Building building;goodGay(building);
}int main() {test01();return 0;
}
2友元类
/** 类做友元*/
class Building;class GoodGay {
public:GoodGay(); //声明构造函数Building *building;void visit(); //参观函数访问Building中的属性
};class Building {//GoodGay 是 Building 的好基友类友元类,所以GoodGay中的对象可以访问Building中的私有成员friend class GoodGay;public:Building();string m_sittingRoom; //客厅
private:string m_BedRoom; //卧室
};Building::Building() {m_sittingRoom 客厅;m_BedRoom 卧室;
}GoodGay::GoodGay() {//创建一个建筑物对象building new Building;
}void GoodGay::visit() {cout 好基友类正在访问 building-m_sittingRoom endl;cout 好基友类正在访问 building-m_BedRoom endl;
}void test01() {GoodGay gg;gg.visit();
}int main() {test01();return 0;
}3成员函数 友元
/** 成员函数做友元*/
class Building;class GoodGay {
public:GoodGay();void visit(); //让visit可以访问Building中私有成员void visit2(); //让visit2不可以访问Building中私有成员Building *building;
};class Building {//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友可以访问本类的私有成员friend void GoodGay::visit();public:string m_sittingRoom; //卧室Building();private:string m_BedRoom; //客厅
};Building::Building() {m_sittingRoom 客厅;m_BedRoom 卧室;
}GoodGay::GoodGay() {building new Building();
}void GoodGay::visit() {cout visit函数正在访问: building-m_sittingRoom endl;cout visit函数正在访问: building-m_BedRoom endl;
}void GoodGay::visit2() {cout visit函数正在访问: building-m_sittingRoom endl;
// cout visit函数正在访问: building-m_BedRoom endl; //报错;visit2()函数没有friend 好朋友权限
}void test01() {GoodGay goodGay;goodGay.visit();
}int main() {test01();return 0;
}14.运算符重载
加号预算符重载
/** 运算符重载概念* 对已有的运算符进行重新定义赋予其另一种功能以适应不同的数据类型。**加号运算符重载* 作用实现两个自定义数据类型相加的运算*/class Person {
public:int m_A;int m_B;//成员函数重载号Person operator(Person p) {Person temp;temp.m_A this-m_A p.m_A;temp.m_B this-m_B p.m_B;return temp;}
};//全局函数重载号
Person operator(Person p1, Person p2) {Person temp;temp.m_A p1.m_A p2.m_A;temp.m_B p1.m_B p2.m_B;return temp;
}void test01() {Person p1;p1.m_A 10;p1.m_B 5;Person p2;p2.m_A 10;p2.m_B 5;Person p3 p1.operator(p2);cout p3.m_A p3.m_A endl;cout p3.m_B p3.m_B endl;}int main() {test01();//全局函数cout 全局函数调用重载号函数 endl;Person p1;p1.m_A 10;p1.m_B 5;Person p2;p2.m_A 10;p2.m_B 5;//p4p102;//本质Person p4 operator(p1, p2);return 0;
}左移运算符重载
/** 左移运算符重载*/
class Person {
public:int a;int b;//重载左移运算符
// void operator(){
//
// }
};//全局函数重载左移运算符
//如果要输出私有成员可以将该函数添加为友元函数
ostream operator(ostream cout, Person p) { //本质 operator(cout,p) 简化 cout pcout p.a p.a ;p.b p.b endl;return cout;
}void test01() {Person p;p.a 10;p.b 20;cout p p endl;
}int main() {test01();return 0;
}
/** 输出结果* p p.a10;p.b20*/递增运算符重载
/** 递增运算符重载*/class MyInteger {friend ostream operator(ostream out, MyInteger myint);public:MyInteger() {num 17;}//重载前置运算符 返回引用是为了一直对一个数据进行递增操作MyInteger operator() {num;return *this;}//重载后置运算符//int 代表的一个占位参数可以用于区分前置和后置递增MyInteger operator(int) {num;return *this;}private:int num;
};//重载左移运算符
ostream operator(ostream out, MyInteger myint) {return out MyInteger object myint.num endl;
}void test01() {MyInteger myint;cout 前置递增: myint endl;cout 后置递增: myint endl;cout 后置递增: myint endl;
}int main() {test01();return 0;
}赋值运算符重载
/** 赋值运算符重载** C编译器至少给一个类添加4个函数* 1.默认构造函数无参函数体为空* 2.默认析构函数无参函数体为空* 3.默认拷贝构造函数* 4.赋值运算符operator,对属性进行值拷贝*/
class Person {
public:int *m_Age;Person(int age) {m_Age new int(age);}~Person() {if (m_Age ! NULL) {delete m_Age;m_Age NULL;}}//重载 赋值运算符Person operator(Person p) {//编译器是提供浅拷贝m_Age p.m_Age; //编译器执行的代码;//应该先判断是否有属性在堆区先释放干净然后再进行深拷贝if (m_Age ! NULL) {delete m_Age;m_Age NULL;}m_Age new int(*p.m_Age);return *this;}
};void test01() {Person p1(19);cout p1的年龄为: *p1.m_Age endl;cout endl;Person p2(20);p2 p1; //赋值操作*p1.m_Age 23;cout p2的年龄为: *p2.m_Age endl;Person p3(30);p3 p2 p1; //链式操作cout p1的年龄为: *p1.m_Age endl;cout p2的年龄为: *p2.m_Age endl;cout p3的年龄为: *p3.m_Age endl;
};int main() {test01();return 0;
}关系运算符重载 !
/** 关系运算符重载** 作用重载关系运算符可以让两个自定义类型对象进行对比操作**/
class Person{
public:string m_Name;int m_Age;Person(string name,int age){m_Namename;m_Ageage;}//operator 重载bool operator(Person p){if(this-m_Name!p.m_Name){return false;}if(this-m_Age!p.m_Age){return false;}return true;}//operator 重载!bool operator!(Person p){if(this-m_Name!p.m_Name){return true;}if(this-m_Age!p.m_Age){return true;}return false;}
};void test01(){Person p1(tom,18);Person p2(tom,18);if(p1p2){coutp1p2endl;}
}
int main() {test01();return 0;
}
函数调用运算符重载
/** 函数调用运算符重载** 函数调用运算符() 也可以重载* 由于重载后使用的方式非常像函数的调用因此称为仿函数* 仿函数没有固定写法非常灵活**/class MyPrint {
public://重载函数调用运算符void operator()(string test) {cout test endl;}
};void test01() {MyPrint myPrint;myPrint(打印这条语句); //使用起来非常像一个函数所以叫仿函数
}int main() {test01();return 0;
}15.继承
(1)继承介绍
/** 继承* 继承是面向对象三大特性之一** 语法class 子类 : 继承方式 父类{}* 子类 也称为 派生类* 父类 也称为 父类** 继承的是共性书写的是个性*/Java页面
//class Java{
//public:
// void header(){
// cout首页、公开课、登录、注册。。。公共头部endl;
// }
// void footer(){
// cout帮助中心、交流合作、站内地图。。。公共底部endl;
// }
// void left(){
// coutjava python c (公共分类列表)endl;
// }
// void content(){
// coutJava学科视频endl;
// }
//};
//
Java页面
//class Python{
//public:
// void header(){
// cout首页、公开课、登录、注册。。。公共头部endl;
// }
// void footer(){
// cout帮助中心、交流合作、站内地图。。。公共底部endl;
// }
// void left(){
// coutjava python c (公共分类列表)endl;
// }
// void content(){
// coutPython学科视频endl;
// }
//};//继承页面实现
//公共页面类
class BasePage {
public:void header() {cout 首页、公开课、登录、注册。。。公共头部 endl;}void footer() {cout 帮助中心、交流合作、站内地图。。。公共底部 endl;}void left() {cout java python c (公共分类列表) endl;}
};class Java : public BasePage {
public:void content() {cout java学科视频 endl;}
};class Python : public BasePage {
public:void content() {cout Python学科视频 endl;}
};void test01() {cout java学科页面如下 endl;Java java;java.header();java.content();java.footer();cout endl;cout python学科页面如下 endl;Python python;python.header();python.content();python.footer();cout endl;
}int main() {test01();return 0;
}2继承方式
/*** 继承方式* 1.公共继承* 2.保护继承* 3.私有继承** return*///公共继承
class Base1 {
public:int a;
protected:int b;
private:int c;
};class Son1 : public Base1 {
public:void func() {a 10; //父类中公共权限到子类中依然是公共权限b 10;//父类中保护权限到子类中依然是保护权限//c10; //访问不到}
};//保护继承
class Base2 {
public:int a;
protected:int b;
private:int c;
};class Son2 : protected Base2 {
public:void func() {a 10; //父类中公共权限到子类中变为 保护权限b 10;//父类中保护权限到子类中依然是保护权限
// c10; //访问不到}
};//私有继承
class Base3 {
public:int a;
protected:int b;
private:int c;
};class Son3 : private Base3 {
public:void func() {a 100; //公共权限到子类变为 私有成员b 100;//保护权限到子类变为 私有成员
// c100; //父类中的成员防蚊不到}
};void test01() {Son1 s1;s1.a 100;//s1.b100; //保护权限类外访问不到
}void test02() {Son2 s2;//s2.a0; //变为了保护权限因此访问不到//s2.b0; //保护权限因此访问不到//s2.c0;//私有权限访问不了
}void test03() {Son3 s;//s.a0; //都是私有成员访问不到//s.b0; //都是私有成员访问不到//s.c0; //都是私有成员访问不到
}int main() {return 0;
}3 继承中的对象模型
/** 继承中的对象模型** 问题从父类继承过来的成员哪些属于子类对象中**/class Base {
public:int a;
protected:int b;
private:int c;
};class Son : public Base {
public:int d;
};void test01() {//父类中所有非静态成员属性都会被子类继承下去//父类中私有成员属性 是被编译器给隐藏了因此是访问不到。但是确实被继承下去了cout size of Son sizeof(Son) endl;
}int main() {test01();return 0;
}
/**打印结果:size of Son16*/4继承中构造和析构顺序
/** 继承中构造和析构顺序** 子类继承父类后当创建子类对象也会调用父类的构造函数** 问题父类和子类的构造和析构顺序是谁先谁后*/
class Base {
public:Base() {cout Base()构造函数 endl;}~Base() {cout Base()~析构函数 endl;}
};class Son : public Base {
public:Son() {cout Son()构造函数 endl;}~Son() {cout Son()~析构函数 endl;}
};void test01() {Son son;
}int main() {test01();return 0;
}
/** 运行结果* Base()构造函数* Son()构造函数* Son()~析构函数* Base()~析构函数*/5继承同名成员处理方式
/** 继承同名成员处理方式** 问题当子类与父类出现同名的成员如何通过子类对象访问到子类或者父类中同名的数据呢** 访问子类同名成员直接访问即可* 访问父类同名成员 需要加作用域**/class Base {
public:int a;Base() {a 100;}void func() {cout Base::func()函数 endl;}void func(int a) {cout Base::func(int a)函数 endl;}
};class Son : public Base {
public:int a;Son() {a 200;}void func() {cout Son::func()函数 endl;}
};void test01() {Son son;cout a son.a endl;//若果通过子类对象访问父类中同名成员需要加作用域cout a son.Base::a endl;son.func();son.Base::func();//如果子类中出现和父类同名的成员函数子类的同名成员会隐藏掉父类中所有同名成员函数//如果想访问到父类中被隐藏的同名函数需要加作用域son.Base::func(100);
}int main() {test01();return 0;
}
//返回结果
//a200
//a100
//Son::func()函数
//Base::func()函数
//Son::func(int a)函数6继承同名静态成员处理方式
/** 继承同名静态成员处理方式** 静态成员和非静态成员出现同名处理方式一样** 访问子类同名成员 直接访问即可* 访问父类同名成员 需要加作用域**/class Base {
public:static int a;
};class Son : public Base {
public:static int a;
};int Base::a 10;
int Son::a 100;void test01() {//1.通过对象来访问Son son;cout son.a son.a endl;cout son.Base::a son.Base::a endl;//2.通过类名来访问cout 通过类名来访问: endl;cout Son.a Son::a endl;cout 通过Son访问Base.a Son::Base::a endl;cout 直接访问Base.a Base::a endl;
}int main() {test01();return 0;
}
/** son.a100* son.Base::a10* 通过类名来访问:* Son.a100* 通过Son访问Base.a10* 直接访问Base.a10*/7多继承语法
/** 多继承语法** C运行一个类继承多个类** 语法class 子类 : 继承方式 父类1 , 继承方式 父类.....** 多继承可能会引发父类中有同名成员出现需要加作用域区分** 注意C实际开发中不建议多继承**/class Base1{
public:int a;Base1(){a10;}
};class Base2{
public:int a;Base2(){a10;}
};class Son:public Base1,public Base2{
public:int c;int d;Son(){c12;d13;}
};void test(){Son s;coutsizeof(s)sizeof (s)endl;//当父类中出现同名成员需要加作用域区分couts.Base1::as.Base1::aendl;couts.Base2::as.Base2::aendl;
}int main() {test();return 0;
}
/** sizeof(s)16* s.Base1::a10* s.Base2::a10*/8菱形继承
/** 菱形继承** 概念* 两个派生类继承同一个基类* 又有某一类同时继承两个派生类* 这种继承被称为菱形继承或者砖石继承** 总结* 菱形继承带来的主要问题是子类继承两份相同的数据导致资源浪费以及毫无意义* 利用虚继承可以解决菱形继承问题**/
//动物类
class Animal {
public:int age;
};//利用虚继承可以解决菱形继承的问题
//继承之前 加上关键字 virtual 变为虚继承
//Animal类称为 虚基类
//虚继承 之后相同名称的变量会共享内存
//羊类
class Sheep : virtual public Animal {
};//驼类
class Tuo : virtual public Animal {};class SheepTuo : public Sheep, public Tuo {};void test01() {SheepTuo sheepTuo;sheepTuo.Sheep::age 18;sheepTuo.Tuo::age 28;cout sheepTuo.Sheep::age sheepTuo.Sheep::age endl;cout sheepTuo.Tuo::age sheepTuo.Tuo::age endl;cout sheepTuo.age sheepTuo.age endl;
}int main() {test01();return 0;
}
/** sheepTuo.Sheep::age28* sheepTuo.Tuo::age28* sheepTuo.age28*/16.多态
1多态基础
/*** 多态** 基本概念* 多态分为两类* 静态多态函数重载 和 运算符重载属于静态多态复用函数名* 动态多态派生类和虚函数实现运行时多态* 静态多态和动态多态区别* 静态多态的函数地址早绑定 - 编译阶段确定函数地址* 动态多态的函数地址晚绑定 - 运行阶段确定函数地址*** 地址早绑定 在编译阶段就确定了地址* 如果想执行让猫说话那么这个函数地址就不能提前绑定需要在运行阶段进行绑定地址晚绑定* 动态多态满足条件* 1.有继承关系* 2.子类重写父类虚函数 重写函数返回值类型 函数名 参数列表 完全相同** 动态多态的使用* 父类的指针或者引用指向子类对象**/class Animal {
public://虚函数virtual void speak() {cout 动物在说话 endl;}
};class Cat : public Animal {
public:void speak() {cout 小猫在说话 endl;}
};//执行说话的函数
//地址早绑定 在编译阶段就确定了地址
//如果想执行让猫说话那么这个函数地址就不能提前绑定需要在运行阶段进行绑定地址晚绑定//动态多态满足条件
//1.有继承关系
//2.子类重写父类虚函数 重写函数返回值类型 函数名 参数列表 完全相同
//
//动态多态的使用
//父类的指针或者引用指向子类对象
void doSpeak(Animal animal) {animal.speak();
}void test01() {Cat cat;doSpeak(cat);
}int main() {test01();return 0;
}2纯虚函数和抽象类
/** 纯虚函数和抽象类** 在多态中通常父类中虚函数的实现是毫无意义的主要都是调用子类重写的内容* 因此可以将虚函数更改为 纯虚函数** 纯虚函数语法virtual 返回值类型 函数名 (参数列表)0;* 当类中有了纯虚函数这个类也称为抽象类** 抽象类特点* 无法实例化对象* 子类必须重写抽象类中的纯虚函数否则也属于抽象类*/class Base {
public://纯虚函数//只要有一个纯虚函数这个类称为抽象类virtual void func() 0;
};class Son : public Base {void func() {cout func函数调用 endl;}
};void test01() {//Base b; //抽象类无法实例化对象//new Base; //抽象类无法实例化对象Son s; //子类必须重写父类的纯虚函数否则不能实例化对象Base *base new Son;base-func();
}int main() {test01();return 0;
}3析构和纯虚析构
/** 虚析构和纯虚析构* 多态使用时如果子类中有属性开辟到堆区那么父类指针在释放时无法调用到子类的析构代码* 解决方式将父类中的析构函数改为虚析构或者纯虚析构** 虚析构和纯虚析构共性:* 可以解决父类指针释放子类对象* 都需要具体的函数实现* 虚析构和纯虚析构区别* 如果是纯虚析构该类属于抽象类无法实例化对象** 虚析构语法* virtual ~类名(){}* 纯虚析构语法* vertual ~类名()0;* 类名::~类名(){}**/class Animal {
public://纯虚函数virtual void speak() 0;//利用虚析构可以解决父类指针释放子类对象时不干净问题//虚析构
// virtual ~Animal(){
// coutAnimal析构函数调用endl;
// }//纯虚虚构//需要声明也需要实现//有了纯虚析构之后这个类也属于抽象类virtual ~Animal() 0;
};//Animal纯虚析构的实现类
Animal::~Animal() {cout Animal纯虚析构函数调用 endl;
}class Cat : public Animal {
public:string *name;Cat(string aname) {name new string(aname);}virtual void speak() {cout *name 小猫在说话 endl;}~Cat() {if (name ! NULL) {cout cat析构函数调用 endl;delete name;name NULL;}}
};void test01() {Animal *animal new Cat(Tom);animal-speak();delete animal;
}int main() {test01();return 0;
}/** Tom小猫在说话* cat析构函数调用* Animal纯虚析构函数调用*/
