31问题：使用位操作符|和&实现给定一个整型变量a, 写两段代码，第一个设置a的bit 3，第二个清除a的bit 3 。以上两个操作中，要保持其它位不变。
回答：
#define BIT3 （0x1<<3）
static int a;
void set_bit3(void)
{
a|=BIT3;
}
void clear_bit3(void)
{
a &=~ BIT3;
} 32问题：运用位运算交换a、b两数？
回答：
#include <stdio.h>
int main()
{
int a=3;
int b=4;
a^=b;
b^=a;
a^=b;
printf("a= %d, b=%d/n",a,b);
} 33问题：C/C++中的两种死循环？
回答：1、 for（；；）死循环里的两个；；代表两个空语句，编译器一般会优化掉它们，直接进入循环体。
while（1）死循环里的1被看成表达式，每循环一次都要判断常量1是不是等于零。
for(;;) {循环体；};
按语法, for 循环 (初态;终态;步长） 这三部分，现在 是 (空语句;空语句;空语句)。
是合法的语句。由于没有给 终态 （即允许继续循环和终止循环的条件）， 循环语句于是可以 永远继续下去。俗称 无限循环 或 死循环。
但通常 循环体内 会有 语句控制 决定 是否中止。例如
for(;;) {... if (n>10) break; ...};
for(;;) {... if (n>10) goto Lab1; ...};
34问题：关键字static的作用是什么？
回答：①在函数体内，被申明为静态的变量在这一函数被调用的过程中维持其值不变。
②在模块内（但在函数外），一个被申明为静态的变量可以被模块内的所有函数访问，但不能被模块外的其它函数所访问，它是一个本地的全局变量。
③在模块内，一个被申明为静态的函数只可被这一模块内的其它函数调用，那就是这个函数被限制在申明它模块的本地范围内使用。
35问题：如何理解类、对象、消息？
回答：类是确定对象讲会拥有的特征（属性）和行为（方法），它不是具体客观存在的东西。类是具有相同属性和方法的一组对象集合（一个类可对应多个对象）。
类是抽象的概念，仅仅代表事物的模板，比如说“女朋友”、“男朋友”，是对象的设计蓝图。
对象是现实世界中各种各样的实体，即类的一个实例。一个能够“看得到，摸得着的”具体的实体，比如石榴姐
1，面向对象就是一种常见的思想。符合人们的思考习惯。从而更便于人们理解。
2，面向对象的出现，将复杂的问题简单化。提高了效率，因为人是一种抽象能力很强的生物。
3，面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。
消息：指的就是C＋＋（从Smalltalk中继承而来）这种把成员函数／方法绑定到对象上的面向对象机制。调用一个成员函数／方法的时候要先指定对象，在指定对象身上的操作——如“obj.op()”。
36问题：C++与C语言相比的改进？
回答：C++是C语言发展演变而来，C语言是过程式编程语言，它以过程为中心、以算法为驱动。而C++能够使用面向对象的编程方式，即使用以对象为中心、以消息为驱动的编程方式，这是相对于C最大的改进。
37问题：stuct与class的区别？
回答：①C语言的stuct与C++的class的区别：struct在C语言里用于将多种数据、多个变量组织在一起，便于表达比较复杂的数据类型，只能定义成员变量，不能定义成员函数。而class，则称作“类”，是C++新增来支持面向对象思想概念中“类”的概念的一个关键词，不仅可以像C语言中的struct一样把数据组织在一起，还可以将与数据相关的方法组织在一起，并增加了如虚函数、继承等特性来支持面向对象编程。
②C++语言的stuct与C++的class的区别:在C++中为了兼容C语言保留了该关键字，并且保留了C语言中的所有功能，同时还扩充了C的stuct功能，既能定义成员函数，还能定义成员函数。class中默认的成员访问权限是private，stcuct中默认的成员 访问权限是public；class继承默认是private继承，stcuct继承默认是public继承，以private方式继承父类的子类对象不能访问父类的public成员；
38问题：静态数据成员和静态成员函数？
回答：https://blog.csdn.net/qiana_/article/details/82083313
在类中只能声明可是不能定义，要对静态数据成员定义和初始化必须在类的外面也就是在全局作用域中定义，如果定义不给出初值，则默认初值为0； 静态数据成员甚至在类没有任何对象的时候都可以访问，静态成员可以独立访问，无需依赖任何对象的建立； 静态数据成员不属于任何对象，类的静态数据成员的存在不依赖于任何类对象的存在，静态数据成员是由类的所有对象共享的，包括该类的派生类对象，基类对象和派生类对象共享基类的静态数据成员；静态数据成员可以作为成员函数的默认形参，而普通数据成员则不可以。
静态成员函数的声明也很简单，就是在类的成员函数前加上static关键字即可，和静态成员一样，静态成员函数也是属于类的，它并不属于任何对象，当调用静态成员函数时应该使用类名和域运算符“∷”，当然也可以使用对象调用操作，但是这样的操作并不意味着静态成员函数属于这个对象，它只是被这个对象共享而已，这样也就决定了静态成员函数中是不能访问本类中的非静态数据成员的，它是不能访问非静态数据成员的，在c++中静态成员函数主要用来访问静态数据成员而不访问非静态数据成员
1.静态成员函数不能调用非静态成员函数，但是反过来是可以的
2.静态成员函数没有this指针，也就是说静态成员函数不能使用修饰符(也就是函数后面的const关键字)
3.静态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用 类成员函数指针来储存
39问题：C++中的空类默认会产生哪些类成员函数？class Empty { }；
回答：在C++的空类中，默认会产生默认的构造函数、复制构造函数、析构函数、赋值函数及取值函数。
40问题：构造函数与析构函数是否可以被重载？
回答：构造函数可以被重载，因为构造函数可以有多个，且可以带参数；
析构函数不可以被重载，因为析构函数只有一个，且不能带参数。
41问题：C++构造函数后面加冒号是什么意思？
回答：
A( int aa, int bb ):a(aa),b(bb)
{
}
// 相当于
A( int aa, int bb )
{
a=aa;
b=bb;
} 42问题：C++析构函数的执行顺序？
回答：原则1：先析构子类，后析构父类；原则2：先声明的对象后析构（顺序类似先进后出）。
43问题：编写类String的构造函数、析构函数和赋值函数？已知类如下：
class String
{
public:
String(const char *str=NULL); //普通构造函数
String(const String &other); //复制构造函数
~String(void); //析构函数
String &operator=(const String &other); //赋值函数
private：
char *m_String; //私有成员，保存字符串
} 回答：
44问题：为什么C语言不支持函数重载而C++能支持函数重载?
答案：函数重载是用来描述同名函数具有相同或者相似的功能，但数据类型或者参数不同的函数管理操作。
函数名经过C++编译器处理后包含了原函数名、函数参数数量及返回类型信息，而C语言不会对函数名进行处理。
45问题：重载和覆写?
回答：重载（overloading）是指子类改写父类的方法，重载可以有函数重载和运算符重载。
覆写（overriding）是指同一个函数的不同版本之间参数不同、或称重写，覆盖。
（1）重载
重载是编写一个与已有函数同名但参数列表不同（参数类型或参数个数不同）的方法，具有以下特征：
方法名必须相同
参数列表必须不同，与参数列表的顺序无关
返回值类型可以不同，但就两个函数的返回值而言，不足以区分两个函数是否重载。
（2）覆写
覆写是派生类重写基类的虚函数；具有以下特征：
只有虚函数和抽象方法才能够被覆写
具有相同的函数名
具有相同的参数列表
具有相同的返回值类型
（3）重载是一种语法规则，是由编译器在编译阶段完成，不属于面向对象编程；而覆写是由运行阶段决定的，是面向对象编程的重要特征。
46问题：什么是虚函数？
回答：参考https://blog.csdn.net/lys_best/article/details/7856219
47问题：对C++类继承关系的理解？
回答：①public继承，保留父类中成员的可见性不变，也就是说，如果父类中的某个函数是public的，那么在被子类继承后仍然是public的。
②protected继承，会将父类中的public可见性的成员修改为protected可见性，相当于在子类中引入了protected成员，这样在子类中还是可以调用父类的protected和public成员，子类的子类也就可以调用被protected继承的父类的protected和public成员。
③private继承，会将父类中的public和protected可见性的成员修改为private可见性。这样一来，虽然子类中同样还是可以调用父类的protected和public成员，但是子类的子类就不可以再调用被private继承的父类成员了。
48问题：什么是多态？
回答：多态、继承、封装是面向对象是设计思想的“三大特征”。多态的定义：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。有两种类型的多态性：①编译时的多态性（静态多态），是通过重载来实现的。②运行时的多态性（动态多态），通过虚函数来实现。动态多态是在虚函数的基础上实现的，而实现的条件有：
(1) 在类中声明为虚函数 （什么是虚函数参见：https://blog.csdn.net/lys_best/article/details/7856219）
(2) 函数的函数名，返回值，函数参数个数，参数类型，全都与基类的所声明的虚函数相同（否则是函数重载的条件）
(3) 将子类对象的指针（或以引用形式）赋值给父类对象的指针（或引用），再用该指向父类对象的指针（或引用）调用虚函数
#include <iostream>
using namespace std;
class A {
public:
A() {}
virtual void f() { cout << "A::f() is called.\n"; }
};
class B : public A {
public:
B() {}
virtual void f() { cout << "B::f() is called.\n"; }
};
int main() {
A a;
B b;
A *p1 = &a;
A *p2 = &b;
p1->f();
p2->f();
return 0;
} 运行结果：
A::f() is called.
B::f() is called. 49问题：构造函数的调用？
回答：在单继承中：申明一个子类的对象，则先调用父类的构造函数，然后调用子类的构造函数。
在多继承中的构造函数顺序：
(1)任何 虚拟基类的构造函数按照它们被继承的顺序构造；(#add 即声明顺序)
(2)任何非虚拟基类的构造函数按照它们被继承的顺序构造；
(3)任何成员对象的构造函数按照它们声明的顺序调用；
(4)类自己的构造函数。
50问题：如何消除多重继承的二义性？
回答：
class A {};
class B : public A {};
class C : public A {};
class D : public B, public C {};
int main()
{
D d;
A *pd = &d; //编译错误
return 0;
} 由于B、C继承自A，B、C都拥有A的一份拷贝，类D多重继承自B、C，因此拥有A的两份拷贝，如果此时一个类A的指针指向一个类D的实例，会出现“模糊的转换”之类的编译错误。解决办法如下：
class A {};
class B : virtual public A {}; //B虚拟继承自A
class C : virtual public A {}; //C虚拟继承自A
class D : public B, public C {};
int main()
{
D d;
A *pd = &d; //成功转换
return 0;
} 51问题：虚函数与纯虚函数有什么区别？
回答：
虚函数(impure virtual)，C++的虚函数主要作用是“运行时多态”，父类中提供虚函数的实现，为子类提供默认的函数实现。子类可以重写父类的虚函数实现子类的特殊化。
纯虚函数(pure virtual)，C++中包含纯虚函数的类，被称为是“抽象类”。抽象类不能使用new出对象，只有实现了这个纯虚函数的子类才能new出对象。C++中的纯虚函数更像是“只提供申明，没有实现”，是对子类的约束，是“接口继承”。C++中的纯虚函数也是一种“运行时多态”。
纯虚函数只有定义，没有实现；而虚函数既有定义，也有实现的代码。纯虚函数一般没有代码实现部分。包含纯虚函数的类不能定义其对象，而包含虚函数的则可以。
52问题：抽象类不能实例化？
回答：
#include <iostream>
using namespace std;
class Shape
{
public:
Shape(){}
~Shape(){}
virtual void Draw()=0;
};
void main()
{
Shape s1; //错误 Shape * s1；
}
Shape类的Draw()函数是一个纯虚函数，因此Shape类就是一个抽象类，它是不能实例化一个对象的，因此main函数中的对象声明错误，解决办法是将Draw函数修改成一般虚函数或者把s1定义成Shape的指针。
53问题：函数指针与指针函数的区别？
回答：1、指针函数是指带指针的函数，即本质是一个函数，函数返回类型是某一类型的指针。
2、函数指针是指向函数的指针变量，即本质是一个指针变量。
参考： http://nevel.cnblogs.com/p/6370264.html
54问题：什么是链表？
回答：1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。
2、结点包括两个部分：一、存储数据元素的数据域（内存空间），二、存储指向下一个结点地址的指针域。
3、相对于线性表顺序结构，操作复杂。
二、链表的作用
1、实现数据元素的存储按一定顺序储存，允许在任意位置插入和删除结点。
2、包括单向结点，双向结点，循环接点
3、c/c++/jave都可以实现
优点、链表实现数据元素储存的顺序储存，是连续的。
缺点、因为含有大量的指针域，所以占用空间大，同时因为只有头结点（后面说明）是明确知道地址的，所以查找链表中的元素需要从头开始寻找，非常麻烦。https://blog.csdn.net/wislosophia/article/details/71856514
55问题：编程实现一个单链表节点的插入？
回答：
node *insert_node(node *head,int pos,int data)
{
node *item = NULL;
node *p;
item = (node *)malloc(sizeof(node));
item->data=data;
if(pose == 0) //插入链表头后面
{
head->next =item; // head后面是item
return head;
}
p = search_node(head, pos); // 获得位置pos的节点指针
if(p!=NULL)
{
item->next=p->next; //item指向原pos节点的后一个节点
p->next = item; //把item插入到pos的后面
}
return head;
} 56问题：实现一个单链表的逆置？
回答：
node *reverse_node(node *head)
{
node *p, *q,*r;
if(head==NULL) //链表为空
{
return head;
}
p=head->next;
q=p->next; //保留原第二个节点
p->next=NULL; //保留第一个节点为末节点
while(q!=NULL) //遍历，各个节点的next指针反转
{
r=q-next;
q->next=p;
p=q;
q=r;
}
head-next=p; //新的第一个节点为原末节点
rturn head;
} 56问题：举例说明什么是泛型编程？
回答：泛型编程是指编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同，所谓泛型是指具有多种数据类型上皆可操作的含义。例如：
int max(int a, int b) //重载1
{
return a>b?a:b;
}
int max(double a, double b) //重载2
{
return a>b?a:b;
}
int max(float a, float b) //重载3
{
return a>b?a:b;
} 以上3个重载函数分别实现了不同的数据类型的两个数进行大小比较，可以通过以下模板实现：
template<class T> //class也可以换成typname
T max(T a, T b)
{
return a>b?a:b;
} 57问题：函数模板和类模板有什么区别？
回答：我们在使用函数模板max时不一定必须指明T的类型，函数模板max的实例化是由编译程序在处理函数调用时自动完成的，当调用max（1,2）时自动生成实例max<int>。函数模板是一种抽象的函数定义，代表一类同构函数，类模板是一种更高层次的抽象的类定义。函数模板的实例化由编译器在处理函数调用时自动完成的，而类模板的实例化必须由程序员在程序中显示的指定。模板类的实例个数是由类型参数的种类决定的。
58问题：什么是STL？
回答：即标准模板库，是一个具有工业强度的、高效的C++程序库。它是最新的C++标准库中的一个子集，包括容器、算法、迭代器组件。
59问题：List与vector的区别？
回答：vector拥有一段连续的内存空间，因此支持随机存取，如果需要高效的随机存取，而不在乎插入和删除的效率，就使用vector。
list拥有一段不连续的的内存空间，因此不支持随机存取，需要大量的插入和删除，而不关心随机存取，则应用list
京公网安备 11010502036488号