嵌入式学习之QT学习 ----2 C++基础

1、什么是c++？

c++是c语言的升级版，在c的基础上增加了很多功能，是一种高级语言，常见后缀：cpp，c++，cc 等。
一些C语言里面的语法结构对于c++来讲也是适用的，举个例子，循环打印“Hello World！”十次（使用for循环来实现）

#include <iostream>

using namespace std;

int main()
{
    int i;
    for(i=0;i<10;i++)
        cout << "Hello World!" <<i << endl;
    return 0;
}

运行结果如下：

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

C语言是面向过程的，c++是面向对象的。举个例子，就计算a+b来说，直接计算a+b就是面向过程；面向对象就是给a+b穿上了一层衣服，它不是直接计算a+b，而是先将a+b封装一下，封装到类里面，形成一个方法，然后通过a+b去调用这个类，这样做的好处是方便移植和使用。

3、c++的类就是c++的灵魂；C语言的灵魂是指针。

“类”可以看成是c语言结构体的升级版，但是类的成员不仅可以是变量，还可以是函数。

4、如何定义一个类？

class + 类名
在qt界面打class摁下回车，就会自动补全类的格式，如下所示：

class name
{
public:
    name() {}
};

只需要改一下类名，比如将name改为student，则有如下代码显示：

class student
{
public:
    student() {}
};

public：的后面跟成员变量就可以啦。

class student
{
//类的访问修饰符
public:
    //成员函数or变量
    char name[64];
    int age;
};

类与c语言中的结构体是非常相似的，只是类里面的成员不仅可以是变量，还可以是函数。

5、什么是对象？

通过类定义出来的变量叫做对象。换个说法就是对象是类的实例化。

6、如何定义一个对象？

定义对象有两种方法：一是直接定义；二是在堆里面定义。
如何删除对象呢？delete my;但是这样只能删除在堆里面的对象，而不能删除直接定义的对象。删除对象的意义是“释放堆里面的内存”，因为是在堆里面定义的对象，所以删除可释放堆里面的内存。

//----------------------------------------------
//如何定义对象？
int main()
{
    student my; //student是“类”，my是“对象”；这是直接定义对象的方法。
    student *my = new student;//这种方法是在堆里面定义，运用到了指针
    delete my;//这删除的是在堆里面定义的对象，而不能删除直接定义的对象
    return 0;
}
//---------------------------------------------------

7、怎么访问类的成员？

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

#include <iostream>

using namespace std;

class student
{
public:
    //成员函数
    char name[64];
    int age;
};

//如何定义对象？
int main()
{
    student my; //student是“类”，my是“对象”；这是直接定义对象的方法。
    student *my1 = new student;//这种方法是在堆里面定义,用到了指针
    //delete my;//这删除的是在堆里面定义的对象，而不能删除直接定义的对象

    //怎么样访问类的成员？
    my.age =18;
    my1->age=19;//访问类的成员
    cout<<my.age<<endl;
    cout<<my1->age<<endl;
    return 0;
}

编译、运行结果如下：

8、类的函数成员

类的成员不仅可以是变量，还可以是函数。那么如何在类里面声明函数呢？
第一步：在类里面声明

//如何在类里面声明函数呢？
    void test(){}

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

class student
{
public:
    //成员函数
    char name[64];
    int age;
    
    //------------
    //如何在类里面声明函数呢？
    void test()
    //声明完函数之后，如何在类里面实现函数呢？
    //第一种就是在类里面直接写
    {
        cout << "123" << endl;  
    }
};

写完之后，打印一下，看是否会报错。编译运行，并没有报错。
写在类的外面，即：只在类里面声明，但是把实现写在外面。有时候函数太长啦，将函数实现也写在类的声明里面就会显得很乱。

#include <iostream>

using namespace std;

class student
{
public:
    //成员函数
    char name[64];
    int age;
    //-----------在类里面声明函数，类的外面实现函数-------
    void test();
};
//-------------------------
//将类函数的实现写在类函数的声明外面
void student::test(){
    //student::表示属于这个类里面的函数，不加::的话会被识别成普通函数
    cout << 123 << endl;
}

编译运行，未报错，则类函数声明与实现正确。
访问函数和访问变量是一样的。

#include <iostream>

using namespace std;

class student
{
public:
    //成员函数
    char name[64];
    int age;
    //-----------在类里面声明函数，类的外面实现函数-------
    void test();
};

//-------------------------
//将类函数的实现写在类函数的声明外面
void student::test(){
    //student::表示属于这个类里面的函数，不加::的话会被识别成普通函数
    cout << 123 << endl;
}
//如何定义对象？
int main()
{
    student my; //student是“类”，my是“对象”；这是直接定义对象的方法。
    student *my1 = new student;//这种方法是在堆里面定义,用到了指针
    //怎么样访问类的成员？
    my.age =18;
    my1->age=19;
    //访问类的成员并打印
    
    //访问函数
    my.test();
    cout<<my.age<<endl;
    cout<<my1->age<<endl;
    return 0;
}

编译运行，结果如下：打印了函数里面的“123”，访问函数成功。

9、类的访问修饰符

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

• public：表示函数和变量是公开的，任何人都可以访问
• private：表示函数和变量只能在自己的类里面自己访问自己，不能通过对象来访问。思考：能不能强行访问？能的

#include <iostream>
using namespace std;
class student
{
public:
    char name[64];
    int age;
     void test();
    //--------------private:------------
private:
    int a;
};
//-----------------------------
//在类外面实现函数
void student::test(){
    //student::表示属于这个类里面的函数，不加::的话会被识别成普通函数
    cout << 123 << endl;
}
//----------------------------------
//主函数
int main()
{
     student my;
    student *my1 = new student;
     //怎么样访问类的成员？
    my.age =18;
    my1->age=19;
    cout<<my.age<<endl;
    cout<<my1->age<<endl;

    //访问private里面定义的a
    my.a =12;
    return 0;
}

可以看到刚开始想访问a，a前面的标识都是上锁的那种。

编译运行会报错。如何强行访问呢？可以在类函数里面引用该变量，然后在主函数里面去访问类实现函数test即可

#include <iostream>
using namespace std;
class student
{
public:
    char name[64];
    int age;
     void test();
    //--------------private:------------
private:
    int a;
};
//-----------------------------
//----------强行访问private里面的参数------在类实现里面去用-------
void student::test(){
    a=15;
    cout << a << endl;
}

//----------------------------------
//主函数
int main()
{
    student my;
    student *my1 = new student;
     //怎么样访问类的成员？
    my.age =18;
    my1->age=19;
     //访问函数
    my.test();
    cout<<my.age<<endl;
    cout<<my1->age<<endl;


    return 0;
}

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

10、类函数的重载特性

类函数的重载特性就是说我们可以在类里面定义同名但是参数不同的函数。
比如说在标题八那里已经声明了test类函数了，还可以再声明一个test的类函数，只是参数会不一样，比如说加一个参数“int a”

    //-----------在类里面声明函数，类的外面实现函数-------
    void test();
    void test(int a);

这种在c++里面是可以的，C语言不支持这样的重载。
重载函数在调用的时候，会根据参数的类型，然后去匹配相应的函数进行调用。
调用void test()

#include <iostream>
using namespace std;
class student
{
public:
    char name[64];
    int age;
    void test();
    void test(int a);
private:
    int a;
};
void student::test(){
    a=15;
    cout << a << endl;
}
void student::test(int a){
    cout << a << endl;
}

int main()
{
    student my;
    student *my1 = new student;

    my.age =18;
    my1->age=19;
    //访问类的成员并打印

    //访问函数
    my.test();
    cout<<my.age<<endl;
    cout<<my1->age<<endl;
      return 0;
}

调用void test（int a）
若是将访问函数那一句改为：

 //访问函数
    my.test(50);

则运行结果发生改变，代码将自动匹配void test（int a）去编译，结果如下：

11、构造函数和析构函数

• 析构函数：假如我们定义了析构函数，当对象被删除或者生命周期结束的时候，就会触发析构函数。
• 构造函数：假如我们定义了构造函数，就会触发这个构造函数。
  我们要怎么定义析构函数和构造函数？
  首先，析构函数和构造函数的名字必须和类名一模一样；其次，析构函数要在前面加上一个“~”

构造函数例程：

#include <iostream>
using namespace std;
class student
{
public:
    student();//定义构造函数，与类的名字一样  构造函数是在对象被创建的时候才会被触发
    char name[64];
    int age;
    void test();
    void test(int a);
private:
    int a;
};
student::student(){
    cout << "hello" << endl;
    //构造函数是在对象被创建的时候被触发的，所以执行程序的时候，hello的打印是早于后面的年龄那些信息的
}
int main()
{
    student my; //student是“类”，my是“对象”；这是直接定义对象的方法。
    student *my1 = new student;//这种方法是在堆里面定义,用到了指针
    //delete my;//这删除的是在堆里面定义的对象，而不能删除直接定义的对象

    //怎么样访问类的成员？
    my.age =18;
    my1->age=19;
    cout<<my.age<<endl;
    cout<<my1->age<<endl;

      return 0;
}

运行结果如下：构造函数是在对象被创建的时候被触发的，所以执行程序的时候，hello的打印是早于后面的年龄那些信息的。

为什么会打印两个hello呢？因为在代码里面定义了两个对象。

student my; //student是“类”，my是“对象”；这是直接定义对象的方法。
    student *my1 = new student;//这种方法是在堆里面定义,用到了指针

析构函数例程：

#include <iostream>
using namespace std;
class student
{
public:
    student();//定义构造函数，与类的名字一样  构造函数是在对象被创建的时候才会被触发
     ~student();
    char name[64];
    int age;
    void test();
    void test(int a);
private:
    int a;
};
student::student(){
    cout << "hello" << endl;
    //构造函数是在对象被删除或者声明周期结束的时候触发的，所以会在程序执行完其余代码之后才会被执行。
}
student::~student(){
    cout << "byebye" << endl;
    //析构函数是在对象被创建的时候被触发的，所以执行程序的时候，hello的打印是早于后面的年龄那些信息的
}
int main()
{
    student my; //student是“类”，my是“对象”；这是直接定义对象的方法。
    student *my1 = new student;//这种方法是在堆里面定义,用到了指针
    //delete my;//这删除的是在堆里面定义的对象，而不能删除直接定义的对象

    //怎么样访问类的成员？
    my.age =18;
    my1->age=19;
    cout<<my.age<<endl;
    cout<<my1->age<<endl;

      return 0;
}

运行结果如下：因为在return 0 之后，对象就被删除了，所以触发了析构函数。

在“return 0”前面加一句“delete my1；”查看编译运行的结果。（会打印两次byebye）

此外，构造函数是可以被重载的，但是析构函数不可以被重载。

12、什么是类的继承？

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

class 儿子：public 爸爸
{ 
	public： 
	........ 
	Protected: 
}

举个例子：

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

如何在子类里面去访问父类的成员？
也是通过“.”和“->”来访问的。

13、虚函数和纯虚函数

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

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

怎么定义一个虚函数？
用virtual函数来修饰。虚函数是用在类的继承上的。
虚函数的优点？
可以预留接口，实现分工合作。