Qt之C++
类的定义
C语言的灵魂是指针
C++的灵魂是类，类可以看出C语言结构体的升级版，类的成员可以是变量，也可是函数。
class Box
{
public://确定类成员的访问属性
double length;//长
double breadth;//宽度
double heigth;//高度
};
定义对象
对象是类的实例化
直接定义
Box mybox;//Box是类，mybox是对象
在堆中定义
Box *youbox = new Box;//在堆中定义对象youbox
delete youbox;//删除对象，释放堆里面的内存
访问对象中的成员
类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问。
//普通变量通过. 指针通过->
Box mybox;//Box是类，mybox是对象
mybox.length = 10;
Box *youbox = new Box;//在堆中定义对象youbox
youbox->length = 20;
delete youbox;//删除对象，释放堆里面的内存
类成员函数
类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。
类成员函数可以在类内部定义，也可以在类外部定义
内部定义
class Box
{
public://确定类成员的访问属性
double length;//长
double breadth;//宽度
double heigth;//高度
//函数-表行为
double getVolume(void)
{
return length * breadth * heigth;
}
};
外部定义（使用比较多）
class Box
{
public://确定类成员的访问属性
double length;//长
double breadth;//宽度
double heigth;//高度
//函数-表行为
double getVolume(void);
};
//:: 运算符之前必须使用类名
double Box::getVolume(void)
{
return length * breadth * heigth;
}
例子
#include <iostream>
using namespace std;
class Box
{
public://确定类成员的访问属性
double length;//长
double breadth;//宽度
double heigth;//高度
//函数-表行为
double getVolume(void);
void setLength(double len);
void setBreadth(double bre);
void setHeight(double hei);
};
//:: 运算符之前必须使用类名
double Box::getVolume(void)
{
return length * breadth * heigth;
}
void Box::setLength(double len)
{
length = len;
}
void Box::setBreadth(double bre)
{
breadth = bre;
}
void Box::setHeight(double hei)
{
heigth = hei;
}
int main()
{
double volume = 0.0;//用于存储体积
Box *youbox = new Box;//在堆中定义对象youbox
youbox->setLength(6.0);
youbox->setHeight(7.0);
youbox->setBreadth(8.0);
volume = youbox->getVolume();
cout << "youbox的体积: " << volume << endl;
delete youbox;//删除对象，释放堆里面的内存
return 0;
}
类的访问修饰符
关键字 public、private、protected 称为访问修饰符。
class Base {
public:
// 公有成员
//公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值
protected:
// 受保护成员
//私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。
private:
// 私有成员
//protected（受保护）成员变量或函数与私有成员十分相似，但有一点不同，protected（受保护）成员在派生类（即子类）中是可访问的。
};
类的构造函数和析构函数
构造函数
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
构造函数：假如我们定义了构造函数，就会触发这个构造函数。
构造函数也可以进行重载。
#include <iostream>
using namespace std;
class Box
{
public://确定类成员的访问属性
double length;//长
double breadth;//宽度
double heigth;//高度
Box()//构造函数（没有带参数）
{
length = 1;
breadth = 1;
heigth = 1;
}
Box(int a)//带参数的构造函数(重载)
{
length = 2;
breadth = 2;
heigth = 2;
}
//函数-表行为
double getVolume(void);
void setLength(double len);
void setBreadth(double bre);
void setHeight(double hei);
};
//:: 运算符之前必须使用类名
double Box::getVolume(void)
{
return length * breadth * heigth;
}
void Box::setLength(double len)
{
length = len;
}
void Box::setBreadth(double bre)
{
breadth = bre;
}
void Box::setHeight(double hei)
{
heigth = hei;
}
int main()
{
double volume = 0.0;//用于存储体积
// Box *youbox = new Box;//在堆中定义对象youbox
//想要初始化时使用带参数的构造函数时
int a;
Box *youbox = new Box(a);//在堆中定义对象youbox
volume = youbox->getVolume();//使用的默认值
cout << "youbox的体积: " << volume << endl;
youbox->setLength(6.0);
youbox->setHeight(7.0);
youbox->setBreadth(8.0);
volume = youbox->getVolume();
cout << "youbox的体积: " << volume << endl;
delete youbox;//删除对象，释放堆里面的内存
return 0;
}
初始化的另一种方式
析构函数
析构函数：假如我们定义了析构函数，当对象被删除或者生命周期结束的时候，就会
触发析构函数。
类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
class Box
{
public://确定类成员的访问属性
double length;//长
double breadth;//宽度
double heigth;//高度
Box()//构造函数（没有带参数）
{
length = 1;
breadth = 1;
heigth = 1;
}
Box(int a)//带参数的构造函数(重载)
{
length = 2;
breadth = 2;
heigth = 2;
}
~Box()//析构函数
{
cout<<"Box is end"<<endl;
}
//函数-表行为
double getVolume(void);
void setLength(double len);
void setBreadth(double bre);
void setHeight(double hei);
};
继承
继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。
当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。
类的继承允许我们在新的类里面继承父类的public还有protected部分，private是不能被继承的。
当我们觉得这个类不好的时候，可以使用类的继承，添加我们需要的功能。
// 基类
class Animal {
// eat() 函数
// sleep() 函数
};
//派生类
class Dog : public Animal {
// bark() 函数
};
#include <iostream>
using namespace std;
//基类Shape(范围很大，描述模糊)
class Shape
{
public://接口函数
void setwidth(int w)
{
width = w;
}
void setHeight(int h)
{
height = h;
}
public://构造函数
Shape() {}
protected:
int width;
int height;
};
//基类 PaintCost
class PaintCost
{
public:
int getCost(int area)
{
return area*70;
}
//构造函数
public:
PaintCost() {}
};
//派生类
class Rectangle: public Shape,public PaintCost
{
public:
int getArea()
{
return (width*height);
}
};
int main()
{
Rectangle *Rect = new Rectangle;
int area;
Rect->setwidth(5);
Rect->setHeight(7);
area = Rect->getArea();
//输出对象的面积
cout << "Total area:"<<Rect->getArea() << endl;
//输出总花费
cout<<"Total paint const: $"<<Rect->getCost(area)<<endl;
return 0;
}
虚函数和纯虚函数
用virtual来修饰，虚函数是用在类的继承上的。
可以预留接口，实现分工合作。
![Oracle-ORA-00600:[ktspffbmb:objdchk_kcbnew_3]](https://img-blog.csdnimg.cn/img_convert/6c162faf67fd114a01ea6f26f376c77e.png)
