在Qt里，线程相关的类有：

QThread 线程

QMutex 互斥锁

QMutex 互斥锁

QSemaphore 信号量

创建线程：

1
2
3
4
5
6
7

class MyThread : public QThread
{ 
	Q_OBJECT
public: 
	MyThread(QObject *parent);
    ~MyThread(); void run();   // 线程的入口函数
};

事件处理：当事件发生时，程序做出响应

示例：点击“显示”按钮时，文本框显示对应内容

首先采用QT设计师添加控件文本框和按钮

        网上对于Visual Studio 2013版本编译64位的QT4版本的资料相对较少，因此本人在编译的过程也走了一些弯路，现趁着空闲时间来详细的讲讲编译的步骤。

        首先，下载Visual Studio 2013版本并进行安装，推荐微信公众号关注：软件安装管家。这里面有许多软件的各个版本的破解版下载链接和教程，免费的！！！

        接下来，下载QT4，这个可以直接搜索官网进行下载，百度搜索QT4下载就能找到。具体哪个版本可随意，只要是QT4的就行，本文就用QT4.8.6版本进行演示。

下载链接：http://download.qt.io/archive/qt/4.8/4.8.6/qt-everywhere-opensource-src-4.8.6.zip

注意：下载的要是源代码，不要下载成已经编译好的软件。

毕设答辩问题总结

下位机问题：

1.简述51与STM32的区别

内核：

        51单片机采用的是51 Core，8Bit；

        STM32采用的是ARM Cortex-M3，32Bit

地址空间：

        51单片机只有64KB；

        STM32有4GB

片上储存器：

        51单片机ROM(只读存储器)只有2K-64K，RAM(易挥发性随机存取存储器)仅为128B-1K；

        STM32的ROM为20K-1MB，RAM有8K-256K　

        下面是我个人做的一些比较经典的数据结构题目，内含代码解析

        数据结构中的排序算法有：插入类排序、交换类排序、选择排序、堆排序、归并排序、桶排序。而交换类排序包括：冒泡排序和快速排序。

其中：冒泡排序（稳定的排序）

注：下列改进的冒泡排序是从小到大排序

        数据结构中的排序算法有：插入类排序、交换类排序、选择排序、堆排序、归并排序、桶排序。而交换类排序包括：冒泡排序和快速排序。

其中：快速排序（不稳定的排序）

特点：序列越无序，效率越高，快速排序是基于原问题分解成多个子问题，再递归地求解各个子问题。

原理：每次选任一元素作为枢轴（一般选第一个元素），将比枢轴小的元素都放到枢轴前面，比枢轴大的元素都移到枢轴后面。（即类比于：每次选一个标兵，比该标兵矮的同学站左边，比标兵高的同学站右边）

注：下列两种方法的排序都是从小到大排序

方法一：采用递归（较为容易理解）

        数据结构中的排序算法有：插入类排序、交换类排序、选择排序、堆排序、归并排序、桶排序。而 插入类排序包括：直接插入排序、折半插入排序、希尔排序。

其中：希尔排序（不稳定的排序）

        希尔排序又称：缩小增量排序。什么是不稳定的排序呢？意思是假如未排序前的序列存在两个值相同的元素，经过希尔排序后，这两个值在排完的有序序列中的先后位置会发生改变。反之，稳定的排序则不会发生改变。

为什么希尔排序是不稳定的排序呢？因为：不同的增量可能把相同的关键字划分到两个子序列中执行直接插入排序。

        希尔排序可以理解为：要对整个班级按照身高从低到高排列。希尔排序就是首先将班级人数分成5排，然后对每一列进行排序；当排序完后再将队伍分成2排，再次对每一列的同学进行身高排序；当再次排序完后最后队伍分成1排，对每一列的同学进行身高排序（此时就是简单的插入排序了）。

注：下列两种方法都是从小到大排序

方法一：建立哨兵（A[0]为哨兵，类似于中介变量，用于暂存元素值）

        数据结构中的排序算法有：插入类排序、交换类排序、选择排序、堆排序、归并排序、桶排序。而 插入类排序包括：直接插入排序、折半插入排序、希尔排序。

其中：折半插入排序（稳定的排序）

原理步骤：

        1）首先，利用折半查找法确定插入的正确位置；

        2）其次，再一次性对元素进行移动；

        3）最后，执行插入指令

先讲讲折半查找法：

        折半查找也叫二分查找，该方法要求必须是线性存储结构。其原理就是每次与当前有序序列中间下标的数组进行比较，如果此时要插入的值比该A[mid]大，那么我就进入这个有序序列的右半部分继续进行查找，否则就进入左半部分继续查找。直到找到合适位置（low=high时）。

注：下列两种方法都是从小到大排序

方法一：建立哨兵（A[0]为哨兵，类似于中介变量，用于暂存元素值）

static**：用来说明是静态变量

特点：

1.如果是在函数外面定义的，那么效果和全局变量类似，但static定义的变量只能在当前的C文件中使用

2.如果是在函数内部定义的，那么这个变量只初始化一次

const:

const 常量类型 常量名=常量表达式；(固定不变)

int const等同于const int

malloc和free：

new和delete：

new：开辟一个存储空间

delete：撤销new建立的存储空间，防止内存泄漏。

try和throw：

stlen()和str():

析构函数的调用顺序：

先构造的后析构，后构造的先析构。相当于栈的先进后出

拷贝构造函数：

CExample(const CExample& C)　就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它必须的一个参数是本类型的一个引用变量**。

https://www.cnblogs.com/alantu2018/p/8459250.html

friend：友元，给予函数访问私有部分内容的权限

例子：friend int f(A&f1,B&f2)

引用：等同于取别名

例：

1
2
3
4
5
6
7
8
9

void f(int *a,int *b)
{
	........
}
void main()
{
	int a=1,b=5;
	f(&a,&b);
}

上面这个例子可以看出&a要跟 *a配合使用，若主函数中调用f()不写&a，而是写成a的话，那么只有在f()这个函数里变量a,b才会改变，等到执行完这个子函数f()后，值又会重新变为刚输入f()子函数时的数值。（即：在f()函数中其实是形参a,b发生了改变，而实参a,b并没有变化）

为什么当子函数格式为：void f(int *a,*b)时，在调用子函数的输入一定要为f(&a,&b)呢？

原因是：引用得到的是地址，当子函数用指针来接收地址时，函数中的a,b发生变化时，被引用的值同时也发生变化，不会受到函数声明周期的影响。

C++中：参数传递的方法是想“实虚结合”

• 按值传递：调用函数本身，不对实参进行操作，即使形参值发生改变，实参的值仍然不变；
• 地址传递：形参为指针，实参跟着形参发生改变；例：f(a,b);void f(&a,&b);
• 引用传递：引用得到的是地址，相当于输入的是地址，子函数用指针来接收地址;例：f(&a,&b);void f(*a,*b)

函数的重载：

1

例：同时定义这三个函数void f(int x)，void f(float x), void f(double x)

从上面看；：这就是重载。即：定义的函数名字相同，但是输入参数的类型不同

运算符的重载：

运算符重载的基本原则：

格式：如operator+（）必须是有效的C++运算符。

• 不能虚构运算符，如operator@（）
• 重载后的运算符至少要有一个操作数是用户自定义的类型不能违反运算符原来的句法规则，如取模%不能重载成使用操作数
• 不能修改运算符的优先级

继承方式：

分为：公用继承、私有继承、受保护继承

特点：

• 无论是什么方式的继承，都只继承基类的公用成员和保护成员，而私有成员、构造函数、析构函数都是不被继承的；
• 公用继承不改变访问属性；
• 私有、受保护继承则根据继承方式，将从基类继承过来的成员的访问属性全改为对应的继承方式;

注：保护成员：不能被外界引用，但可以被派生类的成员引用.(派生类：通过继承方式，新的类可以从已有的类中派生。那么用于派生的类统称为这个派生类的“基类”)

注：若是调用时不写继承方式，则默认为私有继承哦。

当存在继承关系时，执行的顺序为：

虚函数：

定义：被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性。（多态性：是将接口与实现进行分离；简单来讲就是实现以共同的方法，但因个体差异，而采用不同的策略。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

例1：
class A
{
public:
	A(){}
	virtual void f()//声明为虚函数
	{
		cout<<"11111111111"<<endl;
	}
	
};
class B:public A
{
	public:
		B(){}
		void f()//子类和父类具有相同的函数名
		{
			cout<<"22222222222"<<endl
		}
};
void main()
{
	A *a= new B();
	a->f();//基类指针调用派生类的非虚函数
	delete a;
}
输出：
	22222222222
	11111111111

假如不声明为虚函数会怎样呢？

答：如果不声明为虚函数，那么试图通过基类指针调用派生类的非虚函数是不行的。如果非要这样写，那么输出的结果就是11111111111。

为什么会这样呢？

答：因为：基类指针是用来指向基类对象的，如果用它指向派生类对象，则自动进行指针类型转换，将派生类的对象的指针先转换为基类指针对象，这样，基类指针指向的是派生类对象中的基类部分，所以不声明为虚函数的话，是没法执行派生类中相同函数名的函数的。我的理解是：virtual这个关键字是要告诉编译器在派生类中还可能存在着相同函数名的函数，使得基类指针去往派生类中寻找。