【QT】C++基础

引言

目前打算一周内学习QT的基本使用，从此篇"C++基础"文章开始记录分享学习经验。
在此系列开始之前，非常推荐北京讯为的QT网课：【北京迅为】嵌入式学习之QT学习篇
此篇文章的内容也是来自于此，仅作为笔记分享。

C++及其各种定义（一）

C++是面向对象的，什么是面向对象，什么是面向过程？

举例 计算a+b的值： C语言，直接计算a+b；C++，先将a+b封装，封装到类里面形成一个方法，然后再通过这个类去调用a+b，面向对象就是给a+b穿上了衣服，不是直接的计算，方便移植和使用。

类是C++的灵魂，而什么是类呢？

语言结构体的升级版。C语言结构体里面可以包含若干个变量，成员变量的类型也可以不同；类的成员不仅可以是变量，也可以是函数，而通过类定义出来的成员就是对象。类可以看成C语言结构体的升级版。C语言结构体里面可以包含若干个变量，成员变量的类型也可以不同；类的成员不仅可以是变量，也可以是函数，而通过类定义出来的成员就是对象。

如何定义一个类？

关键字： class

点击查看代码

using namespace std;  // 添加命名空间
class student
{
public:
    char name[64];
    char age;
}

什么是对象？

对象是类的实例化对象是类的实例化。

如何定义一个对象

1. 直接定义：

点击查看代码

student my; // 类：student；对象：my

2. 堆里面定义：

点击查看代码

student *my = new student;

删除堆里面定义的对象3. 删除堆里面定义的对象：

点击查看代码

delete my; // 用于释放堆里面的内存

怎么访问类的成员？

通变量通过“.访问方法和C语言一样，普通变量通过“.”来访问，指针用“->”来访问。

点击查看代码

student my;
student *you = new student;

my.age = 18;
you->age = 20;

cout << my.age << endl;
cout << you->age << endl;

如何在类里声明一个函数？

第一步：在类里面声明一个函数
第二步：实现这个函数（可在类的里面，也可在类的外面）
第三步：访问这个函数（访问函数和访问变量是一样的）

1. 直接在类的里面实现

点击查看代码

using namespace std;  // 添加命名空间
class student
{
public:
    char name[64];
    int age;

    void test(){
        cout << 123 << endl;
    };
};

2. 在类的外部进行实现

点击查看代码

using namespace std;  // 添加命名空间
class student
{
public:
    char name[64];
    int age;

    void test();
};

void student:: test(){	// 表示属于这个类里面的函数，不加的话就会被识别成普通函数。
    cout << 123 << endl;
};

类的访问修饰符是什么

类的访问修饰符就是对类的成员进行权限管理。

表示权限公开，任何人都能访问。
private：表示函数和变量只能public：表示权限公开，任何人都能访问。
private：表示函数和变量只能自己在自己的类里面访问自己，不能通过对象来访问（其实可以强行访问）。

点击查看代码

using namespace std;  // 添加命名空间
class student
{
public:
    void test();
private:
    int test1;
};

void student:: test(){
    test1 = 30;
    cout << test1 << endl;
};

int main()
{
    my.test();
    return 0;
}

protected：也表示函数和变量只能自己在自己的类里面访问自己，但是可以被派生类来访问。

C++及其各种定义（二）

类函数的重载特性

类函数的重载特性就是可以在函数内定义同名的函数，但是参数不同的函数。
重载函数在调用的时候，会根据参数的类型去匹配相应的类型去调用。

点击查看代码

using namespace std;  // 添加命名空间
class student
{
public:
    void test();
    void test(int a);
};
void student:: test(){
    test1 = 30;
    cout << test1 << endl;
};

void student:: test(int a){
//    test1 = 30;
    cout << a << endl;
};

int main()
{
    student my;
    my.test(100);
    return 0;
}

构造函数和析构函数是什么？

析构函数：假如定义了析构函数，当对象被删除或者生命周期结束的时候，就会触发析构函数。
构造函数：假如定义了构造函数，当对象被创建的时候，就会触发构造函数。

如何定义析构函数和构造函数？

1.构造函数和析构函数的名字必须与类名一样。
2.析构函数要在前面加上一个“~”，而构造函数不用。

点击查看代码

using namespace std;  // 添加命名空间
class student
{
public:
    student();  // 构造函数
    ~student(); // 析构函数
};

student::student(){ // 构造函数是在对象被创建的时候触发
    cout << "hello!" << endl;
}

student::~student(){ // 析构函数是在对象被删除或者生命周期结束的时候触发
    cout << "bye!" << endl;
}

int main()
{
    student my;     // 创建第一次对象
    student *you = new student; //创建第二次对象

    delete you; // 删除对象，触发析构函数
    return 0;   // return 0 后对象被删除，析构函数触发
}

构造函数是可以被重载的，而析构函数不能被重载。

点击查看代码

using namespace std;  // 添加命名空间
class student
{
public:
    student();  // 构造函数
    student(int b);  // 构造函数重载
    ~student(); // 析构函数
};

student::student(){ // 构造函数是在对象被创建的时候触发
    cout << "hello!" << endl;
}

student::student(int b){ // 重载构造函数
    cout << b << endl;
}

student::~student(){ // 析构函数是在对象被删除或者生命周期结束的时候触发
    cout << "bye!" << endl;
}

int main()
{
    student my;     // 创建第一次对象
    student *you = new student(999); //创建第二次对象，调用重载重构函数

    delete you; // 删除对象，触发析构函数
    return 0;   // return 0 后对象被删除，析构函数触发
}

什么是类的继承

类的继承允许我们在新的类里面继承父类的public还有protected，私有的部分private是不能被继承的。
当我们觉得这个类不好的时候，就可以使用类的继承，添加我们需要的功能。

格式（例子）：

点击查看代码

class 儿子: public 父亲{
public：
	......
protected:
	......
};

/************* 例如 *************/
using namespace std;  // 添加命名空间
class student
{
public:
    student();  // 构造函数
    student(int b);  // 构造函数重载
    ~student(); // 析构函数
    char name[64];
    int age;

    void test();
    void test(int a);

private:
    int test1;
};

class goodstudent: public student {
public:
    int grade;
};

如果想在子类里面访问父类的成员，也是通过“.”和“->”来访问。
当子类创建对象的时候，父类假如定义了构造函数，那么这个父类的构造函数则会被触发。

点击查看代码

using namespace std;  // 添加命名空间
class student
{
public:
    student();  // 构造函数
    ~student(); // 析构函数
    int age;
};

class goodstudent: public student {	// 创建子类
public:
    int grade;
};

student::student(){ // 构造函数是在对象被创建的时候触发
    cout << "hello!" << endl;
}

student::~student(){ // 析构函数是在对象被删除或者生命周期结束的时候触发
    cout << "bye!" << endl;
}

int main()
{
    goodstudent mystudent;	// 子类对象被创建的时候，父类的构造函数也会被触发
    mystudent.grade = 88;   // 访问子类成员
    mystudent.age = 10;     // 访问父类成员

    cout << mystudent.grade << endl;
    cout << mystudent.age << endl;

    return 0;
}

虚函数和纯虚函数的定义

虚函数：有实际意义的，允许派生类对其进行覆盖式的替换。使用virtual来修饰。
纯虚函数：没有实际定义的虚函数就是纯虚函数。

怎么定义一个虚函数

用 virtual 来修饰，虚函数是用来类的继承上的

举例：

点击查看代码

using namespace std;  // 添加命名空间
class student
{
public:
    int age;
    virtual void test();    //定义一个虚函数
    virtual void test_a() {};   // 定义一个纯虚函数
private:
    int test1;
};

class goodstudent: public student {
public:
    int grade;
    void test() {   // 子类的函数堆父类同名的函数进行了覆盖式的替换，这就是虚函数的一个特点
        cout << 200 << endl;
    };
};

void student:: test(){	// 父类test函数原本的定义
    test1 = 30;
    cout << test1 << endl;
};

int main()
{
    goodstudent mystudent;
    mystudent.grade = 88;   // 访问子类成员
    mystudent.age = 10;     // 访问父类成员

    cout << mystudent.grade << endl;
    cout << mystudent.age << endl;

    mystudent.test();	// 调用后可以看到，****原本父类的test的函数定义被改变

    return 0;   // return 0 后对象被删除，析构函数触发
}

虚函数的优点有什么？

可以预留类的接口，利于实现分工合作。