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

 

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

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

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

2、头文件的做用
增强安全检测
经过头文件可能方便地调用库功能，而没必要关心其实现方式

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

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

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

6、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

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

8、一个内存拷贝函数的实现体
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;
}

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

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

11、内容复制与比较
//数组……
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)
{}

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

十3、关于指针
一、 指针建立时必须被初始化
二、 指针在free 或delete后必须置为NULL
三、 指针的长度都为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;

十4、关于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函数来定义内存分配异常的处理

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

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

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

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

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

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

十7、构造函数与析构函数
派生类的构造函数应在初始化表里调用基类的构造函数；
派生类和基类的析构函数应加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

十8、#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。