1.父类Base.h

ifndef BASE_H

define BASE_H

include "algogeocal_global.h"

include <QObject>

class ALGOGEOCALSHARED_EXPORT CalPara
{
public:
double Distance;
CalPara()
{
this->Distance = 10;
}
CalPara& operator = (const CalPara& para)
{
this->Distance = para.Distance ;
return *this;
}
};

class ALGOGEOCALSHARED_EXPORT Base : public QObject
{
Q_OBJECT
public:
enum MachineType
{
Machine_A,
Machine_B
};
virtual void setMachineType(MachineType type) {}
virtual void startCalculate(){}
signals:
void sgnl_TransPara(CalPara);
};

2.子类Sun.h

include "Base.h"

struct Point
{
double u;
double v;
};
class Sun : public Base
{
public:
Sun();
~Sun();
void setMachineType(MachineType type);
void startCalculate();
private:
void CoordinateTransform(const Point *p, double angle, Point *p_new);
private:
MachineType m_MachineType;
}

3.子类Sun.cpp

include "Sun.h"

Sun::Sun()
{}
Sun::~Sun()
{}
void Sun::setMachineType(MachineType type)
{
m_MachineType = type;
}
void Sun:: startCalculate()
{
double Distance;
if(m_MachineType ==Machine_A)
{
Distance=20;
}
CalPara p;
p.Distance = Distance ;
emit sgnl_TransPara(p);
}
4.父类、子类、友元类总结
1)一个类里的成员属性可分为public、private、protected。
我公开的东西，大家都可以访问；我保护的东西，我，我儿子和我的朋友可以访问，我的隐私，只有我和我的朋友可以访问。

图片.png
在C++里，一个类的所有成员，该类的友元类friend class都可以访问。而private成员，只有友元类可以访问使用。
图片.png

2)友元类
friend class是单向的，不具备传递性，你在设计类的时候，如果有些属性你不希望暴露给所有人，但又不得不让某些指定的模块使用，那就把这些成员划分到private属性里，同时把需要访问这些成员的模块声明为该类的友元类或友元函数。
class Base{
public:
int GetMyName();
protected:
double GetMyMoney();
private:
std::string GetMySecret();
friend class MyFriend;
};

class MyFriend{
public:
std::string TalkToEveryone(){
Base base;
return base.GetMySecret();
}
};
3)父类和子类之间，牢记保护\protected这个词。所有protected属性的成员，都是留给儿子的。而外人可用不到。在设计类的时候，如果有些属性你不希望暴露给所有人，但你希望给子类留着，那就把这些成员都划分到protected属性里。
class Base{
public:
int GetMyName();
protected:
double GetMyMoney();
private:
std::string GetMySecret();
};
class MySon:public Base{
public:
void SpendMoney(){
double money = GetMyMoney();
findGirls(money);
}
};
4)继承分级别的，C++里对类的继承分为public继承，protected继承，private继承三种，三者的访问权限也是由低到高的。在按照某种权限方式继承时，会将权限低于自己的成员提升至跟自己同一级别，而无法将权限高于自己的成员拉低。

图片.png