面试总结

1.strcpy()函数的编写

char*strcpy(char *strDest, const char *strSrc);

{

   assert((strDest!=NULL) && (strSrc !=NULL));

   char *address =strDest;                 

   while( (*strDest++ = * strSrc++) != ‘/0’)   

      NULL;

   return address;                         

}

 

char *strcat(char *str1, char *str2)

{

           if((str1==NULL)||(str2==NULL))throw "Invalide arguments!";

           char*pt = str1;

           while(*str1!='\0')str1++;

           while(*str2!='\0')*str1++ = *str2++;

           *str1= '\0';

           returnpt;

}

 

 

2.虚函数表解析

主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

 

       typedef void(*Fun)(void);

            Baseb;

            FunpFun = NULL;

            cout<< "虚函数表地址：" << (int*)(&b) << endl;

            cout<< "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;

 

            //Invoke the first virtual function 

            pFun= (Fun)*((int*)*(int*)(&b));

            pFun();

 

实际运行经果如下：(Windows XP+VS2003,  Linux 2.6.22 + GCC 4.1.3)

 

虚函数表地址：0012FED4

虚函数表 — 第一个函数地址：0044F148

Base::f

一般继承：

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

 

多重继承：

1）  每个父类都有自己的虚表。

2）  子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

 

3.如何实现只能动态分配类对象，不能定义类对象？

 

将析构函数设为私有，类对象就无法建立在栈上了。

上述方法的一个缺点就是，无法解决继承问题。如果A作为其它类的基类，则析构函数通常要设为virtual，然后在子类重写，以实现多态。因此析构函数不能设为private。还好C++提供了第三种访问控制，protected。将析构函数设为protected可以有效解决这个问题，类外无法访问protected成员，子类则可以访问。

     另一个问题是，类的使用很不方便，使用new建立对象，却使用destory函数释放对象，而不是使用delete。（使用delete会报错，因为delete对象的指针，会调用对象的析构函数，而析构函数类外不可访问）这种使用方式比较怪异。为了统一，可以将构造函数设为protected，然后提供一个public的static函数来完成构造，这样不使用new，而是使用一个函数来构造，使用一个函数来析构。代码如下，类似于单例模式：

 class A  

1. {  
2. protected:  
3.     A(){}  
4.     ~A(){}  
5. public:  
6.     static A* create()  
7.     {  
8.         return new A();  
9.     }  
10.     void destory()  
11.     {  
12.         delete this;  
13.     }  
14. };  

只能建立在栈上：

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

4.stl中有哪些容器？

C++中有两种类型的容器：顺序容器和关联容器。顺序容器主要有vector、list、deque等。其中vector表示一段连续的内存，基于数组实现，list表示非连续的内存，基于链表实现，deque与vector类似，但是对首元素提供插入和删除的双向支持。关联容器主要有map和set。map是key-value形式，set是单值。map和set只能存放唯一的key，multimap和multiset可以存放多个相同的key。

容器类自动申请和释放内存，因此无需new和delete操作。

 

一、vector

vector基于模板实现，需包含头文件vector。

1.定义和初始化

//1.定义和初始化

   vector<int> vec1;    //默认初始化，vec1为空

   vector<int> vec2(vec1);  //使用vec1初始化vec2

   vector<int> vec3(vec1.begin(),vec1.end());//使用vec1初始化vec2

   vector<int> vec4(10);    //10个值为0的元素

vector<int> vec5(10,4);  //10个值为4的元素

 

//2.常用操作方法

   vec1.push_back(100);           //添加元素

    int size= vec1.size();         //元素个数

    bool isEmpty= vec1.empty();    //判断是否为空

   cout<<vec1[0]<<endl;        //取得第一个元素

   vec1.insert(vec1.end(),5,3);    //从vec1.back位置插入个值为的元素

    //vec1.pop_back();             //删除末尾元素

    //vec1.erase(vec1.begin(),vec1.end());//删除之间的元素，其他元素前移

   cout<<(vec1==vec2)?true:false;  //判断是否相等==、！=、>=、<=...

   vector<int>::iterator iter = vec1.begin();    //获取迭代器首地址

   vector<int>::const_iterator c_iter = vec1.begin();   //获取const类型迭代器

    //vec1.clear();                //清空元素

//3.遍历

    //下标法

    int length= vec1.size();

    for(int i=0;i<length;i++)

    {

      cout<<vec1[i];

    }

   cout<<endl<<endl;

    //迭代器法

    vector<int>::const_iteratoriterator = vec1.begin();

    for(;iterator!= vec1.end();iterator++)

    {

      cout<<*iterator;

    }

 

二、list

List是stl实现的双向链表，与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢。需要添加头文件list

 //1.定义和初始化

   list<int>lst1;          //创建空list

   list<int> lst2(3);       //创建含有三个元素的list

   list<int> lst3(3,2); //创建含有三个元素的list

   list<int> lst4(lst2);    //使用lst2初始化lst4

   list<int> lst5(lst2.begin(),lst2.end());  //同lst4

 

    //2.常用操作方法

   lst1.assign(lst2.begin(),lst2.end());  //分配值

   lst1.push_back(10);                    //添加值

   lst1.pop_back();                   //删除末尾值

   lst1.begin();                      //返回首值的迭代器

   lst1.end();                            //返回尾值的迭代器

   lst1.clear();                      //清空值

    bool isEmpty1= lst1.empty();          //判断为空

   lst1.erase(lst1.begin(),lst1.end());                        //删除元素

   lst1.front();                      //返回第一个元素的引用

   lst1.back();                       //返回最后一个元素的引用

   lst1.insert(lst1.begin(),3,2);         //从指定位置插入个

   lst1.rbegin();                         //返回第一个元素的前向指针

   lst1.remove(2);                        //相同的元素全部删除

   lst1.reverse();                        //反转

   lst1.size();                       //含有元素个数

   lst1.sort();                       //排序

   lst1.unique();                         //删除相邻重复元素

 //3.遍历

    //迭代器法

    for(list<int>::const_iteratoriter = lst1.begin();iter != lst1.end();iter++)

   {

      cout<<*iter;

   }

   cout<<endl;

 

三、deque

deque容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：push_front()。其余类似vector操作方法的使用。

四、map

C++中map容器提供一个键值对（key/value）容器，map与multimap差别仅仅在于multiple允许一个键对应多个值。需要包含头文件map。对于迭代器来说，可以修改实值，而不能修改key。Map会根据key自动排序。

 //1.定义和初始化

   map<int,string>map1;                  //空map

 //2.常用操作方法

   map1[3] = "Saniya";                    //添加元素

   map1.insert(map<int,string>::value_type(2,"Diyabi"));//插入元素

    //map1.insert(pair<int,string>(1,"Siqinsini"));

   map1.insert(make_pair<int,string>(4,"V5"));

   string str =map1[3];                  //根据key取得value，key不能修改

   map<int,string>::iterator iter_map = map1.begin();//取得迭代器首地址

    int key=iter_map->first;             //取得eky

   string value = iter_map->second;       //取得value

   map1.erase(iter_map);                  //删除迭代器数据

   map1.erase(3);                         //根据key删除value

   map1.size();                       //元素个数

   map1.empty();                      //判断空

   map1.clear();                      //清空所有元素

//3.遍历

    for(map<int,string>::iteratoriter = map1.begin();iter!=map1.end();iter++)

   {

       int keyk= iter->first;

      string valuev = iter->second;

}

 

五、set

set的含义是集合，它是一个有序的容器，里面的元素都是排序好的，支持插入，删除，查找等操作，就像一个集合一样。所有的操作的都是严格在logn时间之内完成，效率非常高。set和multiset的区别是：set插入的元素不能相同，但是multiset可以相同。Set默认自动排序。使用方法类似list。

(1)     vector
内部数据结构：数组。
内部数据结构：数组。
随机访问每个元素，所需要的时间为常量。
在末尾增加或删除元素所需时间与元素数目无关，在中间或开头增加或删除元素所需时间随元素数目呈线性变化。
可动态增加或减少元素，内存管理自动完成，但程序员可以使用reserve()成员函数来管理内存。
vector的迭代器在内存重新分配时将失效（它所指向的元素在该操作的前后不再相同）。当把超过capacity()-size()个元素插入vector中时，内存会重新分配，所有的迭代器都将失效；否则，指向当前元素以后的任何元素的迭代器都将失效。当删除元素时，指向被删除元素以后的任何元素的迭代器都将失效。

(2)     deque
内部数据结构：数组。
随机访问每个元素，所需要的时间为常量。
在开头和末尾增加元素所需时间与元素数目无关，在中间增加或删除元素所需时间随元素数目呈线性变化。
可动态增加或减少元素，内存管理自动完成，不提供用于内存管理的成员函数。
增加任何元素都将使deque的迭代器失效。在deque的中间删除元素将使迭代器失效。在deque的头或尾删除元素时，只有指向该元素的迭代器失效。

(3)list
内部数据结构：双向环状链表。
不能随机访问一个元素。
可双向遍历。
在开头、末尾和中间任何地方增加或删除元素所需时间都为常量。
可动态增加或减少元素，内存管理自动完成。
增加任何元素都不会使迭代器失效。删除元素时，除了指向当前被删除元素的迭代器外，其它迭代器都不会失效。

(4)slist
内部数据结构：单向链表。
不可双向遍历，只能从前到后地遍历。
其它的特性同list相似。

(5)stack
适配器，它可以将任意类型的序列容器转换为一个堆栈，一般使用deque作为支持的序列容器。
元素只能后进先出（LIFO）。
不能遍历整个stack。

(6)queue
适配器，它可以将任意类型的序列容器转换为一个队列，一般使用deque作为支持的序列容器。
元素只能先进先出（FIFO）。
不能遍历整个queue。

(7)priority_queue
适配器，它可以将任意类型的序列容器转换为一个优先级队列，一般使用vector作为底层存储方式。
只能访问第一个元素，不能遍历整个priority_queue。
第一个元素始终是优先级最高的一个元素。

(8)set
键和值相等。
键唯一。
元素默认按升序排列。
如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。

(9)multiset
键可以不唯一。
其它特点与set相同。

(10)hash_set
与set相比较，它里面的元素不一定是经过排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当然跟hash函数有关）。
其它特点与set相同。

(11)hash_multiset
键可以不唯一。
其它特点与hash_set相同。

(12)map
键唯一。
元素默认按键的升序排列。
如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。

(13)multimap
键可以不唯一。
其它特点与map相同。

(14)hash_map
与map相比较，它里面的元素不一定是按键值排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当然也跟hash函数有关）。
其它特点与map相同。

(15)hash_multimap
键可以不唯一。
其它特点与hash_map相同。

5.二叉树

N0=n2+1;

满二叉树、完全二叉树、非完全二叉树

二叉查找树（BinarySearchTree，也叫二叉搜索树，或称二叉排序树Binary Sort Tree）或者是一棵空树，或者是具有下列性质的二叉树：

    （1）、若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值；

    （2）、若它的右子树不为空，则右子树上所有结点的值均大于它的根结点的值；

（3）、它的左、右子树也分别为二叉查找树。

一棵红黑树是指一棵满足下述性质的二叉搜索树（BST, binary search tree）：

1. 每个结点或者为黑色或者为红色。 
2. 根结点为黑色。 
3. 每个叶结点(实际上就是NULL指针)都是黑色的。 
4. 如果一个结点是红色的，那么它的两个子节点都是黑色的（也就是说，不能有两个相邻的红色结点）。 
5. 对于每个结点，从该结点到其所有子孙叶结点的路径中所包含的黑色结点数量必须相同。 

平衡二叉树（Balanced Binary Tree）是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。1962年，G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树，所以它又叫AVL树。平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一个节点使得高度之差大于1，就要进行节点之间的旋转，将二叉树重新维持在一个平衡状态。这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。

 

红黑树，一种二叉查找树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。前面说了，红黑树，是一种二叉查找树，既然是二叉查找树，那么它必满足二叉查找树的一般性质。

     红黑树是通过节点分为红、黑两种颜色并根据一定的规则确保在一定程度上是平衡的，从而保证在红黑树中查找、删除、插入操作都只需要O（logk）的时间。

     在STL中set和multiset都是基于红黑树实现的。

 红黑树的性质：

1）  红黑树节点要么是红节点、要么是黑节点；

2）  根节点为黑节点；

3）  叶节点（空节点）为黑节点；

4）  每个红节点的两个子节点是黑节点；

5）    对于每个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑节点。

 

6.静态成员函数和数据成员有什么意义？

静态全局变量：在全局变量前,加上关键字 static 该变量就被定义成为了一个静态全局变量。

静态局部变量：

       A、该变量在全局数据区分配内存

        B、初始化：如果不是显式初始化，那么将被隐式初始化为0，以后的函数调用不再进行初始化。

        C、它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域。当定义它的函数或语句块结束时，其作用域也随之结束。

在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。

静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对一个存款类，每个实例的利息都是相同的，所以把利息可以设为存款类的静态数据成员。这有两个好处，一是不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省了存储空间。二是一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了。

普通的成员函数一般都隐藏了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this指针是缺省的、但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针，从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。

7.explicit是干什么用的？

原则上应该在所有的构造函数前加explicit关键字，当你有心利用隐式转换的时候再去解除explicit，这样可以大大减少错误的发生。

explicit关键字用来修饰类的构造函数，表明构造函数是显示的，相对的是implicit关键字。
首先这个关键字只能用在类内部的构造函数声明上，而不能用在类外部的函数定义上，它的作用是不能进行隐式转换。

从这里也就看出这个关键字的作用是将编译器隐式转换的功能给屏蔽掉。

 

8.内存溢出

heap：是由malloc之类函数分配的空间所在地。地址是由低向高增长的。
stack：是自动分配变量，以及函数调用的时候所使用的一些空间。地址是由高向低减少的。

 

一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap）— 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放
4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放
5、程序代码区—存放函数体的二进制代码。

 

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

数据结构方面的堆和栈，这些都是不同的概念。这里的堆实际上指的就是（满足堆性质的）优先队列的一种数据结构，第1个元素有最高的优先权；栈实际上就是满足先进后出的性质的数学或数据结构。

内存泄漏(memory leak)指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。内存泄漏与许多其他问题有着相似的症状，并且通常情况下只能由那些可以获得程序源代码的程序员才可以分析出来。然而，有不少人习惯于把任何不需要的内存使用的增加描述为内存泄漏，严格意义上来说这是不准确的。

　  一般我们常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的，大小任意的（内存块的大小可以在程序运行期决定），使用完后必须显式释放的内存。应用程序一般使用malloc，calloc，realloc，new等函数从堆中分配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存块，否则，这块内存就不能被再次使用，我们就说这块内存泄漏了。

 

比方说栈，栈满时再做进栈必定产生空间溢出，叫上溢，栈空时再做退栈也产生空间溢出，称为下溢。

这是程序语言中的一个概念，典型的，在C语言中，在分配数组时为其分配的长度是1024，但往其中装入超过1024个数据时，由于C语言不会对数组操作进行越界检查，就会造成内存溢出错误

导致内存溢出问题的原因有很多，比如： 
(1) 使用非类型安全(non-type-safe)的语言如 C/C++ 等。 
(2) 以不可靠的方式存取或者复制内存缓冲区。 
(3) 编译器设置的内存缓冲区太靠近关键数据结构。 

 

9.auto_ptr类

auto_ptr的使用很简单，通过构造函数拥有一个动态分配对象的所有权，然后就可以被当作对象指针来使用，当auto_ptr对象被销毁的时候，它也会自动销毁自己拥有所有权的对象（嗯，标准的RAAI做法），release可以用来手动放弃所有权，reset可用于手动销毁内部对象。

 

同时也不要将auto_ptr放进标准库的容器中，否则在标准库容器无准备的拷贝行为中（标准库容器需要的拷贝行为是等价的），会导致难以发觉的错误。

auto_ptr特殊的拷贝行为使得使用它来远距离传递动态对象变成了一件十分危险的行为，在传递的过程中，一不小心就会留下一些实际为空但程序本身却缺少这样认知的auto_ptr对象。

 

auto_ptr的几点注意事项：
1、auto_ptr不能共享所有权

2、auto_ptr不能指向数组

3、auto_ptr不能作为容器的成员

4、不能通过复制操作来初始化auto_ptr

std::auto_ptr<int> p(new int(42));//OK

std::atuo_ptr<int>p = newint(42);//Error

这是因为auto_ptr的构造函数被定义了explicit

5、不要把auto_ptr放入容器

 

shared_ptr是可以拷贝和赋值的，拷贝行为也是等价的，并且可以被比较，这意味这它可被放入标准库的一般容器（vector，list）和关联容器中（map）。