QT学习笔记（二）：C++简单了解

QT学习笔记（二）：C++简单了解

本文内容参考自以下内容：
【北京迅为】嵌入式学习之QT学习篇

1、什么是C++

C++是C语言的升级版，在C的基础上增加了很多功能，是一种高级语言。

2、什么是面向过程，什么是面向对象

C语言是面向过程，C++是面向对象的

举例：计算a+b

直接计算a+b就是面向过程

面向对象就是给a+b穿上了一层衣服，不是直接计算，方便移植和使用

3、C++的灵魂：类

类大家可以把他看成C语言的结构体的升级版。类的成员不仅可以是变量，也可以是函数。通过类定义出来的变量叫做对象。

4、如何定义一个类

class student
{
public:
    char name[64];
    char age;
};

5、什么是对象

对象是类的实例化

6、如何定义一个对象

直接定义：

student my;// student就是类，my就是对象

在堆里面定义：

student *my = new student;

删除在堆里面定义的变量：

delete my;

7、怎么访问类的成员

 student my;
 student *my2 = new student;

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

直接定义的变量用 . 访问

在堆里面定义的变量用->访问

8、类的函数成员

因为类里面的成员不仅可以是变量也可以是函数

第一步：在类里面声明

第二步：实现这个函数，这个函数可以直接在类里面写，也可以写在类的外面

直接在类里面写：

class student
{
public:
    char name[64];
    int age;

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

写在类的外面：

class student
{
public:
    char name[64];
    int age;

    void test();
};

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

访问函数和访问变量是一样的

student my;
student *my2 = new student;

my.test();
my2->test();

9、类的访问修饰符

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

public：表示函数和变量是公开的，任何人都可以访问

private：表示函数和变量只能在自己的类里面自己访问自己，不能通过对象来访问

class student
{
public:
    char name[64];
    int age;

    void test();

private:
    int score;
};

void student::test()
{
    score = 100;
    cout << score << endl;
}

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

10、类函数的重载特性

类函数的重载特性就是说我们可以在类里面定义同名的函数，但是参数不同的函数。

class student
{
public:
    char name[64];
    int age;

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

private:
    int score;
};

重载函数在调用的时候会根据参数的类型，然后去匹配相应的函数进行调用。

11、构造函数和析构函数

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

构造函数：假如我们定义了构造函数，当对象被创建的时候就会触发构造函数

怎么定义析构函数是和构造函数：

• 构造函数和析构函数的名字必须和类名一致。

• 析构函数在前面加~

• 构造函数不用加~

class student
{
public:
    student();
    ~student();
    char name[64];
    int age;

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

private:
    int score;
};

student::student()
{
    cout << "hello" << endl;
}

student::~student()
{
    cout << "bye" << endl;
}

构造函数可以被重载，这时候定义对象就要用在堆里面定义

class student
{
public:
    student();
    student(int score);
    ~student();
    char name[64];
    int age;

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

private:
    int score;
};

student::student()
{
    cout << "hello" << endl;
}

student::student(int score)
{
    cout << score << endl;
}

int main()
{
    student my;
    student *my2 = new student(90);

    return 0;  // return 0 之后对象就被删除了
}

析构函数不可以被重载

12、类的继承

类的继承允许在新的类中继承父类的public和protected部分，private是不能被继承的。

当我们觉得这个类不好的时候，可以使用类的继承，添加我们需要的功能。访问父类的成员也是通过 . 和 ->。

class student
{
public:
    student();
    student(int score);
    ~student();
    char name[64];
    int age;

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

private:
    int score;
};

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

int main()
{
    student my;
    My_Student *my2 = new My_Student();

    my2->grade = 100;
    my2->age = 18;

    cout << my2->grade << endl;
    cout << my2->age << endl;

    return 0;  // return 0 之后对象就被删除了
}

13、虚函数和纯虚函数

虚函数：有实际定义的，允许派生类对他进行覆盖式的替换，用virtual来修饰，虚函数是用在类的继承上的。

纯虚函数：没有实际定义的虚函数就是纯虚函数
怎么定义一个虚函数：
用virtual来修饰，虚函数是用在类的继承上面的。父类的函数可以被子类重新修改掉。

class student
{
public:
    student(); // 构造函数
    student(int score); // 构造函数的重载
    ~student(); // 析构函数
    char name[64];
    int age;

    virtual void test();  // 虚函数
    virtual void test2(){} // 纯虚函数

private:
    int score;
};

void student::test()
{
    score = 100;
    cout << score << endl;
}

允许派生类对他进行覆盖式的替换：

class student
{
public:
    student(); // 构造函数
    student(int score); // 构造函数的重载
    ~student(); // 析构函数
    char name[64];
    int age;

    virtual void test();  // 虚函数
    virtual void test2(){} // 纯虚函数

private:
    int score;
};

class My_Student : public student
{
public:
    int grade;
    void test()
    {
        cout << 200 << endl;
    }
};

void student::test()
{
    score = 100;
    cout << score << endl;
}

int main()
{
    student my;
    My_Student my2;

    my.test(); // 打印结果是100
    my2.test();  // 打印结果是200

    return 0;  // return 0 之后对象就被删除了
}

虚函数的优点：
可以使用虚函数预留出接口给相应的功能，实现分工合作