类型转换，类与类之间的转换，继承关系，继承与静态变量，子类父类重名，多继承，虚基类

常量的基本类型转换，例如：int num(10.8),这种方式是隐式转换。
通过函数的构造函数实现转换。
类类转换函数，当构造函数不能将类型转换成基本类型时。所以就有了类类转换函数，通过这种方式。

案例：

#include <iostream>class fushu
{
public://通过加explicit的这种方式避免隐式转换，避免引发歧义explicit fushu(int num){x = num;y = num;}void print(){std::cout << x << "+" << y << std::endl;}//下面对这个声进行明实现,重载int,这里是类型转换函数operator int();//不支持友元，仅仅支持成员函数operator double(){return (double)(x + y);}
protected:
private:int x;int y;
};//下面是：类类之间的转换函数
fushu::operator int()
{return x * y;
}void main()
{int num(100.9);fushu fushu1(num);//构造函数fushu1.print();//下满如果不带（int）将报错误提示//类型转换可以把一个自定义类型当作基本数据类型来计算int data = (int)fushu1 + 10;//这一句的运行结果是：10000+10std::cout << data << std::endl;std::cin.get();
}//转换有两种方式：1、赋值;2.使用（）调用构造进行转换
void main2()
{int num(100.9); //这里调用了int类型的构造fushu fushu1(num);  //构造函数int data(fushu1);//转换，调用：fushu::operator int()std::cout << data << std::endl;//通过下面几句走类类转换函数（fushu::operator int()）data2-->data5,下面几种方式得到到的结果都是10000int data2 = fushu1; std::cout << data2 << std::endl;int data3 = (int)fushu1;std::cout << data3 << std::endl;int data4 = int(fushu1);std::cout << data4 << std::endl;int data5 = (int(fushu1));std::cout << data5 << std::endl;
}void main1()
{//基本数据类型转换，这里是隐式类型与显式转换，是否带有类型转换符int num(10.8);//调用构造函数，调用explicit fushu(int num)这个构造函数fushu fushu1 = (fushu)10.8;//调用之后的结果是：10fushu1.print();   //通过static_cast的方式进行类型转换，这种方式同样走了构造函数fushu fushu2 = static_cast<fushu>(12.8);fushu2.print();   //调用之后的结果是：10 fushu fushu3 = (fushu)10;//构造函数//因为一个类不可能转换成为int类型的，所以找重载int的fushu::operator int()int numA = fushu3;  //这里调用之后的结果是100std::cout << numA << std::endl;std::cin.get();
}

4.类与类之间的类型转换

#include<iostream>class mianji
{
public://通过友元，让fushu这个类可以调用这两个类的变量friend class fushu;mianji(){this->cx = 0;this->cy = 0;}void setxy(int a,int b){this->cx = a;this->cy = b;}
private:int cx;int cy;
};class fushu
{
public://友元可以访问私有变量friend class mianji;fushu(mianji mianji1){this->x = mianji1.cx;this->y = mianji1.cy;}void print(){std::cout << x << "+" << y << std::endl;}//使用operator+类的方式进行转换,类与类之间的类型转换operator mianji(){mianji temp;temp.cx = x;temp.cy = y;return temp;}
private:int x;int y;
};void main()
{mianji mianji1;  //这里调用了//这里调用了fushu的有参构造函数fushu fushu1 = (fushu)mianji1;  fushu1.print();   //结果：0+0fushu fushu2(mianji1);//调用了构造函数fushu2.print();  //结果：0+0mianji mianji2;//设置x,y的值mianji2.setxy(10, 20);fushu1 = mianji2;fushu1.print(); //结果：10+20std::cin.get();
}

5.类和类之间的关系：

案例：

#include "mainwindow.h"
#include <QApplication>#include<stdlib.h>//第一种关系，某一个类作为某一个类的部件
class mywindow
{
public:MainWindow w;//这时一种包含关系
};class show
{
public://部分的使用一个类，调用一个类void showwindow(MainWindow  & w){w.show();}
};//继承是通过加上：的方式实现
class newwindow:public MainWindow
{
public://增强一个功能void run(char *str){system(str);}
};//测试继承
int mainA(int argc, char *argv[])
{QApplication a(argc, argv);newwindow new1;new1.show();//运行的结果是显示了计算器窗口new1.run("calc");return a.exec();
}//通过包含的方式进行调用一个类
int main(int argc,char *argv[])
{QApplication a(argc,argv);mywindow my1;show show1;show1.showwindow(my1.w);return a.exec();
}

6.继承之间的关系

A：共有(public)继承 à可以无限传承，原来是共有的public继承之后仍然共有，私有的还是私有的。

B：私有(private)继承，只能继承一代，一代之后不可以继承了。不管父类里共有的还是私有的，都变成私有的了。

C：保护（protected）继承，共有成员全部变成了保护成员，保护成员不发生变化，可以无限传承。

创建三个类来描述这三种关系：

创建人类，代码如下：

头文件ren.h：

#pragma once
class ren
{
public:ren();~ren();long long selfnum;
private:char *name;bool isman;
protected:int money;int house;
};
//设计一个类，可以无限传承美德，私有资产
//公有继承  ->无限传承，公有，保护不发生 70%//只能继承一代，
//私有继承 ->传一代就断了，公有，私有都变成私有  //保护继承
//保护继承->公有成员全部变成保护成员  保护成员不发生变化，可以无限传承ren.cpp
#include "ren.h"
ren::ren()
{
}ren::~ren()
{
}

创建月光族

yueguang.h

#pragma once
#include "ren.h"
class yueguang:public ren  //这里用月光族来模拟共有的特征
{
public:yueguang();~yueguang();
};
yueguang.cpp
#include "yueguang.h"
yueguang::yueguang()
{
}
yueguang::~yueguang()
{
}

创建啃老族（父类的东西都变成自己的了，并且子辈没有东西）：

kenlao.h

#pragma once
#include "ren.h"
class kenlao:private ren  //模拟私有继承
{
public:kenlao();~kenlao();
};kenlao.cpp
#include "kenlao.h"kenlao::kenlao()
{
}kenlao::~kenlao()
{
}

模拟可传承的特征：

chuancheng.h

#pragma once
#include "ren.h"
class chuancheng:protected ren  //模拟可供传承的类
{
public:chuancheng();~chuancheng();
};chuancheng.cpp
#include "chuancheng.h"chuancheng::chuancheng()
{
}chuancheng::~chuancheng()
{
}

7. //子类的内部可以访问父类的被保护的num,通过::num的方式进行调用

//此外还可以通过这种方式访问父类的方法。如果不写这个就是调用本类的方法

std::cout <<(this->coder::num) << std::endl;

通过另外一个案例说明继承的三种关系：

coder.h

#pragma once#include<iostream> //加了这一句之后std::cout才可以用
class coder
{
private:char *str;
public:coder();~coder();void girlfriend();void coding();
protected:int num;
};
coder.cpp
#include "coder.h"coder::coder()
{std::cout << "coder create" << std::endl;str = "锄禾日当午";num = 100;
}coder::~coder()
{std::cout << "coder delete" << std::endl;
}void  coder::girlfriend()
{std::cout << "一般都会写代码，可以创建一个对象，可是没有对象" << std::endl;
}void  coder::coding()
{std::cout << "加班加点熬夜" << std::endl;
}

公有继承

cppcoder.h

#pragma once
#include "coder.h"//使用public继承的时候
//父类的私有成员，不可以访问
//父类的保护成员，共有成员都可以访问
//共有继承，不影响保护成员，共有成员属性变化
class cppcoder:public coder
{
public:cppcoder();~cppcoder();void coding();void ui();
};
cppcoder.cpp
#include "cppcoder.h"cppcoder::cppcoder()
{std::cout << "cpp coder create" << std::endl;
}cppcoder::~cppcoder()
{std::cout << "  cpp  coder delete" << std::endl;
}void cppcoder::ui()
{std::cout << "QT真蛋疼" << std::endl;//子类的内部可以访问父类的被保护的num,通过::num的方式进行调用//此外还可以通过这种方式访问父类的方法。如果不写这个就是调用本类的方法std::cout << (this->coder::num) << std::endl;
}void cppcoder::coding()
{std::cout << "CPP真蛋疼" << std::endl;
}
保护继承：
ccoder.h
#pragma once
#include "coder.h"//父类的私有成员，不可以被继承
//父类的保护成员，共有成员内部可以访问//protected继承的时候：保护成员，共有成员都会变成保护成员
class ccoder:protected coder
{
public:ccoder();~ccoder();
};
ccoder.cpp
#include "ccoder.h"ccoder::ccoder()
{
}ccoder::~ccoder()
{
}私有继承
javacoder.h
#pragma once
#include "coder.h"//父类的私有成员，不可以访问
//使用private继承之后，父类的保护成员，共有成员内部可以访问
//私有继承，共有成员，保护成员都变成私有成员
class javacoder:private coder
{
public:javacoder();~javacoder();
};javacoder.cpp
#include "javacoder.h"javacoder::javacoder()
{//父类的被进程的变量可以在子类中可以访问，类外不可以被访问this->num = 100;
}javacoder::~javacoder()
{
}
主函数
#include<iostream>
#include "coder.h"
#include "cppcoder.h"
#include "javacoder.h"void main1()
{//通过new关键字创建一个类的指针javacoder *pjava = new javacoder;//这时候的结果是：coder create,说明要调用父类的构造函数std::cin.get();
}void main2()
{cppcoder *ptansheng = new cppcoder;coder *pcode = new coder;ptansheng->ui();std::cin.get();//运行结果：//coder create//cpp coder create//coder create//QT真蛋疼//100
}void main3()
{//父类的指针，接受子类指针的地址coder *pcode = new cppcoder;pcode->coding();//通过reinterpret_cast进行类型转换cppcoder *pcppcoder = reinterpret_cast<cppcoder *>(pcode);pcppcoder->coding();//通过下面的方式实现获得指针类型std::cout << typeid(pcode).name() << std::endl;std::cout << typeid(pcppcoder).name() << std::endl;std::cin.get();//运行结果：//coder create//cpp coder create//加班加点熬夜//CPP真蛋疼//class coder *//class cppcoder *
}void main()
{cppcoder *ptansheng = new cppcoder;ptansheng->girlfriend();ptansheng->ui();//当子类与父类中函数同名的时候，会覆盖父类中的函数ptansheng->coding();//每一个子类都会生成一个默认的父类对象//调用父类的同名方法可以通过下面的方式实现ptansheng->coder::coding();delete ptansheng;std::cin.get();//运行结果：//coder create//cpp coder create//一般都会写代码，可以创建一个对象，可是没有对象//QT真蛋疼//100//CPP真蛋疼//加班加点熬夜//  cpp coder delete//coder delete
}

8.子类父类重名问题

#include<iostream>class father
{
public:int num;void print(){std::cout << num << std::endl;}father(){num = 99;}
};class son :public father
{
public:int num;void print(){std::cout << num << std::endl;}//子类覆盖父类son(){num = 89;}
};void main()
{son *pson = new son;pson->print();//第一种方式调用父类中的方法pson->father::print();//第二种方式调用父类中的方法，将子类转换强转成为父类的指针father *p = reinterpret_cast<father *>(pson);p->print();std::cin.get();
}
运行结果：
89
99
99

9.基类的初始化

#include<iostream>class myclass
{
public:myclass() :x(0){//x = 0;std::cout << "myclass  init without num" << std::endl;}myclass(int num) :x(num){//x = num;std::cout << "myclass init with num" << std::endl;}
protected:
private:int x;
};class myziclass :public myclass
{
public:myziclass(){std::cout << "myziclass  init without num" << std::endl;}//第一个初始化的是父类，第二个，第三个是初始化本类的x,ymyziclass(int num) :myclass(num), x(num + 1), y(num + 2){std::cout << "myziclass  init with num" << std::endl;}int x;int y;
};void main()
{//指定构造函数myziclass *p = new myziclass(10);std::cin.get();
}

10.简单单继承的案例

#include <iostream>
#include<math.h>class dian
{
public:friend class xian;dian(int a, int b, int c) :x(a), y(b), z(c){}void print(){std::cout << "x=" << x << ",y=" << y << ",z=" << z << std::endl;}
private:int x;int y;int z;
};//继承没有意义,包含
class xian
{
public:xian(dian dianx, dian diany) :dian1(dianx), dian2(diany){}double getlength(){double length = 0;length = sqrt((dian1.x - dian2.x)*(dian1.x - dian2.x) + (dian1.y - dian2.y)*(dian1.y - dian2.y) + (dian1.z - dian2.z)*(dian1.z - dian2.z));return length;}dian dian1;dian dian2;
protected:
private:
};class yuan :public xian
{
public:yuan(dian dianx, dian diany) :xian(dianx, diany){}double getmianji(){return 3.1415926* (this->getlength())*(this->getlength());}double zhouchang(){return 3.1415926 * 2 * (this->getlength());}
};class qiu :public yuan
{
public:qiu(dian dian1, dian dian2) :yuan(dian1, dian2){}double getmianji(){return 3.1415926* (this->getlength())*(this->getlength()) * 4;}double gettiji(){return 4 / 3.0*3.1415926* (this->getlength())* (this->getlength())* (this->getlength());}
};void main()
{dian dian1(0, 0, 1);dian dian2(0, 0, 6);dian1.print();dian2.print();xian xian1(dian1, dian2);std::cout << xian1.getlength() << std::endl;yuan yuan1(dian1, dian2);std::cout << yuan1.getmianji() << std::endl;std::cout << yuan1.zhouchang() << std::endl;qiu qiu1(dian1, dian2);std::cout << qiu1.gettiji() << std::endl;std::cout << qiu1.getmianji() << std::endl;std::cin.get();
}

11.继承与静态变量

#include<iostream>class myclass
{
public:int data;static int num;//声明静态变量存在myclass(){num++;//共享,统计对象的数目}static void print(){//this->data;//静态函数无法使用this指针//data = 10;std::cout << num << std::endl;}};int myclass::num = 0;//静态变量初始化//private私有继承，无法传承到下一代
class ziclass :protected myclass
{void run(){this->print();this->num;}};class sunclass :protected  ziclass
{void goandrun(){this->ziclass::myclass::print();}};void main()
{ziclass *p = new ziclass;ziclass z1;sunclass *ps = new sunclass;//int a;//p->num;           //这种方式同样不行，说明使用protected的之后，不可以再使用了//p->print();//p->myclass::num;  //这里不能使用，因为ziclass使用protected从class继承//p->myclass::print();//ps->print();//ps->ziclass::myclass::print();std::cin.get();
}

12.继承QT中的QLabel，并且增强其功能，创建一个QTGUI项目，修改main.cpp.

#include<QApplication>
#include<QLabel>
#include<stdlib.h>class mylabel:public QLabel
{
public:mylabel(char *str):QLabel(str){}void run(char *str){system(str);}
};int main(int argc, char *argv[])
{QApplication a(argc, argv);mylabel my1("12345ABC");my1.show();my1.run("notepad");return a.exec();
}

13：多继承，将很多东西的东西集成在一起，多继承案例如下：

#include <iostream>
#include<stdlib.h>class A{};class B{};class myclass1
{
public:void run(char *str){system(str);}myclass1(){std::cout << "myclass1 is create" << std::endl;}~myclass1(){std::cout << "myclass1 is delete" << std::endl;}
};class myclass2
{
public:int add(int a, int b){return a + b;}myclass2(){std::cout << "myclass2 is create" << std::endl;}~myclass2(){std::cout << "myclass2 is delete" << std::endl;}
};class myclass :public myclass1, public myclass2, public A, public B
{
public:void print(char *str){std::cout << str << std::endl;}myclass(){std::cout << "myclass is create" << std::endl;}~myclass(){std::cout << "myclass is delete" << std::endl;}
};void main()
{myclass *pmy1 = new myclass;delete pmy1;myclass my1;my1.run("tasklist");my1.myclass1::run("ipconfig");std::cout << my1.add(10, 20) << std::endl;std::cout << my1.myclass2::add(19, 20) << std::endl;my1.print("12345");std::cin.get();
}

14.为了在创建类的时候不多次创建父类，使用虚基类技术，也就是说加上virtual关键字，案例如下：

#include<iostream>class obj
{
public:int num;obj(int data) :num(data){std::cout << "obj  create\n";}obj(){num = 0;std::cout << "obj create\n";}~obj(){std::cout << "obj delete\n";}
};//下面使用了virtual（虚基类的）
class Aobj :virtual public obj
{
public:Aobj(int data) :obj(data){std::cout << "Aobj create\n";}~Aobj(){std::cout << "Aobj delete\n";}
};//多个类公共继承一个类的时候，为了避免重复生成父类，加上virtual
class  Bobj : virtual public obj
{
public:Bobj(int data) :obj(data){std::cout << "Bobj  create\n";}~Bobj(){std::cout << "Bobj  delete\n";}
};class ABobj :public Aobj, public Bobj
{
public:ABobj(int x, int y) :Aobj(x), Bobj(y){std::cout << "ABobj  create\n";}ABobj(int z) :Aobj(z), Bobj(z){std::cout << "ABobj  create\n";}~ABobj(){std::cout << "ABobj  delete\n";}
};void main()
{ABobj *p = new ABobj(10);std::cout << p->Aobj::obj::num << "\n";std::cout << p->Bobj::obj::num << "\n";delete p;std::cin.get();
}

15：QT中的多继承实现

#include "mainwindow.h"
#include <QApplication>
#include <QPushButton>
#include <QLabel>class zajiao :public MainWindow,public QLabel,public QPushButton
{
public:zajiao(char *str):QLabel(str),QPushButton(str){this->MainWindow::setWindowTitle(str);}~zajiao(){}
};int main(int argc, char *argv[])
{QApplication a(argc, argv);zajiao zajiao1("ABCDEF12345");zajiao1.QPushButton::show();zajiao1.QPushButton::move(0,0);zajiao1.QLabel::show();zajiao1.MainWindow::show();return a.exec();
}

类型转换，类与类之间的转换，继承关系，继承与静态变量，子类父类重名，多继承，虚基类相关推荐

C++ 多继承类虚基类
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明. 本文链接:https://blog.csdn.net/jzj_c_love/article/d ...
C++虚继承中的虚基类表
虚继承主要解决多重继承会在子类中存在多份拷贝的问题,这不仅浪费空间,而且存在二义性. 在之前的 C++ 继承中已经说过虚继承基本概念,这里不再赘述.这篇文章主要探究虚继承的原理.文章中多处给出了类实例 ...
【C++】继承和派生、虚继承和虚基类、虚基类表和虚基类指针
继承和派生.虚继承和虚基类.虚基类表和虚基类指针继承和派生继承概述继承基本概念派生类中的成员继承的内容派生类定义派生类访问控制对象构造和析构对象构造和析构的调用顺序继承中的构造和析 ...
多继承中虚基类构造函数的一种调用规则
规则:如果父类中有虚基类(A),且有一个直接基类(B)是虚基类的子类,那么子类(C或D)若不显式调用虚基类的有参数构造函数,它的直接基类(B)即使在构造列表中调用了非默认构造函数,那么也会直接调用虚基 ...
C++中虚基类相关的知识点
目录前言虚基类的作用虚基类的声明虚基类的初识化前言在上一篇的文章中我们知道了, C++语言是知识多继承的,并且一个子类可以有多个父类子类,拥有所有父类的成员变量,子类会继承父类的所有成员函 ...
虚基类及虚基类的定义使用
虚基类在前面学过的继承过程中,不知道大家有没有想到这种情况:在多继承关系中,如果一个派生类的从两个父类那里继承过来,并且这两个父类又恰恰是从一个基类那里继承而来.那这样就麻烦了,因为你可能继承了两份 ...
C++中的各种“虚“-- 虚函数、纯虚函数、虚继承、虚基类、虚析构、纯虚析构、抽象类讲解
C++中的各种"虚" 1. 菱形继承 1.1 虚继承 && 虚基类 1.2 虚基类指针(vbptr)&& 虚基类表(vbtable) 2. 多态 2 ...
C++:94---类继承（菱形继承、虚继承(virtual虚基类)）
一.菱形继承在介绍虚继承之前介绍一下菱形继承概念:A作为基类,B和C都继承与A.最后一个类D又继承于B和C,这样形式的继承称为菱形继承菱形继承的缺点: 数据冗余:在D中会保存两份A的内容访问不 ...
继承与派生(Part Ⅲ)——多重继承虚基类
虚基类虚基类的作用如果一个派生类有多个直接基类,而这些直接基类又有一个共同的基类,则在最终的派生类中会保留该间接共同基类数据成员的多份同名成员.在引用这些同名的成员时,必须在派生类对象名后增加直接 ...

类型转换，类与类之间的转换，继承关系，继承与静态变量，子类父类重名，多继承，虚基类

类型转换，类与类之间的转换，继承关系，继承与静态变量，子类父类重名，多继承，虚基类相关推荐

最新文章

热门文章