1. 限定类型修饰符。
   1. int const a = 1; //int型常量。需要在定义时就初始化。

   　　

   2. int const arr[] = {1 ,2 , 3}; //数组中每一个元素都是常量。但是注意，不能把1中的a和arr[1]当作一样的。比如说可以紧接着这样定义：
      int testArr[a]; //正确
      int testArr[arr[1]]; //错误
      原因：const用于集合时，编译器不会把这个集合放到其符号表中，那么需要为其分配内存。但是虽然为其分配内存，其值却不能在编译阶段使用。

   　　

   3. int const *p; //p是一个指向int型常量的指针。这里的p指针没必要在定义的时候就初始化。不过*p是只读的，就是说不能通过*p来修改其所指向地址的值，但是可以通过其他指针修改。

   　　

   4. int * const p; // p是一个指针常量，指向int型变量。p本身不能改变。不过*p是可读可写的。

   　　

   5. 自然，综合上面两个，就有了int const * const p; //意义不言自明了吧？

   　　

   6. class A; const A a; 简单的用法，跟上面是一样的。不过牵扯到类，就变得复杂了，有些我也搞不明白。
2. 转换规则
   　　描述起来费劲，不如看例子。
   　　const int *pa;
   　　int * pb;
   　　pb = pa; //错误，不能直接将指向常量的指针转换为指向非常量的指针。
   　　pa = pb; //正确。
   　　pb = (int *) pa; //可以强制转换。不过转换后就失去了原有的保护机制。这时就可以通过pb修改pa所指向地址的值。

　

3. 作为函数参数
   　　
   1. const修饰函数参数，就是希望函数不修改这个参数的值。对于值传递来说，没必要用const，因为函数即使修改了也是修改的副本，对实参没影响。但是这种拷贝毕竟费时耗内存，所以有了引用。此时又不希望引用被修改，所以可以加上const限定。比如：
      void fun( int const & );

   　　

   2. 但是记住，const仅仅只能希望程序不修改参数的值或者参数指向的地址的值，但不能杜绝它那么作。加入const可以让编译器在编译阶段就能检查出不希望的修改行为。但如果你强制修改或通过其他方式，照样是可以达到目的的。比如：
      void fun( int const *a){
      int *tmp = (int *)a;
      *tmp = *tmp +1;
      }

　

4. 限定函数
   　　主要是限定类的成员函数。如果不希望一个成员函数修改任何一个类的成员数据，比如说这个函数只是打印信息。就可以像下面这样限定：
   class A{
   void fun(…) const; //不要把const写到最前面了，那意义可就变了。
   }
   　　但是，如果某个成员有mutable修饰，那上面的const就不对它保护了，程序可以随便修改。

　

5. 修饰函数返回值
   　　如果像这样：const int fun( );使用，我觉得没有什么意义。因为，系统会将返回值复制到函数外部的临时存储单元中。如果是：const char * fun( ); 那么只能用const char *型变量来保存。const char * rtv = fun( );

　

6. 多文件中共享const常量
   　　在C中定义时，如果是： int Max = 100 ; 默认的linkage就是extern，此时在其他文件中通过声明extern int Max ; 就可以使用Max 了。有时候需要在多个源文件中共享某个常量，此时注意了。在C++中，const定义默认具有 internal linkage，如果你定义int const Max = 100 ; 希望其他文件通过声明： extern int const Max ;来使用Max，那就会编译错误，提示找不到Max。此时需要显示的声明为Max为extern，即extern int const Max = 100 ;

　

7. const其他
   　　const比#define要好得多的多。#define是在预处理时展开，定义的符号在编译完成之后，就不存在了，原来的地方全部成了立即数。const定义的常量在运行期间也是存在的，在编译阶段有可能加入符号表，方便查询，所以编译速度也不是大问题。由上也可推出，const会在某些场合比define少些内存分配。比如说：const str[] = “hello”; 如果程序中用到了多次str，那么str只需要一次内存分配，之后使用只要给出地址就行。而define：#define str “hello”; 将多次出现的地方全部替换成了立即数，那么每次使用时都需要为之分配内存，也就是说内存中会存在str的多个拷贝。

———————————————————————————————————

　　上面的代码可能有让你不舒服的地方，尤其 int const * p ; 而不是写作 const int *p ; 在说明我为什么这么写（下一篇文章）之前，问个问题，如果你能很清晰地回答正确，就没必要继续看了。
　　参考：Dan Saks写的《const T vs T const》。
　　［问题］
typedef void *VP;
const VP vectorTable[] = { … …};
跟下面的是不是等价的？
const void *vectorTable[] = { …… };

［基础知识］
　　考察基础知识，在笔试题目最常见，占比例也最大。

1. 有n个节点的二叉树，其中有m个节点有两个孩子，问这棵树有多少颗叶子节点。

   这题目其实是数据结构上的原题，不要被n迷惑了。

2. 问这段代码输出什么？考察C++基础。

   class A{ 
   public: 
   int x(){return 2;} 
   }; 
   class B : public A{ 
   public: 
   int x(){return 3;} 
   }; 
    
   int main(){ 
   A *a = new A(); 
   A *b = new B(); 
   cout << a->x() << b->x() <<endl; 
   return 0; 
   }

   　　
   

   类A中的函数x并非虚函数，所以不会发生动态绑定。

3. 　　下列哪个表达式是错误的?
   　　int a = 10;
   　　1. (a++) += a;
   　　2. (++a) += (a++);
   　　
   

   a++其实是分三个步骤的：{tmp=a;++a;return tmp;}所以a++不能作为左值。

4. 　　问下面的程序需要几次才能跳出循环?

   　　unsigned int a =5;
   　　int b = 2;
   　　while ( a+b >= 0){
      　　　b--;
   　　}

   　　
   

   C++中有符号和无符号类型之间的转换，要遵循一个原则：所定义的转换规则需要保护操作数的精度。比如long和unsigned int类型，只要机器上的long型足够表示unsigned int型的所有值，就将unsigned int转换为long型，否则，将两个操作数都转换为unsigned long。而对于包含signed 和 unsigned int型的表达式，其转换则是将signed型数值转换为unsigned型。如果此时将int转换为unsigned int，而int型数值恰好为负数，那这带来了副作用。此题就是一个例子。

5. 　　union{
   　　int i;
   　　char x[2];
   　　}a;

   　　a.x[0] = 8;
   　　a.x[1] = 1;
   　　问 a.i为多少?
   　　
   

   首先要了解的是，数据在内存中的存储方式。比如一个int型数，4个字节，表示为ABCD，在内存其实是DCBA保存的。那么看这题，内存中保存的是：00001000 00000001 00000000 00000000.根据上面的规则，那么用int来读取这段数据，即为00000000 00000000 00000001 00001000，即264.

6. 　　map,set,hashmap和multimap,有个与其他三个数据结构不同的是哪一个?
   　　
   

   hashmap，采用和其他三种都不同的方式。

7. 　　如果一个数列中的元素距离他们各自最终的位置都很近，那么哪一种算法最省时间？（直接插入，堆排序，快速排序，选择排序）
   　　
   

   我感觉是直接插入排序，当然还需要测试。

8. 　　const char *和char * const 的区别。
   　　　
   

   const char *p;结合的方式是自右向左。所以p首先是个指针，然后个char型指针，然后他指向的是个const,此时，p本身的值可以改变的，但是不能通过p来修改p所指向区域A的值，但A可以通过其他指针修改。同理，char * const p，p首先是个const对象，之后才是指向char型的指针，此时p本身是不能修改的。

9. 　　问下面的结果？
   　　char a = 50;
   　　int i = sizeof( a = (a+205));
   　　问 i 和 a各为多少?
   　　
   

   i为1大家都可以看出来，但a为多少相信就不是那么容易答对了。答-1的算好的，说255的就可以回去看计组了。sizeof(A)是个大难点，尤其是A如果是struct类型的时候。此题中，sizeof(A)的值其实是在编译阶段就已经确定了，所以根本没有运行a = a+205 这一步。在编译完成后，这句就相当于int i = 1;

10. 　　计算机网络单播，组播，广播的区别。路由器和交换机的作用和原理。ARP协议的内容，以及其他相关的PPPOE协议的知识。
11. 　　修改错误的代码：快排和堆排序。这完全的基本功了，为了面试，多练习在纸上写程序吧。

　　类似的题目还有很多。这些题目如果不能拿分的话，给面试官的印象会很不好。这几次面试的时候，面试官手里一般都是我的笔试试卷 + 面试评分单。面试官都会拿我的基础题目说，为什么这道题目都不会？所以把握基础题目至关重要的。

　　计算机本身是门实践性更强的学科，所以如果平时不怎么编程，是很难发现自己的问题和未知的领域的。tencent的笔试题目考得很细很深，平时不上机code的同学可能很难会想到所考的知识点； 而遇到问题时不刨根问底或者得过且过，则会造成更大的遗憾。const char *和char * const的区别，内存的分配方式和管理方式，内存泄漏等等，平时感觉到有一丁点疑惑时，问题的背后一般藏有更多你不了解的；还有一点也很重要，像PPPOE并不是在书上，但是大家听说的就比较多了。应该及时的去了解这些前沿领域（虽然PPPOE不算前沿），保持对本专业发展方向的敏感，扩大自己的视野。

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;
 
int main()
{
    vector<int> v1((istream_iterator<int>(cin)),(istream_iterator<int>()));
    sort(v1.begin(),v1.end());
    copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));
    return 0;
}

　　【题目2】三句话实现：单词的输入，剔除其中重复的单词，并按字母顺序输出。

	vector<string> v1((istream_iterator<string>(cin)),(istream_iterator<string>()));
	sort(v1.begin(),v1.end());
	unique_copy(v1.begin(),v1.end(),ostream_iterator<string>(cout," "));

　　
　　【woj1170】Problem 1170 – Sorting 　　重写了遍。

    vector<int>  v1((istream_iterator<int>(cin)),(istream_iterator<int>()));
    v1.erase(v1.end()-1);
    sort(v1.begin(),v1.end());
    unique_copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));

　　这题目用vector的效率不高，用list快些。

　　【总结】
　　明白Sandy的意思是让我练习下STL，我说了很久要学要学，但是好久之后依然还没动，被这个被那个事情给耽搁着。前天晚上和Sandy的聊天，让我明白了，这些知识并不是要等某一天某一大段时间再去学习，而是点滴积累的。

　　以上的两道题目牵涉到的有：(这几天总结下)
　　

• 输入流迭代器

　　

• sort

　　

• vector，list，deque

　　

• unique_copy 和 copy

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

#include "iostream"
#include "cmath"
#include "cstdlib"
using namespace std;
 
int main(){
 
	int n=3;
 
	unsigned int a=1,b=1,c=2;//a保存F(n-2),b保存F(n-1),c保存F(n)
 
	unsigned int MaxInt=pow(2.0,31)-1;
 
	while(c<MaxInt){
		c=a+b;
		a=b;
		b=c;
 
		++n;
	}
 
	cout <<n<<endl;
	system("pause");
	return 0;
}

运行不到1秒钟,结果为48.当时我笔试的时候犯了个低级错误,int型的最大值是2^31-1而不是2^32-1(unsigned int类型)。
第四题，哥德巴赫猜想，一个偶数必然可以表示成两个素数之和。那么现在给一个N(4<=N<=1000),求N可被表示为不同的两个素数对的个数。比如20,可以表示为(3,17)和(7,13)两对.思路也比较简单,打个素数表,然后在[2,N/2]之间的素数判断,假设当前值为i,只要判断N-i是否为素数就可以了.代码不贴了.
第五题还不错.问析构函数用虚函数有什么作用?举个例子说明这点.我对虚函数了解不多,当时感觉可能造成内存泄漏,然后就糊弄着写了下.回来后Sandy给我讲了下,才渐渐明了.
首先应该知道一点,析构函数不必要是虚函数.
其次,考虑两个问题,(1)析构函数为什么要声明为虚函数?在什么地方需要? (2)为什么析构函数要层层由子类向基类析构?
先看代码:

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
30
31
32
33
34
35
36
37
38
39
40

class sth
{
public:
	~sth(){printf("sth freed.
");}
};
 
class A{
 
public:
	A(int a1):a(a1){s1=new sth();}
	virtual ~A(){printf("A:%d  destroyed
",a);}
	virtual void F(){printf(" A(%d)::F called 
",a);delete s1;}
	int a;
	sth *s1;
};
 
class B : public A{
public :
	B(int a1):A(a1){s2=new sth();}
	virtual ~B(){printf("B:%d  destroyed
",a);}
	virtual void F(){printf(" B(%d)::F called 
",a);delete s2;}
	sth *s2;
};
 
int test()
{
	A a1(1);
	B b1(2);
	A *a2;
	a2=new B(3);
	//a2->F();
	delete a2;
 
	return 0;
}

如果不将class A的析构函数声明为虚函数,那么当声明一个A *a2;时,系统知道a2是指向A对象的指针,但是你又a2=new B(3);那系统是不会知道a2实际指向了B的.此时如果delete a2时,系统只会调用A的析构函数.这就是释放一半留一半,内存泄漏了.
系统在有虚函数的时候,会建立一个虚函数表,这个表中就是一些函数指针.当a2=new B(3)时,此时a2就是指向了B的对象,因此会调用B的析构函数.
那么为什么要层层向上级析构呢? 因为每一层只管理当前层的数据的释放.虽然子类知道父类分配了些内存,但是却不知道怎么释放,或者说这事不用他管.只要层层回调析构,就可以达到释放所分配的内存.这个过程跟子类的构造函数的过程正好相反.构造函数是由基类向子类层层构造.

总结：虽然这次笔试难度很低,不过还是学到了些东西.一个是要细心,基础的概念要扎扎实实的,以后还有类似unsigned和int之类的问题.另一个是C++不仅要看,而且要多写.之前看过很多遍虚函数,换个问题就没思路了.