C&C++——C与C++知识点

C++知识点系列之一（转+整理）

编程时类声明后面千万不要忘了加分号，不然会出现很多错误！！

c系列之一
一、#include “filename.h”和#include<filename.h> 的区别
#include “filename.h”是指编译器将从当前工作目录上开始查找此文件
#include<filename.h> 是指编译器将从标准库目录中开始查找此文件

二、头文件的作用
加强安全检测
通过头文件可能方便地调用库功能，而不必关心其实现方式

三、* , &修饰符的位置
对于*和&修饰符，为了避免误解，最好将修饰符紧靠变量名

四、if语句
不要将布尔变量与任何值进行比较，那会很容易出错的。
整形变量必须要有类型相同的值进行比较
浮点变量最好少比点，就算要比也要有值进行限制
指针变量要和NULL进行比较，不要和布尔型和整形比较

五、const和#define的比较
const有数据类型，#define没有数据类型
个别编译器中const可以进行调试，#define不可以进行调试
在类中定义常量有两种方式
1、 在类在声明常量，但不赋值，在构造函数初始化表中进行赋值；
2、 用枚举代替const常量。

六、C++函数中值的传递方式
有三种方式：值传递(Pass by value)、指针传递(Pass by pointer)、引用传递(Pass by reference)
void fun(char c) //pass by value
void fun(char *str) //pass by pointer
void fun(char &str) //pass by reference
如果输入参数是以值传递的话，最好使用引用传递代替，因为引用传递省去了临时对象的构造和析构
函数的类型不能省略，就算没有也要加个void

七、函数体中的指针或引用常量不能被返回
Char *func(void)
{
char str[]=”Hello Word”;
//这个是不能被返回的，因为str是个指定变量，不是一般的值，函数结束后会被注销掉
return str;
}
函数体内的指针变量并不会随着函数的消亡而自动释放

八、一个内存拷贝函数的实现体
void *memcpy(void *pvTo,const void *pvFrom,size_t size)
{
assert((pvTo!=NULL)&&(pvFrom!=NULL));
byte *pbTo=(byte*)pvTo; //防止地址被改变
byte *pbFrom=(byte*)pvFrom;
while (size-- >0)
pbTo++ = pbForm++;
return pvTo;
}

九、内存的分配方式
分配方式有三种，请记住，说不定那天去面试的时候就会有人问你这问题
1、 静态存储区，是在程序编译时就已经分配好的，在整个运行期间都存在，如全局变量、常量。
2、 栈上分配，函数内的局部变量就是从这分配的，但分配的内存容易有限。
3、 堆上分配，也称动态分配，如我们用new,malloc分配内存，用delete,free来释放的内存。

十、内存分配的注意事项
用new或malloc分配内存时，必须要对此指针赋初值。
用delete 或free释放内存后，必须要将指针指向NULL
不能修改指向常量的指针数据

十一、内容复制与比较
//数组……
char a[]=”Hello Word!”;
char b[10];
strcpy(b,a);
if (strcmp(a,b)==0)
{}
//指针……
char a[]=”Hello Word!”;
char *p;
p=new char[strlen(a)+1];
strcpy(p,a);
if (strcmp(p,a)==0)
{}

十二、sizeof的问题
记住一点，C++无法知道指针所指对象的大小，指针的大小永远为4字节
char a[]=”Hello World!”
char *p=a;
count<<
count<<
而且，在函数中，数组参数退化为指针，所以下面的内容永远输出为4
void fun(char a[1000])
{
count<<
}

十三、关于指针
1、 指针创建时必须被初始化
2、 指针在free 或delete后必须置为NULL
3、 指针的长度都为4字节
４、释放内存时，如果是数组指针，必须要释放掉所有的内存，如
char *p=new char[100];
strcpy(p,”Hello World”);
delete []p; //注意前面的［］号
p=NULL;
５、数组指针的内容不能超过数组指针的最大容易。
如:
char *p=new char[5];
strcpy(p,”Hello World”); //报错 目标容易不够大
delete []p; //注意前面的［］号
p=NULL;

十四、关于malloc/free 和new /delete
malloc/free 是C/C+的内存分配符，new /delete是C++的内存分配符。
注意：malloc/free是库函数，new/delete是运算符
malloc/free不能执行构造函数与析构函数，而new/delete可以
new/delete不能在C上运行，所以malloc/free不能被淘汰
两者都必须要成对使用
C++中可以使用_set_new_hander函数来定义内存分配异常的处理

十五、Ｃ++的特性
Ｃ++新增加有重载(overload)，内联（inline），Const，Virtual四种机制
重载和内联：即可用于全局函数，也可用于类的成员函数；
Const和Virtual：只可用于类的成员函数；
重载：在同一类中，函数名相同的函数。由不同的参数决定调用那个函数。函数可要不可要Virtual关键字。和全局函数同名的函数不叫重载。如果在类中调用同名的全局函数，必须用全局引用符号::引用。

覆盖是指派生类函数覆盖基类函数
函数名相同；
参数相同；
基类函数必须有Virtual关键字；
不同的范围(派生类和基类)。

隐藏是指派生类屏蔽了基类的同名函数相同
1、 函数名相同，但参数不同，此时不论基类有无Virtual关键字，基类函数将被隐藏。
2、 函数名相同，参数也相同，但基类无Virtual关键字(有就是覆盖)，基类函数将被隐藏。

内联：inline关键字必须与定义体放在一起，而不是单单放在声明中。

Const：const是constant的缩写，“恒定不变”的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
1、 参数做输入用的指针型参数，加上const可防止被意外改动。
2、按值引用的用户类型做输入参数时，最好将按值传递的改为引用传递，并加上const关键字，目的是为了提高效率。数据类型为内部类型的就没必要做这件事情；如：
将void Func(A a) 改为void Func(const A &a)。
而void func(int a)就没必要改成void func(const int &a);
3、 给返回值为指针类型的函数加上const，会使函数返回值不能被修改，赋给的变量也只能是const型变量。如：函数const char*GetString(void); char *str=GetString()将会出错。而const char *str=GetString()将是正确的。
4、 Const成员函数是指此函数体内只能调用Const成员变量，提高程序的键壮性。如声明函数 int GetCount(void) const;此函数体内就只能调用Const成员变量。
Virtual：虚函数：派生类可以覆盖掉的函数，纯虚函数：只是个空函数，没有函数实现体；

十六、extern“C”有什么作用？
Extern “C”是由Ｃ＋＋提供的一个连接交换指定符号，用于告诉Ｃ＋＋这段代码是Ｃ函数。这是因为C++编译后库中函数名会变得很长，与C生成的不一致，造成Ｃ＋＋不能直接调用C函数，加上extren “c”后，C++就能直接调用C函数了。
Extern “C”主要使用正规DLL函数的引用和导出 和 在C++包含C函数或C头文件时使用。使用时在前面加上extern “c” 关键字即可。

十七、构造函数与析构函数
派生类的构造函数应在初始化表里调用基类的构造函数；
派生类和基类的析构函数应加Virtual关键字。
不要小看构造函数和析构函数，其实编起来还是不容易。
#include
class Base
{
public:
virtua ~Base() { cout<< "~Base" << end ; }
};
class Derived : public Base
{
public:
virtua ~Derived() { cout<< "~Derived" << end ; }
};
void main(void)
{
Base * pB = new Derived; // upcast
delete pB;
}
输出结果为：
~Derived
~Base
如果析构函数不为虚，那么输出结果为
~Base

十八、#IFNDEF/#DEFINE/#ENDIF有什么作用
仿止该头文件被重复引用

C++知识点系列之二
1. 写一个"标准"宏MIN ，这个宏输入两个参数并返回较小的一个。
#define MIN(A,B) （（A） <= (B) ? (A) : (B))
这个测试是为下面的目的而设的：
1) 标识#define在宏中应用的基本知识。这是很重要的。因为在 嵌入(inline)操作符变为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。
2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。
3) 懂得在宏中小心地把参数用括号括起来
4) 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？
least = MIN(*p++, b);
2.嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？
这个问题用几个解决方案。我首选的方案是：
while(1)
{
}
一些程序员更喜欢如下方案：
for(;;)
{
}
这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，我将用这个作为一个机会去探究他们这样做的基本原理。如果他们的基本答案是："我被教着这样做，但从没有想到过为什么。"这会给我留下一个坏印象。
第三个方案是用 goto
Loop:
...
goto Loop;
应试者如给出上面的方案，这说明或者他是一个汇编语言程序员（这也许是好事）或者他是一个想进入新领域的BASIC/FORTRAN程序员。
3.
a) 一个整型数（An integer）
b)一个指向整型数的指针（ A pointer to an integer）
c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r
d)一个有10个整型数的数组（ An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers）
f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers）
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）
答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer
人们经常声称这里有几个问题是那种要翻一下书才能回答的问题，我同意这种说法。当我写这篇文章时，为了确定语法的正确性，我的确查了一下书。但是当我被面试的时候，我期望被问到这个问题（或者相近的问题）。因为在被面试的这段时间里，我确定我知道这个问题的答案。应试者如果不知道所有的答案（或至少大部分答案），那么也就没有为这次面试做准备，如果该面试者没有为这次面试做准备，那么他又能为什么出准备呢
4.
关键字static的作用是什么？
这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：
1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。
5. 关键字const有什么含意？
我只要一听到被面试者说："const意味着常数"，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着"只读"就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）
如果应试者能正确回答这个问题，我将问他一个附加的问题：
下面的声明都是什么意思？
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
1) 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
2) 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
3) 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。
6. 关键字volatile有什么含意?并给出三个不同的例子。
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
1) 并行设备的硬件寄存器（如：状态寄存器）
2) 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3) 多线程应用中被几个任务共享的变量
回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。
假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
1)一个参数既可以是const还可以是volatile吗？解释为什么。
2); 一个指针可以是volatile 吗？解释为什么。
3); 下面的函数有什么错误：
int square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案：
1)是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
2); 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3) 这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
int square(volatile int *ptr) {
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
long square(volatile int *ptr) {
int a;
a = *ptr;
return a * a;
}
7.位操作（Bit manipulation）
下面的代码输出是什么，为什么？
void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) ? puts("> 6") : puts("<= 6");
}
这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是 ">6"。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。
8. Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子：
#define dPS struct s *
typedef struct s * tPS;
以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？
这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子：
dPS p1,p2;
tPS p3,p4;
第一个扩展为
struct s * p1, p2;
.
上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。晦涩的语法
9. C++中什么数据分配在栈或堆中，New分配数据是在近堆还是远堆中？
答：栈: 存放局部变量，函数调用参数,函数返回值，函数返回地址。由系统管理
堆: 程序运行时动态申请，new 和　malloc申请的内存就在堆上

C++知识点系列之三

关于预处理
#define的常量用const取代，宏用inline函数取代。
在类定义中定义的函数自动为内联函数。也可以使用inline修饰函数使其成为内联的。inline只有在函数定义时才会发挥作用。因此头文件中的内联函数都是有函数体的。inline的函数也是内部联接的。
friend的函数也可以是inline的。
inline只是对编译器的优化提示，编译器不一定会对所有的inline进行内联。

不可替代的预处理功能：
字符串化（#，将标识符转化为字符串）：#define DEBUG(x) cout << #x " = " << x << endl
记号粘贴（##，连接两个标识符形成一个新的标识符）：#define FIELD(a) char* a##_string; int a##_size

static
编译器保证对static的内置类型赋初值。对于static的对象调用其默认的构造函数。
static对象的析构函数会在main()函数结束或调用exit()时被自动调用。因此在static对象的析构函数中调用exit()可能会导致递归调用。调用abort()时不会自动调用static对象的析构函数。
全局的对象是static的。因此全局对象的构造和析构函数可以用来在进入main()之前和退出main()之后完成一些工作。
对于全局的对象来说，因为其本身是静态存储的，因此使用static修饰的效果只是使其变为内部联接。

静态数据成员的定义：
class A {
static int i;
public:
//...
};
int A::i = 1;
只有static const的整型才能在类内部被初始化，其他类型都必须在外部（文件域中）被初始化。因此本地类（在函数中定义的类）中不能定义静态成员。

static的成员函数在类中定义。为所有该类的对象共用，调用时可以直接使用类名::函数名。
static的成员函数只能访问static的成员，因为static的成员没有this。
static初始化的依赖关系（最好避免）。可参考iostream的实现（cin、cout和cerr都是在不同文件中的static对象）或另一种（居然无名！）方法。

namespace
#include <iostream.h>
意味着
#include <iostream>
using namespace std;
因为在标准化之前不存在名字空间，.h中的所有内容都是暴露的
namespace定义只能出现在全局域或另一个namespace中。定义的{}后没有分号。可以跨越多个文件定义（不算重复定义）。也可以定义别名。如：
namespace Bob = BobsSuperDuperLibrary;
每个编译单元都有一个未命名的namespace。通过将变量放入这个namespace中就可以不必将它们声明为static的（内部联接）。C++中要达到文件内的静态就使用这种方法。

类中声明的友元也会进入这个类所在的namespace。
using namespace只在当前域内有效（将namespace中的所有名称注入当前域）。using namespace中引入的名称可以被覆盖。
联接方式。比如需要在C++中调用C的库中的函数：
extern "C" float f(int a, char b);
否则的话联接程序可能无法解析函数调用。通常编译器都会自动处理这种情况。

引用和指针
引用必须在创建时被初始化为引用某一个变量，并且一旦在初始化后就不能再改变被引用的对象。
函数返回引用时要注意引用的对象不能在函数返回后就不存在了，比如函数内部的变量。
拷贝构造函数接受的是本类的引用。定义拷贝构造函数就必须定义构造函数。
通过声明一个private的拷贝构造函数可以防止对象被传值。

指向特定类中成员的指针：
声明：
int ObjectClass::*pointerToMember;
初始化：
int ObjectClass::*pointerToMember = &ObjectClass::a;
使用：
objectPointer->*pointerToMember = 47;
object.*pointerToMember = 47;
对于成员函数也适用

运算符重载
重载的运算符必须接受至少一个自定义类型。接受的参数都为内置类型的运算符无法被重载。
运算符作为类的成员函数被重载时，类的对象就作为第一个参数。注意此时函数的返回方式。
重载++a会调用operator++(a)，重载a++会调用operator++(a, int)，其中第二个int参数是不会被用到的，只是用来区分前缀和后缀调用。--的重载也是一样。
=和[]只能作为成员函数被重载。()只能作为成员函数被重载，可以带任意多个参数。（若可以不作为成员函数被重载，则对于内置类型的运算就可以被重载，这是没有意义的）
->和->*也只能作为成员函数被重载，但对返回值有一定的限制。
.和.*不能被重载

返回值优化：
Integer tmp(left.i + right.i);
return tmp;
这样编译器需要三步才能完成（构造，拷贝，析构），而
return Integer(left.i + right.i);
则只需要一步

重载时作为成员或非成员函数的选择：
所有的一元运算符 推荐作为成员
= () [] -> ->* 必须作为成员
+= -= /= *= ^=
&= |= %= >>= <<= 推荐作为成员
所有其他的二元运算符 推荐作为非成员

当对象还没有被创建时，=调用的是构造函数或拷贝构造函数，为的是初始化对象；当对象已被创建时，=调用的才是operator=。因此
Fee fee(1);
Fee fum(fi);
这样的写法要比
Fee fee = 1;
Fee fum = fi;
这样的写法清晰。

在重载赋值运算符时，首先检查是否是对自身赋值是个好习惯。
当对象中有指针时，拷贝构造函数通常需要连同复制出指针所指向的内容。而当此内容很大时，通常采用引用计数的方法，只在需要修改数据且引用数大于1时才复制内容。这种技术被称为copy-on-write。
当构造函数接受一个其他类型的对象作为参数时，编译器可以用它来进行自动类型转换。如果不需要这样的自动转换，在构造函数前加上explicit。
也可以重载operator 类型名来定义自动类型转换。由于这种类型转换是由源对象完成的（不像构造函数的类型转换是由目标对象完成的），因此可以完成自定义对象到内置类型的转换。
运算符重载为非成员函数时，运算符两边都可以进行自动类型转换。
提供自动类型转换时注意两种类型之间只需提供一条转换路径，否则会出现二义性错误。

new和delete
new为对象分配空间并调用构造函数。delete调用对象的析构函数后释放对象的空间。
delete对于零指针无效，因此人们通常在delete之后将指针设为零，以防止多次delete带来的问题。

delete void*可能会带来问题。由于编译器不知道具体的类型，将导致对象的空间被释放而没有调用析构函数。这可能会引起内存泄漏。
a* p = new a[100];为数组中的每个对象分配空间并调用构造函数进行初始化。
delete []p;则完成相反的事。delete后的[]表示指针只是数组的首地址，编译器会自动获取数组的大小完成释放工作。由于表示首地址，最好定义为常量：
a* const p = new a[100];
当new找不到空间分配时，会调用new-handler。其默认行为是抛出异常。可以通过使用new.h中的set_new_handler()来定义作为new-handler的函数。

operator new和operator delete都可以被重载，用来完成一些自定义的内存管理功能：
void* operator new(size_t sz)
void operator delete(void* m)
当new和delete作为类的成员函数被重载时，为该类的对象分配空间时就会调用这些重载的操作符。
用于为数组分配空间的operator new[]和operator delete[]也能被重载。实际占用的空间比分配的要多4个字节，被系统用于存储数组的大小。

重载的new可以接受任意多个参数，比如定义第二个参数，用于指明在何处分配空间：
void* operator new(size_t, void* loc)
使用时：
X* xp = new(a) X;
其中的a就是第二个参数。采用这种形式的new可能需要显式调用析构函数：
xp->X::~X();
（因为对象可能不是构建在堆上，使用delete只能释放堆上的空间）

继承
合成和继承都需要在构造初始化列表中对子对象进行初始化。
一旦在子类中定义了一个与超类中同名的函数，超类中所有同名的函数，不管函数特征是否相同，都会变得不可见。
构造函数，析构函数，operator=不会在继承时进入子类。
继承默认是private的，即超类中的public成员在子类中也会变成private的。若只想暴露某些成员，可以在子类中的public部分使用using。这种情况下同名的重载函数会被全部暴露。

多态
C++中使用virtual关键字来声明函数为延迟绑定的（或动态绑定）。函数的定义中不需要virtual。使用了virtual之后， upcast时调用的就是子类的重载函数，否则只能调用基类的。（C++使用virtual来使得动态绑定成为可选的，这是出于效率的考虑。其他语言如 Java和Python等默认就是使用动态绑定的）
拥有纯虚函数的类是抽象类（提供了一个接口）。纯虚函数在virtual定义后加上=0。
继承抽象类的子类必须实现基类中所有的纯虚函数，否则就还是抽象类。

纯虚函数不能内联定义。在定义后则可以被子类使用。
传值的upcast会把对象切割，即子类会被切到只剩下基类的部分。抽象的基类可以避免这种情况，因为抽象类不允许实例化。
构造函数不能是virtual的，而析构函数可以。

模板
继承可以重用对象，而模板可以重用代码。
定义template时可以使用内置类型。它们的值可以是常量。如：
template<class T, int size = 100>
template不仅可以用来创建类模板，还能用来创建函数模板。

杂项
之间没有标点符号的字符数组会被自动连接起来
C++标准中包含的不是STL，而是C++标准库，它是由STL演变来的。
C++中的类型转换可以函数的形式，如float(n)等价于(float)n。
C++中的显示类型转换（提供一种容易辨别的形式）：
static_cast：类型收窄时可以避免编译器的警告信息；同样可用于类型放宽、void*的强制转换和自动隐式转换。
const_cast：用于转换const和volatile，比如将一个普通指针指向一个const
reinterpret_cast：把一种类型当成另一种类型
dynamic_cast：用于downcast
sizeof是运算符而不是函数，用于类型时要加括号，如sizeof(double)，用于变量时不用，如sizeof x。