C&C++笔试面试高频1000题(一)

写在前面

C/C++笔试面试出现频率最高的1000题系列，由于文章篇幅限定，总共1000题的分析将分为10篇讲述，此篇为
第一篇。
掌握这1000的高频题，面对互联网大厂笔试面试时会底气十足！
加油！

1.变量的声明和定义有什么区别

为变量分配地址和存储空间的称为定义，不分配地址的称为声明。一个变量可以在多个地方声明，
但是只在一个地方定义。加入 extern 修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。说明：很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间，
如外部变量。

2.写出 bool 、int、 float、指针变量与“零值”比较的 if 语句

//bool 型数据： 
if( flag ) 
{ 
 	A; 
} 
else 
{ 
 	B； 
} 
//int 型数据： 
if( 0 != flag ) 
{ 
 	A; 
} 
else { 
 	B； 
} 
//指针型： 
if( NULL == flag ) 
{ 
 	A; 
} 
else { 
 	B； 
} 
//float 型数据： 
if ( ( flag >= -NORM ) && ( flag <= NORM ) ) 
{ 
 	A； 
}

注意：应特别注意在 int、指针型变量和“零值”比较的时候，把“零值”放在左边，这样当把“==” 误写成“=”时，编译器可以报错，否则这种逻辑错误不容易发现，并且可能导致很严重的后果。

3.sizeof 和 strlen 的区别

sizeof 和 strlen 有以下区别：

sizeof 是一个操作符，strlen 是库函数。
sizeof 的参数可以是数据的类型，也可以是变量，而 strlen 只能以结尾为‘\0‘的字符串作参数。
编译器在编译时就计算出了 sizeof 的结果。而 strlen 函数必须在运行时才能计算出来。并且 sizeof 计算的是数据类型占内存的大小，而 strlen 计算的是字符串实际的长度。
数组做 sizeof 的参数不退化，传递给 strlen 就退化为指针了。

注意：有些是操作符看起来像是函数，而有些函数名看起来又像操作符，这类容易混淆的名称一定要加以区分，否则遇到数组名这类特殊数据类型作参数时就很容易出错。最容易混淆为函数的操作符就是 sizeof。

4.C 语言的关键字 static 和 C++ 的关键字 static 有什么区别

在 C 中 static 用来修饰局部静态变量和外部静态变量、函数。而 C++中除了上述功能外，还用来定义类的成员变量和函数。即静态成员和静态成员函数。

注意：编程时 static 的记忆性，和全局性的特点可以让在不同时期调用的函数进行通信，传递信息，而 C++的静态成员则可以在多个对象实例间进行通信，传递信息。

5.Ｃ中的 malloc 和Ｃ＋＋中的 new 有什么区别

malloc 和 new 有以下不同：

new、delete 是操作符，可以重载，只能在 C++中使用。
malloc、free 是函数，可以覆盖，C、C++中都可以使用。
new 可以调用对象的构造函数，对应的 delete 调用相应的析构函数。
malloc 仅仅分配内存，free 仅仅回收内存，并不执行构造和析构函数
new、delete 返回的是某种数据类型指针，malloc、free 返回的是 void 指针。

注意：malloc 申请的内存空间要用 free 释放，而 new 申请的内存空间要用 delete 释放，不要混用。
因为两者实现的机理不同。

6.写一个“标准”宏 MIN

#define min(a,b)((a)<=(b)?(a):(b))

注意：在调用时一定要注意这个宏定义的副作用，如下调用：

((++*p)<=(x)?(++*p):(x)

p 指针就自加了两次，违背了 MIN 的本意。

7.一个指针可以是 volatile 吗

可以，因为指针和普通变量一样，有时也有变化程序的不可控性。

常见例：子中断服务子程序修改一个指向一个 buffer 的指针时，必须用 volatile 来修饰这个指针。

说明：指针是一种普通的变量，从访问上没有什么不同于其他变量的特性。其保存的数值是个整型数据，和整型变量不同的是，这个整型数据指向的是一段内存地址。

8.a 和&a 有什么区别

请写出以下代码的打印结果，主要目的是考察 a 和&a 的区别。

#include<stdio.h> 
void main( void ) 
{ 
 	int a[5]={1,2,3,4,5}; 
 	int *ptr=(int *)(&a+1); 
 	printf("%d,%d",*(a+1),*(ptr-1));  	
 	return; 
}

输出结果：2，5。
注意：数组名 a 可以作数组的首地址，而&a 是数组的指针。思考，将原式的 int *ptr=(int *)(&a+1); 改为 int *ptr=(int *)(a+1);时输出结果将是什么呢？

9.简述 C、C++程序编译的内存分配情况

C、C++中内存分配方式可以分为三种：

从静态存储区域分配：

内存在程序编译时就已经分配好，这块内存在程序的整个运行期间都存在。速度快、不容易出错，因为有系统会善后。例如全局变量，static 变量等。
在栈上分配：

在执行函数时，函数内局部变量的存储单元都在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
从堆上分配：

即动态内存分配。程序在运行的时候用 malloc 或 new 申请任意大小的内存，程序员自己负责在何时用 free 或 delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活。如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，另外频繁地分配和释放不同大小的堆空间将会产生堆内碎块。

一个 C、C++程序编译时内存分为 5 大存储区：堆区、栈区、全局区、文字常量区、程序代码区。

10.简述 strcpy、sprintf 与 memcpy 的区别

三者主要有以下不同之处：

操作对象不同，strcpy 的两个操作对象均为字符串，sprintf 的操作源对象可以是多种数据类型，目的操作对象是字符串，memcpy 的两个对象就是两个任意可操作的内存地址，并不限于何种数据类型。
执行效率不同，memcpy 最高，strcpy 次之，sprintf 的效率最低。
实现功能不同，strcpy 主要实现字符串变量间的拷贝，sprintf 主要实现其他数据类型格式到字符串的转化，memcpy 主要是内存块间的拷贝。

说明：strcpy、sprintf 与 memcpy 都可以实现拷贝的功能，但是针对的对象不同，根据实际需求，来选择合适的函数实现拷贝功能。

11.设置地址为 0x67a9 的整型变量的值为 0xaa66

int *ptr;  
ptr = (int *)0x67a9;  
*ptr = 0xaa66;

说明：这道题就是强制类型转换的典型例子，无论在什么平台地址长度和整型数据的长度是一样的，即一个整型数据可以强制转换成地址指针类型，只要有意义即可。

12.面向对象的三大特征

面向对象的三大特征是封装性、继承性和多态性：

封装性：将客观事物抽象成类，每个类对自身的数据和方法实行 protection（private， protected， public）。

继承性：广义的继承有三种实现形式：实现继承（使用基类的属性和方法而无需额外编码的能力)、可视继承(子窗体使用父窗体的外观和实现代码)、接口继承(仅使用属性和方法,实现滞后到子类实现)。

多态性：是将父类对象设置成为和一个或更多它的子对象相等的技术。用子类对象给父类对象赋值之后，父类对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。这部分需要熟悉掌握原理虚函数，了解一些概念（静态多态、动态多态）等，面试时经常会问。

说明：面向对象的三个特征是实现面向对象技术的关键，每一个特征的相关技术都非常的复杂，程序员应该多看、多练。

13.C++的空类有哪些成员函数

缺省构造函数。
缺省拷贝构造函数。
缺省析构函数。
缺省赋值运算符。
缺省取址运算符。
缺省取址运算符 const。

注意：有些书上只是简单的介绍了前四个函数。没有提及后面这两个函数。但后面这两个函数也是空类的默认函数。另外需要注意的是，只有当实际使用这些函数的时候，编译器才会去定义它们。

14.谈谈你对拷贝构造函数和赋值运算符的认识

拷贝构造函数和赋值运算符重载有以下两个不同之处：

拷贝构造函数生成新的类对象，而赋值运算符不能。
由于拷贝构造函数是直接构造一个新的类对象，所以在初始化这个对象之前不用检验源对象是否和新建对象相同。而赋值运算符则需要这个操作，另外赋值运算中如果原来的对象中有内存分配要先把内存释放掉

注意：当有类中有指针类型的成员变量时，一定要重写拷贝构造函数和赋值运算符，不要使用默认的。

15.用 C++设计一个不能被继承的类

template <typename T> class A 
{ 
 	friend T; private: 
 	A() {} 
 	~A() {} 
}; 

class B : virtual public A<B> 
{ 
public: 
 	B() {} 
 	~B() {} 
}; 
class C : virtual public B 
{ 
public: 
 	C() {} 
 	~C() {} 
}; 
void main( void ) 
{ 
 	B b;  //C c; 
 	return; 
}

注意：构造函数是继承实现的关键，每次子类对象构造时，首先调用的是父类的构造函数，然后才是自己的。

16.访问基类的私有虚函数

写出以下程序的输出结果：

#include <iostream.h> 
class A 
{ 
 	virtual void g() 
 	{ 
 	 	cout << "A::g" << endl; 
 	} 
private: 
 	virtual void f() 
 	{ 
 	 	cout << "A::f" << endl; 
 	} 
}; 
class B : public A 
{ 
 	void g() 
 	{ 
 	 	cout << "B::g" << endl; 
 	} 
 	virtual void h() 
 	{ 
 	 	cout << "B::h" << endl; 
 	} 
}; 
typedef void( *Fun )( void ); void main() 
{ 
 	B b; 
 	Fun pFun; 
 	for(int i = 0 ; i < 3; i++) 
 	{ 
 	 	pFun = ( Fun )*( ( int* ) * ( int* )( &b ) + i ); 
 	 	pFun(); 
 	} 	 
}

输出结果：

B::g

A::f

B::h

注意：本题主要考察了面试者对虚函数的理解程度。一个对虚函数不了解的人很难正确的做出本题。
在学习面向对象的多态性时一定要深刻理解虚函数表的工作原理。

17.简述类成员函数的重写、重载和隐藏的区别

重写和重载主要有以下几点不同。

范围的区别：被重写的和重写的函数在两个类中，而重载和被重载的函数在同一个类中。

参数的区别：被重写函数和重写函数的参数列表一定相同，而被重载函数和重载函数的参数列表一定不同。

virtual 的区别：重写的基类中被重写的函数必须要有 virtual 修饰，而重载函数和被重载函数可以被

virtual 修饰，也可以没有。
隐藏和重写、重载有以下几点不同。

与重载的范围不同：和重写一样，隐藏函数和被隐藏函数不在同一个类中。

参数的区别：隐藏函数和被隐藏的函数的参数列表可以相同，也可不同，但是函数名肯定要相同。当参数不相同时，无论基类中的参数是否被 virtual 修饰，基类的函数都是被隐藏，而不是被重写。

说明：虽然重载和覆盖都是实现多态的基础，但是两者实现的技术完全不相同，达到的目的也是完全不同的，覆盖是动态态绑定的多态，而重载是静态绑定的多态。

18.简述多态实现的原理

编译器发现一个类中有虚函数，便会立即为此类生成虚函数表 vtable。虚函数表的各表项为指向对应虚函数的指针。编译器还会在此类中隐含插入一个指针 vptr（对 vc 编译器来说，它插在类的第一个位置上）指向虚函数表。调用此类的构造函数时，在类的构造函数中，编译器会隐含执行 vptr 与 vtable 的关联代码，将 vptr 指向对应的 vtable，将类与此类的 vtable 联系了起来。另外在调用类的构造函数时，指向基础类的指针此时已经变成指向具体的类的 this 指针，这样依靠此 this 指针即可得到正确的 vtable，。
如此才能真正与函数体进行连接，这就是动态联编，实现多态的基本原理。

注意：一定要区分虚函数，纯虚函数、虚拟继承的关系和区别。牢记虚函数实现原理，因为多态
C++面试的重要考点之一，而虚函数是实现多态的基础。

19.链表和数组有什么区别

数组和链表有以下几点不同：

存储形式：数组是一块连续的空间，声明时就要确定长度。链表是一块可不连续的动态空间，长度可变，每个结点要保存相邻结点指针。
数据查找：数组的线性查找速度快，查找操作直接使用偏移地址。链表需要按顺序检索结点，效率低。
数据插入或删除：链表可以快速插入和删除结点，而数组则可能需要大量数据移动。
越界问题：链表不存在越界问题，数组有越界问题。

说明：在选择数组或链表数据结构时，一定要根据实际需要进行选择。数组便于查询，链表便于插入删除。数组节省空间但是长度固定，链表虽然变长但是占了更多的存储空间。

20.怎样把一个单链表反序

反转一个链表。循环算法。

List reverse(List   n)  
{  
 	if(!n)  	 	 	 	 	 	//判断链表是否为空，为空即退出。 
 	{ 
 	 	return n; 
 	} 
 	list cur = n.next; 	 	 	 	//保存头结点的下个结点  
 	list pre = n; 	 	 
 	list tmp; 	 	 	//保存头结点 
 	pre.next = null;  	 	 	 	//头结点的指针指空，转换后变尾结点 
 	while ( NULL != cur.next )  	 	//循环直到 cur.next 为空 
 	{ 
 		tmp = cur;  	 	 	 	
	} 	 	
	tmp.next = pre;    	
	pre = tmp; 
 	cur = cur.next; 
	

return tmp; 	 	 	 	 	//f 返回头指针 

}

反转一个链表。递归算法。

List *reverse( List *oldList, List *newHead = NULL )  
{ 
 	List *next = oldList-> next;  	 	//记录上次翻转后的链表  	
 	oldList-> next = newHead;  	 	//将当前结点插入到翻转后链表的开头  	
 	newHead = oldList;   	 	 	//递归处理剩余的链表 
 	return ( next==NULL )? newHead: reverse( t, newHead );  
}

说明：循环算法就是移动过程，比较好理解和想到。递归算法的设计虽有一点难度，但是理解了循环算法，再设计递归算法就简单多了。

21.简述队列和栈的异同

队列和栈都是线性存储结构，但是两者的插入和删除数据的操作不同，队列是“先进先出”，栈是
“后进先出”。

注意：区别栈区和堆区。堆区的存取是“顺序随意”，而栈区是“后进先出”。栈由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。堆一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。分配方式类似于链表。
它与本题中的堆和栈是两回事。堆栈只是一种数据结构，而堆区和栈区是程序的不同内存存储区域。

22.能否用两个栈实现一个队列的功能

//结点结构体：
typedef struct node
{
   int data;
   node *next;
}node, *LinkStack;
//创建空栈：
LinkStack CreateNULLStack(LinkStack &S)
{
   S = (LinkStack)malloc(sizeof(node)); //申请新结点
   if (NULL == S)
   {
   	printf("Fail to malloc a new node.\n")
   		return NULL;
   }
   S->data = 0; //初始化新结点
   S->next = NULL;
   return S;
}
//栈的插入函数：
LinkStack Push(LinkStack &S, int data)
{
   if (NULL == S) //检验栈
   {
   	printf("There no node in stack!");
   	return NULL;
   }
   LinkStack p = NULL;
   p = (LinkStack)malloc(sizeof(node)); //申请新结点
   if (NULL == p)
   {
   	printf("Fail to malloc a new node.\n");
   	return S;
   }
   if (NULL == S->next)
   {
   	p->next = NULL;
   }
   else
   {
   	p->next = S->next;
   }
   p->data = data; //初始化新结点
   S->next = p; //插入新结点
   return S;
}
//出栈函数：
node Pop(LinkStack &S)
{
   node temp;
   temp.data = 0;
   temp.next = NULL;
   if (NULL == S) //检验栈
   {
   	printf("There no node in stack!");
   	return temp;
   }
   temp = *S;
   10
   	if (S->next == NULL)
   	{
   		printf("The stack is NULL,can't pop!\n");
   		return temp;
   	}
   LinkStack p = S->next; //节点出栈
   S->next = S->next->next;
   temp = *p;
   free(p);
   p = NULL;
   return temp;
}
//双栈实现队列的入队函数：
LinkStack StackToQueuPush(LinkStack &S, int data)
{
   node n;
   LinkStack S1 = NULL;
   CreateNULLStack(S1); //创建空栈
   while (NULL != S->next) //S 出栈入 S1
   {
   	n = Pop(S);
   	Push(S1, n.data);
   }
   Push(S1, data); //新结点入栈
   while (NULL != S1->next) //S1 出栈入 S
   {
   	n = Pop(S1);
   	Push(S, n.data);
   }
}

说明：用两个栈能够实现一个队列的功能，那用两个队列能否实现一个队列的功能呢？结果是否定的，因为栈是先进后出，将两个栈连在一起，就是先进先出。而队列是现先进先出，无论多少个连在一起都是先进先出，而无法实现先进后出。

23.计算一颗二叉树的深度

深度的计算函数：

int depth(BiTree T) 
{ 
	if(!T) return 0;  	 	 	 	 	//判断当前结点是否为叶子结点 
	int d1= depth(T->lchild);  	 	 	//求当前结点的左孩子树的深度 
	int d2= depth(T->rchild);   	 	 	//求当前结点的右孩子树的深度 

} 	return (d1>d2?d1:d2)+1;

注意：根据二叉树的结构特点，很多算法都可以用递归算法来实现。

24.编码实现直接插入排序

直接插入排序编程实现如下：

#include<iostream.h> 
void main( void ) 
{ 
 	int ARRAY[10] = { 0, 6, 3, 2, 7, 5, 4, 9, 1, 8 }; 
 	int i,j; 
 	for(  i = 0; i < 10; i++) 
 	{ 
 	 	cout<<ARRAY[i]<<" "; 
 	} 
 	cout<<endl; 
 	for( i = 2; i <= 10; i++ ) 	 	 	 	//将 ARRAY[2],…,ARRAY[n]依次按序插入 
 	{  	 
 	 	if(ARRAY[i] < ARRAY[i-1]) 	 	//如果 ARRAY[i]大于一切有序的数值， 
 	 	 	 	 	 	 	 	 	//ARRAY[i]将保持原位不动 
 	 	{ 
   ARRAY[0] = ARRAY[i];  //将 ARRAY[0]看做是哨兵,是 ARRAY[i]的副本    j = i - 1; 

 	 	do{  	 	 	 	 	//从右向左在有序区 ARRAY[1．．i-1]中  	 	 	 	 	 	 	 	 	//查找 ARRAY[i]的插入位置 

   ARRAY[j+1] = ARRAY[j];  //将数值大于 ARRAY[i]记录后移    j-- ; 
 	 	 	}while( ARRAY[0] < ARRAY[j] );  
 	 	 	ARRAY[j+1]=ARRAY[0];  	//ARRAY[i]插入到正确的位置上 
 	 	} 
 	} 
 	for(  i = 0; i < 10; i++) 
 	{ 
 	 	cout<<ARRAY[i]<<" "; 
 	} 
 	cout<<endl; 
}

注意：所有为简化边界条件而引入的附加结点（元素）均可称为哨兵。引入哨兵后使得查找循环条件的时间大约减少了一半，对于记录数较大的文件节约的时间就相当可观。类似于排序这样使用频率非常高的算法，要尽可能地减少其运行时间。所以不能把上述算法中的哨兵视为雕虫小技。

25.编码实现冒泡排序

冒泡排序编程实现如下：

#include <stdio.h> 
#define LEN 10  	 	 	 	 	 	 	//数组长度 

 void main( void ) 
 { 
 	int ARRAY[10] = { 0, 6, 3, 2, 7, 5, 4, 9, 1, 8 }; 	//待排序数组 
 	printf( "\n" ); 
	for( int a = 0; a < LEN; a++ ) 	 	 	 	//打印数组内容 
 	{ 
 	printf( "%d ", ARRAY[a] ); 
	} 
	int i = 0; int j = 0; 
	bool isChange;  	 	 	 	 	 	//设定交换标志 

for( i = 1; i < LEN; i++ ) 
{ 	 	 	 	 	 	 	 	 	//最多做 LEN-1 趟排序 
 	isChange = 0;  	 	 	 	 	//本趟排序开始前,交换标志应为假 
 	for( j = LEN-1; j >= i; j-- )  	 	 	//对当前无序区 ARRAY[i..LEN]自下向上扫描 
{ 
if( ARRAY[j+1] < ARRAY[j] ) 	 
{ 	 	 	 	 	 	 	//交换记录 
 	 	ARRAY[0] = ARRAY[j+1];  	//ARRAY[0]不是哨兵,仅做暂存单元 
 	 	ARRAY[j+1] = ARRAY[j];  	 	
 	 	ARRAY[j] = ARRAY[0]; 
 		isChange = 1;  	 	 	//发生了交换,故将交换标志置为真 
 	} 

} 
printf( "\n" ); 
for( a = 0; a < LEN; a++)  	 	 	//打印本次排序后数组内容 
 { 
 	printf( "%d ", ARRAY[a] ); 
} 
if( !isChange )  	 	 	 	 
{ 
 	break; 
} 	//本趟排序未发生交换,提前终止算法 
printf( "\n" ); return; 
}

26.编码实现直接选择排序

在这里插入图片描述

注意：在直接选择排序中，具有相同关键码的对象可能会颠倒次序，因而直接选择排序算法是一种不稳定的排序方法。在本例中只是例举了简单的整形数组排序，肯定不会有什么问题。但是在复杂的数据元素序列组合中，只是根据单一的某一个关键值排序，直接选择排序则不保证其稳定性，这是直接选择排序的一个弱点。

27.编程实现堆排序

堆排序编程实现：

void createHeep(int ARRAY[], int sPoint, int Len) //生成大根堆
{
	while ((2 * sPoint + 1) < Len)
	{
		int mPoint = 2 * sPoint + 1;
		if ((2 * sPoint + 2) < Len)
		{
			if (ARRAY[2 * sPoint + 1] < ARRAY[2 * sPoint + 2])
			{
				mPoint = 2 * sPoint + 2;
			}
		}
		if (ARRAY[sPoint] < ARRAY[mPoint]) //堆被破坏，需要重新调整
		{
			int tmpData = ARRAY[sPoint]; //交换 sPoint 与 mPoint 的数据
			ARRAY[sPoint] = ARRAY[mPoint];
			ARRAY[mPoint] = tmpData;
			sPoint = mPoint;
		}
		else
		{
			break; //堆未破坏，不再需要调整
		}
	}
	return;
}
void heepSort(int ARRAY[], int Len) //堆排序
{
	int i = 0;
	for (i = (Len / 2 - 1); i >= 0; i--) //将 Hr[0，Lenght-1]建成大根堆
	{
		createHeep(ARRAY, i, Len);
	}
	for (i = Len - 1; i > 0; i--)
	{
		int tmpData = ARRAY[0]; //与最后一个记录交换
		ARRAY[0] = ARRAY[i];
		ARRAY[i] = tmpData;
		createHeep(ARRAY, 0, i); //将 H.r[0..i]重新调整为大根堆
	}
	return;
}
int main(void)
{
	int ARRAY[] = { 5, 4, 7, 3, 9, 1, 6, 8, 2 };
	printf("Before sorted:\n"); //打印排序前数组内容
	for (int i = 0; i < 9; i++)
	{
		printf("%d ", ARRAY[i]);
	}
	printf("\n");
	heepSort(ARRAY, 9); //堆排序
	printf("After sorted:\n"); //打印排序后数组内容
	for (i = 0; i < 9; i++)
	{
		printf("%d ", ARRAY[i]);
	}
	printf("\n");
}

说明：堆排序，虽然实现复杂，但是非常的实用。另外读者可是自己设计实现小堆排序的算法。虽然和大堆排序的实现过程相似，但是却可以加深对堆排序的记忆和理解。

28.编程实现基数排序

#include <stdio.h>
#include <malloc.h>
#define LEN 8
typedef struct node //队列结点
{
	int data;
	struct node * next;
}node, *QueueNode;
typedef struct Queue //队列
{
	QueueNode front;
	QueueNode rear;
}Queue, *QueueLink;
QueueLink CreateNullQueue(QueueLink &Q) //创建空队列
{
	Q = NULL;
	Q = (QueueLink)malloc(sizeof(Queue));
	if (NULL == Q)
	{
		printf("Fail to malloc null queue!\n");
		return NULL;
	}
	Q->front = (QueueNode)malloc(sizeof(node));
	Q->rear = (QueueNode)malloc(sizeof(node));
	if (NULL == Q->front || NULL == Q->rear)
	{
		printf("Fail to malloc a new queue's fornt or rear!\n");
		return NULL;
	}
	Q->rear = NULL;
	Q->front->next = Q->rear;
	return Q;
}
int lenData(node data[], int len) //计算队列中各结点的数据的最大位数
{
	int m = 0;
	int temp = 0;
	int d;
	for (int i = 0; i < len; i++)
	{
		d = data[i].data;
		while (d > 0)
		{
			d /= 10;
			temp++;
		}
		if (temp > m)
		{
			m = temp;
		}
		temp = 0;
	}
	return m;
}
QueueLink Push(QueueLink &Q, node node) //将数据压入队列
{
	QueueNode p1, p;
	p = (QueueNode)malloc(sizeof(node));
	if (NULL == p)
	{
		printf("Fail to malloc a new node!\n");
		return NULL;
	}
	p1 = Q->front;
	while (p1->next != NULL)
	{
		p1 = p1->next;
	}
	p->data = node.data;
	p1->next = p;
	p->next = Q->rear;
	return NULL;
}
node Pop(QueueLink &Q) //数据出队列
{
	node temp;
	temp.data = 0;
	temp.next = NULL;
	QueueNode p;
	p = Q->front->next;
	if (p != Q->rear)
	{
		temp = *p;
		Q->front->next = p->next;
		free(p);
		p = NULL;
	}
	return temp;
}
int IsEmpty(QueueLink Q)
{
	if (Q->front->next == Q->rear)
	{
		return 0;
	}
	return 1;
}
int main(void)
{
	int i = 0;
	int Max = 0; //记录结点中数据的最大位数
	int d = 10;
	int power = 1;
	int k = 0;
	node Array[LEN] = { { 450, NULL }, { 32, NULL }, { 781, NULL }, { 57, NULL }, 组
	{ 145, NULL }, { 613, NULL }, { 401, NULL }, { 594, NULL } };
	//队列结点数
	QueueLink Queue[10];
	for (i = 0; i < 10; i++)
	{
		CreateNullQueue(Queue[i]); //初始化队列数组
	}
	for (i = 0; i < LEN; i++)
	{
		printf("%d ", Array[i].data);
	}
	printf("\n");
	Max = lenData(Array, LEN); //计算数组中关键字的最大位数
	printf("%d\n", Max);
	for (int j = 0; j < Max; j++) //按位排序
	{
		if (j == 0) power = 1;
		else power = power *d;
		for (i = 0; i < LEN; i++)
		{
			k = Array[i].data / power - (Array[i].data / (power * d)) * d;
			Push(Queue[k], Array[i]);
		}
		for (int l = 0, k = 0; l < d; l++) //排序后出队列重入数组
		{
			while (IsEmpty(Queue[l]))
			{
				Array[k++] = Pop(Queue[l]);
			}
		}
		for (int t = 0; t < LEN; t++)
		{
			printf("%d ", Array[t].data);
		}
		printf("\n");
	}
	return 0;
}

说明：队列为基数排序的实现提供了很大的方便，适当的数据机构可以减少算法的复杂度，让更多的算法实现更容易。

29.谈谈你对编程规范的理解或认识

编程规范可总结为：程序的可行性，可读性、可移植性以及可测试性。
说明：这是编程规范的总纲目，面试者不一定要去背诵上面给出的那几个例子，应该去理解这几个例子说明的问题，想一想，自己如何解决可行性、可读性、可移植性以及可测试性这几个问题，结合以上几个例子和自己平时的编程习惯来回答这个问题。

30.short i = 0; i = i + 1L；这两句有错吗

代码一是错的，代码二是正确的。

说明：在数据安全的情况下大类型的数据向小类型的数据转换一定要显示的强制类型转换。

31.&&和&、||和|有什么区别

&和|对操作数进行求值运算，&&和||只是判断逻辑关系。
&&和||在在判断左侧操作数就能确定结果的情况下就不再对右侧操作数求值。

注意：在编程的时候有些时候将&&或||替换成&或|没有出错，但是其逻辑是错误的，可能会导致不可预想的后果（比如当两个操作数一个是 1 另一个是 2 时。

32.C++的引用和 C 语言的指针有什么区别

指针和引用主要有以下区别：

引用必须被初始化，但是不分配存储空间。指针不声明时初始化，在初始化的时候需要分配存储空间。
引用初始化以后不能被改变，指针可以改变所指的对象。
不存在指向空值的引用，但是存在指向空值的指针。

注意：引用作为函数参数时，会引发一定的问题，因为让引用作参数，目的就是想改变这个引用所指向地址的内容，而函数调用时传入的是实参，看不出函数的参数是正常变量，还是引用，因此可能会引发错误。所以使用时一定要小心谨慎。

33.在二元树中找出和为某一值的所有路径

输入一个整数和一棵二元树。从树的根结点开始往下访问，一直到叶结点所经过的所有结点形成一条路径。打印出和与输入整数相等的所有路径。例如，输入整数 9 和如下二元树：

则打印出两条路径：3，6 和 3，2，4。
【答案】

typedef struct path 
{ 
 	BiTNode* tree;  	 	 	 	 	//结点数据成员 
 	struct path* next;  	 
}PATH,*pPath; 	 	 	 	//结点指针成员 
//初始化树的结点栈： 
void init_path( pPath* L ) 
{ 
 	*L = ( pPath )malloc( sizeof( PATH ) ); 
 	( *L )->next = NULL;  
} 	 	//创建空树 
//树结点入栈函数： 
void push_path(pPath H, pBTree T) 
{ 
 	pPath p = H->next; 
 	pPath q = H; 
 	while( NULL != p ) 
 	{ 
 	q = p; 
 	p = p->next; 
} 
p = ( pPath )malloc( sizeof( PATH ) ); 	 	//申请新结点 
p->next = NULL; 	 	 	 	 	//初始化新结点 
} 	p->tree = T;  
q->next = p;  	 	 	 	 	 	//新结点入栈 
//树结点打印函数： 
void print_path( pPath L ) 
{ 
 	pPath p = L->next;  

while( NULL != p ) 	 	 	 
{ 
	printf("%d, ", p->tree->data);   p = p->next;  
}  

} 	 	//打印当前栈中所有数据 

///树结点出栈函数： 

void pop_path( pPath H ) 
{
	pPath p = H->next; 
	pPath q = H; 
	if( NULL == p )  	 	 	 	 	//检验当前栈是否为空 
 	{ 
 		printf("Stack is null!\n"); 
 		return; 
	} 
	p = p->next; 
	while( NULL != p ) 	 	 	 	 	//出栈 
	{ 
 		q = q->next;  	
 		p = p->next; 
	} 
	free( q->next );  	 	 	 	 	//释放出栈结点空间 
	q->next = NULL;  
}			
//判断结点是否为叶子结点： 
int IsLeaf(pBTree T) 
{ 
 	return ( T->lchild == NULL )&&( T->rchild==NULL );  
} 
//查找符合条件的路径： 
int find_path(pBTree T, int sum, pPath L) 
{ 
 	push_path( L, T); record += T->data;  
 	if( ( record == sum ) && ( IsLeaf( T ) ) ) 	 	//打印符合条件的当前路径 
	{ 
 		print_path( L );  
 		printf( "\n" );  
	} 
	if( T->lchild != NULL ) 	 	 	 	 	//递归查找当前节点的左孩子 
	{ 
 		find_path( T->lchild, sum, L); 
	} 
	if( T->rchild != NULL )  	 	 	 	 	//递归查找当前节点的右孩子 
	{ 
 		find_path( T->rchild, sum, L); 
	} 
	record -= T->data;  pop_path(L);  return 0; 	
}

注意：数据结构一定要活学活用，例如本题，把所有的结点都压入栈，而不符合条件的结点弹出栈，很容易实现了有效路径的查找。虽然用链表也可以实现，但是用栈更利于理解这个问题，即适当的数据结构为更好的算法设计提供了有利的条件。

34.写一个“标准”宏 MIN

写一个“标准”宏 MIN，这个宏输入两个参数并且返回较小的一个。
【答案】

#define min(a,b)((a)<=(b)?(a):(b))

注意：在调用时一定要注意这个宏定义的副作用，如下调用：
((++p)<=(x)?(++p):(x)
p 指针就自加了两次，违背了 MIN 的本意。

35.typedef 和 define 有什么区别

用法不同：typedef 用来定义一种数据类型的别名，增强程序的可读性。define 主要用来定义常量，以及书写复杂使用频繁的宏。
执行时间不同：typedef 是编译过程的一部分，有类型检查的功能。define 是宏定义，是预编译的部分，其发生在编译之前，只是简单的进行字符串的替换，不进行类型的检查。
作用域不同：typedef 有作用域限定。define 不受作用域约束，只要是在 define 声明后的引用都是正确的。
对指针的操作不同：typedef 和 define 定义的指针时有很大的区别。
注意：typedef 定义是语句，因为句尾要加上分号。而 define 不是语句，千万不能在句尾加分号。

36.关键字 const 是什么

const 用来定义一个只读的变量或对象。主要优点：便于类型检查、同宏定义一样可以方便地进行参数的修改和调整、节省空间，避免不必要的内存分配、可为函数重载提供参考。

说明：const 修饰函数参数，是一种编程规范的要求，便于阅读，一看即知这个参数不能被改变，实现时不易出错。 const修饰成员函数不可修改成员变量。

37.static 有什么作用

static 在 C 中主要用于定义全局静态变量、定义局部静态变量、定义静态函数。在 C++中新增了两种作用：定义静态数据成员、静态函数成员。

注意：因为 static 定义的变量分配在静态区，所以其定义的变量的默认值为 0，普通变量的默认值为随机数，在定义指针变量时要特别注意。

38.extern 有什么作用

extern 标识的变量或者函数声明其定义在别的文件中，提示编译器遇到此变量和函数时在其它模块中寻找其定义。

39.流操作符重载为什么返回引用

在程序中，流操作符>>和<<经常连续使用。因此这两个操作符的返回值应该是一个仍旧支持这两个操作符的流引用。其他的数据类型都无法做到这一点。

注意：除了在赋值操作符和流操作符之外的其他的一些操作符中，如+、-、*、/等却千万不能返回引用。因为这四个操作符的对象都是右值，因此，它们必须构造一个对象作为返回值。

40.简述指针常量与常量指针区别

指针常量是指定义了一个指针，这个指针的值只能在定义时初始化，其他地方不能改变。常量指针是指定义了一个指针，这个指针指向一个只读的对象，不能通过常量指针来改变这个对象的值。
指针常量强调的是指针的不可改变性，而常量指针强调的是指针对其所指对象的不可改变性。

注意：无论是指针常量还是常量指针，其最大的用途就是作为函数的形式参数，保证实参在被调用函数中的不可改变特性。

41.数组名和指针的区别

请写出以下代码的打印结果：

#include <iostream.h>
#include <string.h>
void main(void)
{
	char str[13]="Hello world!";
	char *pStr="Hello world!";
	cout<<sizeof(str)<<endl;
	cout<<sizeof(pStr)<<endl;
	cout<<strlen(str)<<endl;
	cout<<strlen(pStr)<<endl;
	return;
}

【答案】
打印结果：

注意：一定要记得数组名并不是真正意义上的指针，它的内涵要比指针丰富的多。但是当数组名当做参数传递给函数后，其失去原来的含义，变作普通的指针。另外要注意 sizeof 不是函数，只是操作符。

42.如何避免“野指针”

“野指针”产生原因及解决办法如下：

指针变量声明时没有被初始化。解决办法：指针声明时初始化，可以是具体的地址值，也可让它指向 NULL。
指针 p 被 free 或者 delete 之后，没有置为 NULL。解决办法：指针指向的内存空间被释放后指针应该指向 NULL。
指针操作超越了变量的作用范围。解决办法：在变量的作用域结束前释放掉变量的地址空间并且让指针指向 NULL。
注意：“野指针”的解决方法也是编程规范的基本原则，平时使用指针时一定要避免产生“野指针”，在使用指针前一定要检验指针的合法性。

43.常引用有什么作用

常引用的引入主要是为了避免使用变量的引用时，在不知情的情况下改变变量的值。常引用主要用于定义一个普通变量的只读属性的别名、作为函数的传入形参，避免实参在调用函数中被意外的改变。
说明：很多情况下，需要用常引用做形参，被引用对象等效于常对象，不能在函数中改变实参的值，这样的好处是有较高的易读性和较小的出错率。

44.编码实现字符串转化为数字

编码实现函数 atoi()，设计一个程序，把一个字符串转化为一个整型数值。例如数字：“5486321”，转化成字符：5486321。
【答案】

int myAtoi(const char * str)
{
	int num = 0; //保存转换后的数值
	int isNegative = 0; //记录字符串中是否有负号
	int n = 0;
	char *p = str;
	if (p == NULL) //判断指针的合法性
	{
		return -1;
	}
	while (*p++ != '\0') //计算数字符串度
	{
		n++;
	}
	p = str;
	if (p[0] == '-') //判断数组是否有负号
	{
		isNegative = 1;
	}
	char temp = '0';
	for (int i = 0; i < n; i++)
	{
		char temp = *p++;
		if (temp > '9' || temp < '0') //滤除非数字字符
		{
			continue;
		}
		if (num != 0 || temp != '0') //滤除字符串开始的 0 字符
		{
			temp -= 0x30; //将数字字符转换为数值
			num += temp *int(pow(10, n - 1 - i));
		}
	}
	if (isNegative) //如果字符串中有负号，将数值取反
	{
		return (0 - num);
	}
	else
	{
		return num; //返回转换后的数值
	}
}

注意：此段代码只是实现了十进制字符串到数字的转化，读者可以自己去实现 2 进制，8 进制，10 进制，16 进制的转化。

45.简述 strcpy、sprintf 与 memcpy 的区别

三者主要有以下不同之处：

操作对象不同，strcpy 的两个操作对象均为字符串，sprintf 的操作源对象可以是多种数据类型，目的操作对象是字符串，memcpy 的两个对象就是两个任意可操作的内存地址，并不限于何种数据类型。
执行效率不同，memcpy 最高，strcpy 次之，sprintf 的效率最低。
实现功能不同，strcpy 主要实现字符串变量间的拷贝，sprintf 主要实现其他数据类型格式到字符串的转化，memcpy 主要是内存块间的拷贝。
说明：strcpy、sprintf 与 memcpy 都可以实现拷贝的功能，但是针对的对象不同，根据实际需求，来选择合适的函数实现拷贝功能。

46.用 C 编写一个死循环程序

while(1)

说明：很多种途径都可实现同一种功能，但是不同的方法时间和空间占用度不同，特别是对于嵌入式软件，处理器速度比较慢，存储空间较小，所以时间和空间优势是选择各种方法的首要考虑条件。

47.编码实现某一变量某位清 0 或置 1

给定一个整型变量 a，写两段代码，第一个设置 a 的 bit 3，第二个清 a 的 bit 3，在以上两个操作中，要保持其他位不变。
【答案】

#define BIT3 (0x1 << 3 ) 
Satic int a; 	
//设置 a 的 bit 3: 	
void set_bit3( void ) 
{ 
 	a |= BIT3;  	 	 	 	 
} 	//将 a 第 3 位置 1 
//清 a 的 bit 3 	
void set_bit3( void ) 
{ 
 	a &= ~BIT3;  	 	 	 	 
} 	//将 a 第 3 位清零

说明：在置或清变量或寄存器的某一位时，一定要注意不要影响其他位。所以用加减法是很难实现的。

48.评论下面这个中断函数

中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展——让标准 C 支持中断。具体代表事实是，产生了一个新的关键字__interrupt。下面的代码就使用了__interrupt 关键字去定义一个中断服务子程序(ISR)，请评论以下这段代码。

__interrupt double compute_area (double radius)  
{  
	double area = PI * radius * radius;  printf(" Area = %f", area);  return area;  
}

【答案】
这段中断服务程序主要有以下四个问题：

ISR 不能返回一个值。
ISR 不能传递参数。
在 ISR 中做浮点运算是不明智的。
printf()经常有重入和性能上的问题。

注意：本题的第三个和第四个问题虽不是考察的重点，但是如果能提到这两点可给面试官留下一个好印象。

49.构造函数能否为虚函数

构造函数不能是虚函数。而且不能在构造函数中调用虚函数，因为那样实际执行的是父类的对应函数，因为自己还没有构造好。析构函数可以是虚函数，而且，在一个复杂类结构中，这往往是必须的。

析构函数也可以是纯虚函数，但纯虚析构函数必须有定义体，因为析构函数的调用是在子类中隐含的。

说明：虚函数的动态绑定特性是实现重载的关键技术，动态绑定根据实际的调用情况查询相应类的虚函数表，调用相应的虚函数。

50.谈谈你对面向对象的认识

面向对象可以理解成对待每一个问题，都是首先要确定这个问题由几个部分组成，而每一个部分其实就是一个对象。然后再分别设计这些对象，最后得到整个程序。传统的程序设计多是基于功能的思想来进行考虑和设计的，而面向对象的程序设计则是基于对象的角度来考虑问题。这样做能够使得程序更加的简洁清晰。

说明：编程中接触最多的“面向对象编程技术”仅仅是面向对象技术中的一个组成部分。发挥面向对象技术的优势是一个综合的技术问题，不仅需要面向对象的分析，设计和编程技术，而且需要借助必要的建模和开发工具。

51.const、static作用。

52.c++面向对象三大特征及对他们的理解，引出多态实现原理、动态绑定、菱形继承。

53.虚析构的必要性，引出内存泄漏，虚函数和普通成员函数的储存位置，虚函数表、虚函数表指针

54.malloc、free和new、delete区别，引出malloc申请大内存、malloc申请空间失败怎么办

55.stl熟悉吗，vector、map、list、hashMap，vector底层，map引出红黑树。优先队列用过吗，使用的场景。无锁队列听说过吗，原理是什么（比较并交换）

56.实现擅长的排序，说出原理（快排、堆排）

57.四种cast，智能指针

58.tcp和udp区别

59.进程和线程区别

60.指针和引用作用以及区别

61.c++11用过哪些特性，auto作为返回值和模板一起怎么用，函数指针能和auto混用吗

62.boost用过哪些类，thread、asio、signal、bind、function

63.单例、工厂模式、代理、适配器、模板，使用场景

64.QT信号槽实现机制，QT内存管理，MFC消息机制

65.进程间通信。会选一个详细问

66.多线程，锁和信号量，互斥和同步

67.动态库和静态库的区别

//auto作为返回值和模板一起怎么用，函数指针能和auto混用吗

#include <iostream>

using namespace std;

template <typename T,typename U>
auto add(T t,U u) -> decltype(t+u)
{
	return t+u;
}

template <typename T,typename U>
auto sub(T t,U u) -> decltype(t-u)
{
        return t-u;
}

template <typename T,typename U>
auto pro(T t,U u) -> decltype(t*u)
{
        return t*u;
}

template <typename T,typename U>
auto div(T t,U u) -> decltype(t/u)
{
    try
	{
		return t/u;
	} 
	catch(...)
	{
		exit(0);
	}	
}


int main()
{
	int x = 520;
	double y= 13.14;
	auto z = add(x,y);
	cout<<z<<endl;
	

//auto(*funp[4])(int ,double) = {add,sub,pro,div};//error
double (*funp[4])(int ,double) = {add,sub,pro,div};
for(unsigned char i=0;i<4;i++)
{
   cout<<funp[i](x,y)<<endl;
}
return 0;

}

68.提高c++性能，你用过哪些方式去提升

（构造、析构、返回值优化、临时对象（使用operator=()消除临时对象）、内联（内联技巧、条件内联、递归内联、静态局部变量内联）、内存池、使用函数对象不使用函数指针、编码（编译器优化、预先计算）、设计（延迟计算、高效数据结构）、系统体系结构（寄存器、缓存、上下文切换））

69.编译原理，尝试自己写过语言或语言编译器

70.泛型模板实用度高

71.对多种计算机语言熟悉

72.Git项目了解多少

73.针对网络框架（DPDK）、逆向工程（汇编）、分布式集群（docker、k8s、redis等）、CPU计算（nvidia cuda)、图像识别（opencv、opengl、tensorflow等)、AI等有研究

74.引用和指针的区别？

指针是一个实体，需要分配内存空间。引用只是变量的别名，不需要分配内存空间。
引用在定义的时候必须进行初始化，并且不能够改变。指针在定义的时候不一定要初始化，并且指向的空间可变。（注：不能有引用的值不能为NULL）
有多级指针，但是没有多级引用，只能有一级引用。
指针和引用的自增运算结果不一样。（指针是指向下一个空间，引用时引用的变量值加1）
sizeof 引用得到的是所指向的变量（对象）的大小，而sizeof 指针得到的是指针本身的大小。
引用访问一个变量是直接访问，而指针访问一个变量是间接访问。
使用指针前最好做类型检查，防止野指针的出现；
引用底层是通过指针实现的；
作为参数时也不同，传指针的实质是传值，传递的值是指针的地址；传引用的实质是传地址，传递的是变量的地址。

75.从汇编层去解释一下引用

1.9:          int x = 1;
2.00401048    mov         dword ptr [ebp-4],1
3.10:         int &b = x;
4.0040104F    lea         eax,[ebp-4]
5.00401052    mov         dword ptr [ebp-8],eax

x的地址为ebp-4，b的地址为ebp-8，因为栈内的变量内存是从高往低进行分配的。所以b的地址比x的低。lea eax,[ebp-4] 这条语句将x的地址ebp-4放入eax寄存器mov dword ptr [ebp-8],eax 这条语句将eax的值放入b的地址ebp-8中上面两条汇编的作用即：将x的地址存入变量b中，这不和将某个变量的地址存入指针变量是一样的吗？所以从汇编层次来看，的确引用是通过指针来实现的。

76.C++中的指针参数传递和引用参数传递

指针参数传递本质上是值传递，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，会在栈中开辟内存空间以存放由主调函数传递进来的实参值，从而形成了实参的一个副本（替身）。值传递的特点是，被调函数对形式参数的任何操作都是作为局部变量进行的，不会影响主调函数的实参变量的值（形参指针变了，实参指针不会变）。
引用参数传递过程中，被调函数的形式参数也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参（本体）的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量（根据别名找到主调函数中的本体）。因此，被调函数对形参的任何操作都会影响主调函数中的实参变量。
引用传递和指针传递是不同的，虽然他们都是在被调函数栈空间上的一个局部变量，但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数，如果改变被调函数中的指针地址，它将应用不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量（地址），那就得使用指向指针的指针或者指针引用。
从编译的角度来讲，程序在编译时分别将指针和引用添加到符号表上，符号表中记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值（与实参名字不同，地址相同）。符号表生成之后就不会再改，因此指针可以改变其指向的对象（指针变量中的值可以改），而引用对象则不能修改。

77.形参与实参的区别？

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。
实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使实参获得确定值，会产生一个临时变量。
实参和形参在数量上，类型上，顺序上应严格一致，否则会发生“类型不匹配”的错误。
函数调用中发生的数据传送是单向的。即只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。因此在函数调用过程中，形参的值发生改变，而实参中的值不会变化。
当形参和实参不是指针类型时，在该函数运行时，形参和实参是不同的变量，他们在内存中位于不同的位置，形参将实参的内容复制一份，在该函数运行结束的时候形参被释放，而实参内容不会改变。
值传递：有一个形参向函数所属的栈拷贝数据的过程，如果值传递的对象是类对象或是大的结构体对象，将耗费一定的时间和空间。（传值）
指针传递：同样有一个形参向函数所属的栈拷贝数据的过程，但拷贝的数据是一个固定为4字节的地址。（传值，传递的是地址值）
引用传递：同样有上述的数据拷贝过程，但其是针对地址的，相当于为该数据所在的地址起了一个别名。（传地址）
效率上讲，指针传递和引用传递比值传递效率高。一般主张使用引用传递，代码逻辑上更加紧凑、清晰。

78.static的用法和作用？

1.先来介绍它的第一条也是最重要的一条：隐藏。（static函数，static变量均可）
当同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。

2.static的第二个作用是保持变量内容的持久。（static变量中的记忆功能和全局生存期）存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。

3.static的第三个作用是默认初始化为0（static变量）
其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。

4.static的第四个作用：C++中的类成员声明static

函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。
类内：
static类对象必须要在类外进行初始化，static修饰的变量先于对象存在，所以static修饰的变量要在类外初始化；
由于static修饰的类成员属于类，不属于对象，因此static类成员函数是没有this指针的，this指针是指向本对象的指针。正因为没有this指针，所以static类成员函数不能访问非static的类成员，只能访问 static修饰的类成员；
static成员函数不能被virtual修饰，static成员不属于任何对象或实例，所以加上virtual没有任何实际意义；静态成员函数没有this指针，虚函数的实现是为每一个对象分配一个vptr指针，而vptr是通过this指针调用的，所以不能为virtual；虚函数的调用关系，this->vptr->ctable->virtual function

79.静态变量什么时候初始化

初始化只有一次，但是可以多次赋值，在主程序之前，编译器已经为其分配好了内存。
静态局部变量和全局变量一样，数据都存放在全局区域，所以在主程序之前，编译器已经为其分配好了内存，但在C和C++中静态局部变量的初始化节点又有点不太一样。在C中，初始化发生在代码执行之前，编译阶段分配好内存之后，就会进行初始化，所以我们看到在C语言中无法使用变量对静态局部变量进行初始化，在程序运行结束，变量所处的全局内存会被全部回收。
而在C++中，初始化时在执行相关代码时才会进行初始化，主要是由于C++引入对象后，要进行初始化必须执行相应构造函数和析构函数，在构造函数或析构函数中经常会需要进行某些程序中需要进行的特定操作，并非简单地分配内存。所以C++标准定为全局或静态对象是有首次用到时才会进行构造，并通过atexit()来管理。在程序结束，按照构造顺序反方向进行逐个析构。所以在C++中是可以使用变量对静态局部变量进行初始化的。

80.const?

阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量，类的常对象只能访问类的常成员函数；
对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。
const成员函数可以访问非const对象的非const数据成员、const数据成员，也可以访问const对象内的所有数据成员；
非const成员函数可以访问非const对象的非const数据成员、const数据成员，但不可以访问const对象的任意数据成员；
一个没有明确声明为const的成员函数被看作是将要修改对象中数据成员的函数，而且编译器不允许它为一个const对象所调用。因此const对象只能调用const成员函数。
const类型变量可以通过类型转换符const_cast将const类型转换为非const类型；
const类型变量必须定义的时候进行初始化，因此也导致如果类的成员变量有const类型的变量，那么该变量必须在类的初始化列表中进行初始化；
对于函数值传递的情况，因为参数传递是通过复制实参创建一个临时变量传递进函数的，函数内只能改变临时变量，但无法改变实参。则这个时候无论加不加const对实参不会产生任何影响。但是在引用或指针传递函数调用中，因为传进去的是一个引用或指针，这样函数内部可以改变引用或指针所指向的变量，这时const 才是实实在在地保护了实参所指向的变量。因为在编译阶段编译器对调用函数的选择是根据实参进行的，所以，只有引用传递和指针传递可以用是否加const来重载。一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来。

81.const成员函数的理解和应用？

①const Stock & Stock::topval (②const Stock & s) ③const
①处const：确保返回的Stock对象在以后的使用中不能被修改
②处const：确保此方法不修改传递的参数 S
③处const：保证此方法不修改调用它的对象，const对象只能调用const成员函数,不能调用非const函数

82.指针和const的用法

当const修饰指针时，由于const的位置不同，它的修饰对象会有所不同。
int const p2中const修饰p2的值,所以理解为p2的值不可以改变，即p2只能指向固定的一个变量地址，但可以通过p2读写这个变量的值。顶层指针表示指针本身是一个常量
int const p1或者const int p1两种情况中const修饰p1，所以理解为p1的值不可以改变，即不可以给*p1赋值改变p1指向变量的值，但可以通过给p赋值不同的地址改变这个指针指向。底层指针表示指针所指向的变量是一个常量。
int const *const p;

83.mutable

如果需要在const成员方法中修改一个成员变量的值，那么需要将这个成员变量修饰为mutable。即用mutable修饰的成员变量不受const成员方法的限制;
可以认为mutable的变量是类的辅助状态，但是只是起到类的一些方面表述的功能，修改他的内容我们可以认为对象的状态本身并没有改变的。实际上由于const_cast的存在，这个概念很多时候用处不是很到了。

84.extern用法？

extern修饰变量的声明
如果文件a.c需要引用b.c中变量int v，就可以在a.c中声明extern int v，然后就可以引用变量v。
extern修饰函数的声明
如果文件a.c需要引用b.c中的函数，比如在b.c中原型是int fun(int mu)，那么就可以在a.c中声明extern int fun（int mu），然后就能使用fun来做任何事情。就像变量的声明一样，extern int fun（int mu）可以放在a.c中任何地方，而不一定非要放在a.c的文件作用域的范围中。
extern修饰符可用于指示C或者C＋＋函数的调用规范。
比如在C＋＋中调用C库函数，就需要在C＋＋程序中用extern “C”声明要引用的函数。这是给链接器用的，告诉链接器在链接的时候用C函数规范来链接。主要原因是C＋＋和C程序编译完成后在目标代码中命名规则不同。

85.int转字符串字符串转int?strcat,strcpy,strncpy,memset,memcpy的内部实现？

c++11标准增加了全局函数std::to_string
可以使用std::stoi/stol/stoll等等函数
strcpy拥有返回值，有时候函数原本不需要返回值，但为了增加灵活性如支持链式表达，

86.深拷贝与浅拷贝？

浅复制 —-只是拷贝了基本类型的数据，而引用类型数据，复制后也是会发生引用，我们把这种拷贝叫做“（浅复制）浅拷贝”，换句话说，浅复制仅仅是指向被复制的内存地址，如果原地址中对象被改变了，那么浅复制出来的对象也会相应改变。
深复制 —-在计算机中开辟了一块新的内存地址用于存放复制的对象。
在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

87.C++模板是什么，底层怎么实现的？

编译器并不是把函数模板处理成能够处理任意类的函数；编译器从函数模板通过具体类型产生不同的函数；编译器会对函数模板进行两次编译：在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。
这是因为函数模板要被实例化后才能成为真正的函数，在使用函数模板的源文件中包含函数模板的头文件，如果该头文件中只有声明，没有定义，那编译器无法实例化该模板，最终导致链接错误。

88.C语言struct和C++struct区别

C语言中：struct是用户自定义数据类型（UDT）；C++中struct是抽象数据类型（ADT），支持成员函数的定义，（C++中的struct能继承，能实现多态）。
C中struct是没有权限的设置的，且struct中只能是一些变量的集合体，可以封装数据却不可以隐藏数据，而且成员不可以是函数。
C++中，struct的成员默认访问说明符为public（为了与C兼容），class中的默认访问限定符为private，struct增加了访问权限，且可以和类一样有成员函数。
struct作为类的一种特例是用来自定义数据结构的。一个结构标记声明后，在C中必须在结构标记前加上struct，才能做结构类型名

89.虚函数可以声明为inline吗?

虚函数用于实现运行时的多态，或者称为晚绑定或动态绑定。而内联函数用于提高效率。内联函数的原理是，在编译期间，对调用内联函数的地方的代码替换成函数代码。内联函数对于程序中需要频繁使用和调用的小函数非常有用。
虚函数要求在运行时进行类型确定，而内敛函数要求在编译期完成相关的函数替换；

90.类成员初始化方式？构造函数的执行顺序？为什么用成员初始化列表会快一些？

赋值初始化，通过在函数体内进行赋值初始化；列表初始化，在冒号后使用初始化列表进行初始化。
这两种方式的主要区别在于：
对于在函数体中初始化,是在所有的数据成员被分配内存空间后才进行的。
列表初始化是给数据成员分配内存空间时就进行初始化,就是说分配一个数据成员只要冒号后有此数据成员的赋值表达式(此表达式必须是括号赋值表达式),那么分配了内存空间后在进入函数体之前给数据成员赋值，就是说初始化这个数据成员此时函数体还未执行。
一个派生类构造函数的执行顺序如下：

虚拟基类的构造函数（多个虚拟基类则按照继承的顺序执行构造函数）。
基类的构造函数（多个普通基类也按照继承的顺序执行构造函数）。
类类型的成员对象的构造函数（按照初始化顺序）
派生类自己的构造函数。

方法一是在构造函数当中做赋值的操作，而方法二是做纯粹的初始化操作。我们都知道，C++的赋值操作是会产生临时对象的。临时对象的出现会降低程序的效率。

91.成员列表初始化？

必须使用成员初始化的四种情况

当初始化一个引用成员时；
当初始化一个常量成员时；
当调用一个基类的构造函数，而它拥有一组参数时；
当调用一个成员类的构造函数，而它拥有一组参数时；

成员初始化列表做了什么

编译器会一一操作初始化列表，以适当的顺序在构造函数之内安插初始化操作，并且在任何显示用户代码之前；
list中的项目顺序是由类中的成员声明顺序决定的，不是由初始化列表的顺序决定的；

92.构造函数为什么不能为虚函数？析构函数为什么要虚函数？

从存储空间角度，虚函数相应一个指向vtable虚函数表的指针，这大家都知道，但是这个指向vtable的指针事实上是存储在对象的内存空间的。问题出来了，假设构造函数是虚的，就须要通过 vtable来调用，但是对象还没有实例化，也就是内存空间还没有，怎么找vtable呢？所以构造函数不能是虚函数。

从使用角度，虚函数主要用于在信息不全的情况下，能使重载的函数得到相应的调用。构造函数本身就是要初始化实例，那使用虚函数也没有实际意义呀。所以构造函数没有必要是虚函数。虚函数的作用在于通过父类的指针或者引用来调用它的时候可以变成调用子类的那个成员函数。而构造函数是在创建对象时自己主动调用的，不可能通过父类的指针或者引用去调用，因此也就规定构造函数不能是虚函数。

构造函数不须要是虚函数，也不同意是虚函数，由于创建一个对象时我们总是要明白指定对象的类型，虽然我们可能通过实验室的基类的指针或引用去訪问它但析构却不一定，我们往往通过基类的指针来销毁对象。这时候假设析构函数不是虚函数，就不能正确识别对象类型从而不能正确调用析构函数。

从实现上看，vbtl在构造函数调用后才建立，因而构造函数不可能成为虚函数从实际含义上看，在调用构造函数时还不能确定对象的真实类型（由于子类会调父类的构造函数）；并且构造函数的作用是提供初始化，在对象生命期仅仅运行一次，不是对象的动态行为，也没有必要成为虚函数。

当一个构造函数被调用时，它做的首要的事情之中的一个是初始化它的VPTR。因此，它仅仅能知道它是“当前”类的，而全然忽视这个对象后面是否还有继承者。当编译器为这个构造函数产生代码时，它是为这个类的构造函数产生代码——既不是为基类，也不是为它的派生类（由于类不知道谁继承它）。所以它使用的VPTR必须是对于这个类的VTABLE。并且，仅仅要它是最后的构造函数调用，那么在这个对象的生命期内，VPTR将保持被初始化为指向这个VTABLE, 但假设接着另一个更晚派生的构造函数被调用，这个构造函数又将设置VPTR指向它的 VTABLE，等.直到最后的构造函数结束。VPTR的状态是由被最后调用的构造函数确定的。这就是为什么构造函数调用是从基类到更加派生类顺序的还有一个理由。可是，当这一系列构造函数调用正发生时，每一个构造函数都已经设置VPTR指向它自己的VTABLE。假设函数调用使用虚机制，它将仅仅产生通过它自己的VTABLE的调用，而不是最后的VTABLE（全部构造函数被调用后才会有最后的VTABLE）。

因为构造函数本来就是为了明确初始化对象成员才产生的，然而virtual function主要是为了再不完全了解细节的情况下也能正确处理对象。另外，virtual函数是在不同类型的对象产生不同的动作，现在对象还没有产生，如何使用virtual函数来完成你想完成的动作。

直接的讲，C++中基类采用virtual虚析构函数是为了防止内存泄漏。具体地说，如果派生类中申请了内存空间，并在其析构函数中对这些内存空间进行释放。假设基类中采用的是非虚析构函数，当删除基类指针指向的派生类对象时就不会触发动态绑定，因而只会调用基类的析构函数，而不会调用派生类的析构函数。那么在这种情况下，派生类中申请的空间就得不到释放从而产生内存泄漏。所以，为了防止这种情况的发生，C++中基类的析构函数应采用virtual虚析构函数。

93.析构函数的作用，如何起作用？

构造函数只是起初始化值的作用，但实例化一个对象的时候，可以通过实例去传递参数，从主函数传递到其他的函数里面，这样就使其他的函数里面有值了。规则，只要你一实例化对象，系统自动回调用一个构造函数，就是你不写，编译器也自动调用一次。
析构函数与构造函数的作用相反，用于撤销对象的一些特殊任务处理，可以是释放对象分配的内存空间；特点：析构函数与构造函数同名，但该函数前面加~。析构函数没有参数，也没有返回值，而且不能重载，在一个类中只能有一个析构函数。当撤销对象时，编译器也会自动调用析构函数。每一个类必须有一个析构函数，用户可以自定义析构函数，也可以是编译器自动生成默认的析构函数。一般析构函数定义为类的公有成员。

94.构造函数和析构函数可以调用虚函数吗，为什么？

在C++中，提倡不在构造函数和析构函数中调用虚函数；
构造函数和析构函数调用虚函数时都不使用动态联编，如果在构造函数或析构函数中调用虚函数，则运行的是为构造函数或析构函数自身类型定义的版本；
因为父类对象会在子类之前进行构造，此时子类部分的数据成员还未初始化，因此调用子类的虚函数时不安全的，故而C++不会进行动态联编；
析构函数是用来销毁一个对象的，在销毁一个对象时，先调用子类的析构函数，然后再调用基类的析构函数。所以在调用基类的析构函数时，派生类对象的数据成员已经销毁，这个时候再调用子类的虚函数没有任何意义。

95.构造函数的执行顺序？析构函数的执行顺序？构造函数内部干了啥？拷贝构造干了啥？

构造函数顺序

基类构造函数。如果有多个基类，则构造函数的调用顺序是某类在类派生表中出现的顺序，而不是它们在成员初始化表中的顺序。
成员类对象构造函数。如果有多个成员类对象则构造函数的调用顺序是对象在类中被声明的顺序，而不是它们出现在成员初始化表中的顺序。
派生类构造函数。

析构函数顺序
①调用派生类的析构函数；
②调用成员类对象的析构函数；
③调用基类的析构函数。

96.虚析构函数的作用，父类的析构函数是否要设置为虚函数？

C++中基类采用virtual虚析构函数是为了防止内存泄漏。具体地说，如果派生类中申请了内存空间，并在其析构函数中对这些内存空间进行释放。假设基类中采用的是非虚析构函数，当删除基类指针指向的派生类对象时就不会触发动态绑定，因而只会调用基类的析构函数，而不会调用派生类的析构函数。那么在这种情况下，派生类中申请的空间就得不到释放从而产生内存泄漏。所以，为了防止这种情况的发生，C++中基类的析构函数应采用virtual虚析构函数。
纯虚析构函数一定得定义，因为每一个派生类析构函数会被编译器加以扩张，以静态调用的方式调用其每一个虚基类以及上一层基类的析构函数。因此，缺乏任何一个基类析构函数的定义，就会导致链接失败。因此，最好不要把虚析构函数定义为纯虚析构函数。

24.构造函数析构函数可以调用虚函数吗？

在构造函数和析构函数中最好不要调用虚函数；
构造函数或者析构函数调用虚函数并不会发挥虚函数动态绑定的特性，跟普通函数没区别；
即使构造函数或者析构函数如果能成功调用虚函数，程序的运行结果也是不可控的。

97.构造函数析构函数可否抛出异常

C++只会析构已经完成的对象，对象只有在其构造函数执行完毕才算是完全构造妥当。在构造函数中发生异常，控制权转出构造函数之外。因此，在对象b的构造函数中发生异常，对象b的析构函数不会被调用。因此会造成内存泄漏。

用auto_ptr对象来取代指针类成员，便对构造函数做了强化，免除了抛出异常时发生资源泄漏的危机，不再需要在析构函数中手动释放资源；
如果控制权基于异常的因素离开析构函数，而此时正有另一个异常处于作用状态，C++会调用terminate函数让程序结束；
如果异常从析构函数抛出，而且没有在当地进行捕捉，那个析构函数便是执行不全的。如果析构函数执行不全，就是没有完成他应该执行的每一件事情。

98.类如何实现只能静态分配和只能动态分配

前者是把new、delete运算符重载为private属性。后者是把构造、析构函数设为protected属性，再用子类来动态创建
建立类的对象有两种方式：

静态建立，静态建立一个类对象，就是由编译器为对象在栈空间中分配内存；
动态建立，A *p = new A();动态建立一个类对象，就是使用new运算符为对象在堆空间中分配内存。这个过程分为两步，第一步执行operator new()函数，在堆中搜索一块内存并进行分配；第二步调用类构造函数构造对象；

只有使用new运算符，对象才会被建立在堆上，因此只要限制new运算符就可以实现类对象只能建立在栈上。可以将new运算符设为私有。

99.如果想将某个类用作基类，为什么该类必须定义而非声明？

派生类中包含并且可以使用它从基类继承而来的成员，为了使用这些成员，派生类必须知道他们是什么。

100.什么情况会自动生成默认构造函数？

带有默认构造函数的类成员对象，如果一个类没有任何构造函数，但它含有一个成员对象，而后者有默认构造函数，那么编译器就为该类合成出一个默认构造函数。不过这个合成操作只有在构造函数真正被需要的时候才会发生；如果一个类A含有多个成员类对象的话，那么类A的每一个构造函数必须调用每一个成员对象的默认构造函数而且必须按照类对象在类A中的声明顺序进行；
带有默认构造函数的基类，如果一个没有任务构造函数的派生类派生自一个带有默认构造函数基类，那么该派生类会合成一个构造函数调用上一层基类的默认构造函数；
带有一个虚函数的类
带有一个虚基类的类
合成的默认构造函数中，只有基类子对象和成员类对象会被初始化。所有其他的非静态数据成员都不会被初始化。

posted @ 2024-12-02 17:52 AutoDriver 阅读(8) 评论(0) 编辑收藏举报

刷新页面返回顶部

autodriver