2016-03-30 14:30 参加百度地图（国际化）的面试。以下是面试后我总结出的题目：
1、关键字static的作用。
static可以修饰局部变量，全局变量，函数和类中的成员变量和成员函数。
static修饰局部变量，只能初始化一次，该静态变量的作用域是所在的函数，生命周期伸长到整个程序的结束。static 修饰的全局变量和函数只能让本文件的其他函数调用，其他文件里用extern声明此静态全局变量和静态函数，编译器将会报错。静态全局变量的初始化也只能是一次，存在于BSS段或者数据段。
static可以修饰类中的成员变量和成员函数，静态数据成员被当作是类的成员，无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份复制品，由该类型的所有对象共享访问。这和非静态成员有很大的区别，因为对于非静态数据成员，每一个类对象都有自己的复制品。静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。基于此，它无法访问属于类对象的非静态数据成员和非静态成员函数，它只能调用其余的静态成员函数或者静态数据成员。
2、#include<xxx.h> 和extern 一个其他文件的全局变量的区别
#include<xxx.h>一个其他文件的全局变量，那么该xxx.h文件必须用extern 声明一下该变量，然后引用该头文件的源文件才能用该变量。extern 直接在源文件中声明其他变量就行。
#include<xxx.h>是批量生产，就是还可以引用xxx.h文件中声明的其他变量；而extern更像零售，
用其他文件的变量必须在每一个变量前加extern关键字。
#include<xxx.h>一个其他文件的全局变量更正规一些。
3、类中静态成员变量的特征，静态成员变量的初始化是怎么样的？
静态数据成员被当作是类的成员，无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份复制品，由该类型的所有对象共享访问。这和非静态成员有很大的区别，因为对于非静态数据成员，每一个类对象都有自己的复制品。
静态数据成员存储在全局数据区。定义时要分配空间，所以不能在类声明中定义。静态成员不属于特定的类对象，在没有产生类对象时其作用域就可见。即在没有产生类的实例时，程序员也可以使用它。
静态数据成员和普通数据成员一样遵从public、protected、private的访问规则。
与全局变量相比，使用静态数据成员有两大优势：
（1）静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其他全局名字冲突的可能性。 （2）可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能。
类的静态成员必须初始化，static成员变量的初始化是在类外，此时不能带上static关键字。private、protected的static成员虽然可以在类外初始化，但是不能在类外被访问。
4、写出String字符串的拷贝构造函数和赋值操作符函数。
class String
{
public:
String();
String(const String& other);
~String();
String& operator=(const string& other);
private:
char* str;
};
拷贝构造函数实现如下：
String::String(const String& other)
{
int len = strlen (other.str);
delete str;
str = new char[len + 1];
strcpy(str, other.str);
return *this;
}
赋值操作符函数实现如下：
String& String::operator=(const String& other)
{
if (this == &other)
return *this;
delete str;
str = new char[len + 1];
strcpy(str, other.str);
return *this;
}
5、自己实现一个atoi的函数
int myatoi(const int* str, int n)
{
char ch;
int num = 0;
int k;
for (k = 0; k < n; k++)
{
ch = str[k];
if (ch == '+' || ch == '-')
continue;
else if (ch <= '9' && ch >= '0')
num += pow(10,n – k – 1) * (ch – '0');
else
return -1;
}
if (str[0] == '-')
return 0 – num;
else
return num;
}
6、大小端的概念，写一个程序分辨是大端还是小端。
大端是高地址存低地址的数据，低地址存高地址的数据
小端是高地址存高地址的数据，低地址存低地址的数据
Union A
{
char ch;
int a;
}
A.a = 0x1122;
A.ch = ?，如果是0x22，那么就是小端，否则就是大端。
7、谈谈深拷贝和浅拷贝的区别。
如果一个类拥有资源（堆或者是其他系统资源），当这个类的对象发生复制过程时，资源重新分配，
这个过程就是深拷贝；反之对象存在资源，但复制过程并未复制资源的情况为浅拷贝。
简单的来说就是，在有指针的情况下，浅拷贝只是增加了一个指针指向已经存在的内存，而深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存，采用深拷贝的情况下，释放内存的时候就不会出现在浅拷贝同时重复释放同一内存的错误！
再简单的说，深拷贝就是拷贝对象本身的副本，而浅拷贝只是拷贝了对象的引用，此时会出现一个对象有被两个指针所指向。
8、Qt中的信号和槽机制是同步的还是异步的，主线程和子线程传递参数能否用信号和槽实现，信号和槽类似于c++中的什么？
有同步也有异步（多线程技术），相当于c++中的回调函数
connect(button,SIGNAL(clicked()),this,SLOT(on_button_click()), @);
connect()函数有五个参数，常常我们只使用前四个参数，而忽略了第五个参数@，分别为：
Qt::AutoConnection
Qt::DirectConnection
Qt::QueuedConnection
Qt::BlockingQueuedConnection
Qt::UniqueConnection
Qt::AutoCompatConnection
其中用第一个第二个参数，是同步的，第三个参数会将信号放到信号等待队列中，此时信号和槽就是异步的。
9、谈谈快速排序的实现原理，时间复杂度，最坏情况下的时间复杂度，最坏情况下是一种什么情况，自己写程序实现。
快速排序是一种非常高效的排序算法，它采用“分治”思想，把大的拆分为小的，小的拆分为更小的。其原理是：对于一组给定的记录，通过一趟排序后，将原序列分为两部分，其中前部分的所有记录均比后部分的所有记录小，然后再依次对前后两部分的记录进行快速排序，递归该过程，直到序列中的所有记录均为有序为止。
快速排序的平均时间复杂度是O(nlogn)，最坏情况下的时间复杂度是O(n^2)，最坏的情况下就是选择的基准关键字是待排序的所有记录中最小或者最大的，即123456789，排成987654321，这就是最坏的情况。
程序实现如下：
void quickSort(int arr[],int low,int high)
{
int i , j;
int temp;
if (low >= high)
return;
i = low;
j = high;
temp = arr[i];
while (i < j)
{
while(i < j && arr[j] >= temp)
j--;
if (i < j)
arr[i++] = arr[j];
while (i < j && arr[i] < temp)
i++;
if (i < j)
arr[j--] = arr[i];
}
arr[i] = index;
quickSort(arr,low, i – 1);
quickSort(arr,i + 1,high);
}
10、自己用程序实现求两个字符串的最长的子字符串（动态规划）。
Int maxLengthStr(const char* str1,const char* str2)
{
int m = strlen(str1);
int n = strlen(str2);
int c[m+1][n+1];
int i,j;
for (i=0;i<m+1;i++)
c[i][n] = 0;
for (j=0;j<n+1;j++)
c[m][j] = 0;
for (i=m-1; i>=0;i--)
{
for (j=n-1;j>=0;j--)
{
if (str1[i] == str2[j])
{
c[i][j] = c[i+1][j+1] + 1;
}
else
{
if(c[i][j+1] > c[i+1][j])
c[i][j] = c[i][j+1];
else
c[i][j] = c[i+1][j];
}
}
}
return c[0][0];
}
与动态规划有关的还有背包问题，数组中子数组和的最大值。
11 虚析构函数的作用？
当基类的指针指向派生类对象时，在析构时防止析构基类而不析构派生类的状况发生，从而引起内存泄露。不是虚析构函数，就只能析构掉基类，不能析构掉派生类。加了virtual，就都可以析构掉了。
