嵌入式学习 QT 篇——（2）C++ 基础

---

C++

C++ 是 C 语言的升级版，很多 C 语言的语法在 C++ 中是通用的；C++ 是面向对象的编程，在面向对象的编程中 C 语言叫做结构体，C++ 叫做类。

1、定义类

下面是定义的一个类

class student
{
public:
		char name[64];
		int age;
		void test();
};

类是用 class 来修饰的，其中的
public: 表示函数和变量是公开的，任何对象都可以访问。
除了 public: 还有 private： 和 protected：
private： 表示函数和变量只能在自己的类里面自己访问自己，不能通过对象来访问。
protected： 表示函数和变量只能在自己的类里面自己访问自己，但是可以被派生类来访问的。

2、定义对象

对象是类的实例化

直接定义对象：

student mystudent1;  // student  是类，mystudent1  是对象

在堆里定义对象：

student * mystudent2 = new student;  // 在堆里定义对象


//              delete mystudent2;   //释放堆里面的内存

访问类的成员与C 语言中访问结构体成员方法一样如下：

mystudent1.age  =  12; // 对象用点

mystudent2->age = 13;  //指针用   ->

输出语句如下：

cout << mystudent1.age << endl;     //输出 12
cout << mystudent2->age << endl;    //输出 13

for(i = 0; i < 10; i++)
	cout << "Hello\t" << i <<endl;   //打印  Hello	1
                                    //      Hello	2
                                    //      .....打印 10 行

3、类的函数成员

写类的函数有两种方法 ①写在类里面；②写在类外边；

①写在类里面

class student
{
public:
		char name[64];
		int age;
		void test(){
				cout << "Hello" << endl; 
		};
};

②写在类外边

class student
{
public:
		char name[64];
		int age;
		void test();
};
void student::test()   //student::  表示属于这个类里面的函数，不加的话会被识别成普通函数。
{  
	cout << "Hello" << endl; 
}

4、类的重载特性

类的重载特性是指我们可以在类里定义同名不同参的函数，如下：

class student
{
public:
		char name[64];
		int age;
		void test();
		void test(int a);
};

void student::test()
{  
	cout << "Hello" << endl;  // 打印 Hello
}
void student::test(int a)
{  
	cout <<  a << endl;    // 打印 a 的值
}

mystudent2->test();
mystudent2->test(60);

重载函数在调用的时候，会根据参数类型自动匹配相应的函数调用。

5、构造函数与析构函数

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

构造函数与析构函数的名字必须和类名一样，析构函数在前面加个 ~

直接上代码

class student
{
public:
		student();  //构造函数 ,创建对象后被调用
      	~student(); //析构函数，对象被删除或者生命周期结束时被调用
		char name[64];
		int age;
		void test();
		void test(int a);
};

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

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

构造函数可以被重载；析构函数不可被重载

6、类的继承

类的继承允许我们在新的类里面继承父类的 public 还有 protected 的部分，private是不能被继承的。

class 子类：public 父类{
public：

protected：

};

class mystudent:public student  //定义 student  的子类  mystudent
{                            // mystudent 包含父类的成员。
public:
       int grade;
};

mystudent * mystudent3 = new mystudent;

mystudent3->grade = 14;
mystudent3->age = 15;

cout << mystudent3->grade << endl;   //打印 14
cout << mystudent3->age << endl;   //打印 15

7、虚函数与纯虚函数

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

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

---