C++ 中的变量类型与Java很相似。像Java一样，C++ 有int 和 double 类型。但是这些数字类型的取值范围是依赖于机器的。比如在16位系统上，例如运行DOS 或Windows 3.x的PC机上，int 是双字节(2-byte)的，取值范围比Java的4-byte的int 要小很多。在这些机器上，如果 int 不够用的话，你需要使用长整型long。

C++ 有 short 和 unsigned 类型来更有效的存储数字。（我认为所谓有效是指更高的空间利用率。） 最好是尽量避免使用这些类型除非是空间利用的有效性对你的系统真的非常重要。

在C++中布尔型用 bool 表示，而不像在Java中用boolean。

C++ 中字符串类型用 string 表示。它与Java中的 String 类型非常相似，但是，还是要逐一以下几点不同之处：

1. C++ 字符串存储ASCII 码字符，而不是标准码Unicode 字符

2. C++ 字符串是可以被修改的，而Java字符串的内容是不可修改的(immutable)。

3. 取子字符串的操作在 C++ 中叫做 substr，这个命令s.substr(i, n) 从字符串s中取得从位置 i 开始长度为n的子字符串。

4. 在C++中，你只能够将字符串与其它字符串对象相串联(concatenate)，而不能够与任意的对象相串联。

5. C++中可以直接使用关系操作符 ==、 !=、 <、 <=、 >、 >= 来进行字符串比较，其中后面四个操作符是按字母顺序进行比较的。 这比Java中使用函数equals和compareTo来比较要方便很多。

2. 变量和常量

在C++中，本地变量的定义看起来与Java中相同，例如：

int n = 5;

实际上这正是C++和Java的一个重要不同之处。C++编译器不对本地变量进行初始化检验，所以在C++中很容易忘记初始化一个变量，这种情况下，变量的值该变量所占内存区域中刚好当前存在随机值。这显然是很容易产生程序出错的地方。

与Java一样， C++中类可以有数据域和静态变量。不同的是，C++中变量可以在函数甚至是类的外面定义，这些所谓的全局变量可以在程序的任何函数中被访问，因而不易被很好的管理。所C++中应该尽量避免使用全局变量。

在C++中，常量可以在任何地方被定义（记得在Java中，常量必须是类的静态数据static data)。 C++ 使用关键字 const 来定义常量，而Java中是 final。例如：

const int DAYS_PER_YEAR = 365;

3. 类

C++ 中对类的定义与Java有些不同，这里是一个例子：一个C++ 版本的 Point 类:

class Point /* C++ */

{

public:

Point();

Point(double xval, double yval);

void move(double dx, double dy);

double getX() const;

double getY() const;

private:

double x;

double y;

};

这里几点重要的不同是：

1. C++的类定义中分为公共和私有部分，分别以关键字 public 和 private开始。而在Java中，每一个元素都必须标明 public 或 private。

2. C++中类的定义只包含函数的声明，真正的实现另外单独列出。

3. 访问函数(accessor methods)标有关键字 const ，表明这个函数不会改变本对象的元素值。

4. 类定义的结尾处有分号

类中函数的实现跟在类的定义之后。因为函数是在类外面定义的，所以每一个函数的名字前面要加类名称作为前缀，并使用操作符双冒号::来分割类的名称和函数的名称。不改变隐含参数值（即当前对象的值）的访问函数用 const标明。如下所示是上面类定义中的函数的实现：

Point::Point() { x = 0; y = 0; }

void Point::move(double dx, double dy)

{

x = x + dx;

y = y + dy;

}

double Point::getX() const

{

return x;

}

4. 对象

Java 与 C++ 最主要的不同在于对象变量的使用。在 C++中，对象变量存储的是真正的对象的值，而不是对象引用(reference)。注意在C++中构造一个对象的时候是不使用关键字new的，只需要在变量的名字后面直接赋予构造函数的参数就可以了，例如：

Point p(1, 2); /* 构造对象 p */

如果不跟参数赋值，则使用默认构造函数，例如：

Time now; /* 默认使用构造函数 Time::Time() */

这一点与Java很不同。在Java中，这个命令仅仅生成一个没有初始化的reference，而在C++中，它生成一个实际的对象。

当一个对象被赋给另一个对象变量的时候，实际的值将被拷贝。而在Java中，拷贝一个对象变量只不过是建立了另外一个指向对象的reference。拷贝一个C++的对象就像在Java中调用clone这个函数一样，而修改拷贝的值不会改变原对象的值。例如：

Point q = p; /* 拷贝p到q */

q.move(1, 1); /* 移动q而p不动，即q的值变了，而p的不变*/

多数情况下，C++中这种对象直接对值操作的特性使用起来很方便，但是也有些时候不尽如人意：

1. 当需要一个函数中修改一个对象的值，必须记住要使用按引用调用call by reference (参见下面函数部分)

2. 两个对象变量不能指向同一个对象实体。如果你要在C++中实现这种效果，必须使用指针pointer（参见下面指针部分）

3. 一个对象变量只能存储一种特定的类型的值，如果你想要使用一个变量来存储不同子类的对象的值（多态ploymorphism)，则需要使用指针。

4. 如果你想在C++中使用一个变量来或者指向null或者指向一个实际的对象，则需要使用指针

5. 函数

在Java中，每一个函数必须或者是对象函数(instance method)，或者是静态函数(static function)或称类函数。C++同样支持对象函数和静态函数（类函数），但同时C++也允许定义不属于任何类的函数，这些函数叫做全局函数（global functions）。

特别的是，每一个C++ 程序都从一个叫做 main的全局函数开始执行：

int main()

{ . . .

}

还有另外一个格式的main函数可以用来捕捉命令行参数，类似于Java的main函数，但是它要求关于C格式的数组和字符串的知识，这里就不介绍了。

按照习惯，通常如果程序执行成功， main 函数返回0，否则返回非零整数。

同Java一样，函数参数是通过值传递的(passed by value)。在Java中，函数无论如何都是可以修改对象的值的。然而在C++中，因为对象直接存储的是实际的值，而不是指向值的reference，也就是说传入函数的是一个实际值的拷贝，因此也就无法修改原来对象的值。

所以，C++ 有两种参数传递机制，同Java一样的按值调用(call by value) ，以及按地址调用(call by reference)。当一个参数是按reference传递时，函数可以修改其原始值。Call by reference 的参数前面有一个地址号 & 跟在参数类型的后面，例如：

void raiseSalary(Employee& e, double by)

{ . . .

}

下面是一个典型的利用call by reference的函数，在Java中是无法实现这样的功能的。

void swap(int& a, int& b)

{ int temp = a;

a = b;

b = temp;

}

如果使用 swap(x, y)来调用这个函数，则reference参数 a 和 b 指向原实际参数x 和 y的位置，而不是它们的值的拷贝，因此这个函数可以实现实际交换这两个参数的值。

在 C++中，每当需要实现修改原参数的值时你就可以使用按地址调用 call by reference

6. 向量Vector

C++ 的向量结构结合了Java中数组和向量两者的优点。一个C++ 的向量可以方便的被访问，其容量又可以动态的增长。如果 T 是任意类型，则 vector<T> 是一个元素为 T 类型的动态数组。下面的语句

vector<int> a;

产生一个初始为空的向量。而语句

vector<int> a(100);

生成一个初始有100个元素的向量。你可以使用push_back 函数来添加元素：

a.push_back(n);

调用 a.pop_back() 从a中取出最后一个元素（操作后这个元素被从a中删掉)， 使用函数size 可以得到当前a中的元素个数。

你还可以通过我们熟悉的 [] 操作符来访问向量中元素，例如：

for (i = 0; i < a.size(); i++) {

sum = sum + a[i];

}

同Java中一样，数组索引必须为 0 和 a.size() - 1之间的值。但是与Java不同的是，C++中没有runtime的索引号合法性检验。试图访问非法的索引位置可能造成非常严重的出错。

就像所有其它 C++ 对象一样，向量也是值。如果你将一个向量赋值给另外一个向量变量，所有的元素都会被拷贝过去。

vector<int> b = a; /* 所有的元素都被拷贝了 */

对比Java中的情况，在Java中，一个数组变量是一个指向数组的reference。拷贝这个变量仅仅产生另外一个指向同一数组的reference，而不会拷贝每一个元素的值。

正因如此，如果一个C++函数要实现修改向量的值，必须使用reference参数：

void sort(vector<int>& a)

{ . . .

}

7. 输入和输出

在C++中，标准的输入输出流用对象 cin 和 cout 表示。我们使用 << 操作符写输出，例如：

cout << “Hello, World!”;

也可以连着输出多项内容，例如：

cout << “The answer is ” << x << “\n”;

我们使用 >> 操作符来读入一个数字或单词，例如：

double x;

cout << “Please enter x: “;

cin >> x;

string fname;

cout << “Please enter your first name: “;

cin >> fname;

函数getline 可以读入整行的输入，例如：

string inputLine;

getline(cin, inputLine);

如果到达输入的结尾，或者一个数字无法被正确的读入，这个流对象会被设置为 failed 状态，我们可以使用函数 fail 来检验这个状态，例如：

int n;

cin >> n;

if (cin.fail()) cout << “Bad input”;

一旦一个流的状态被设为failed，我们是很难重置它的状态的，所以如果你的程序需要处理错误输入的情况，应该使用函数 getline 然后人工处理得到的输入数据。

8. 指针pointer

我们已经知道在C++中，对象变量直接存储的是对象的值。这是与Java不同的，在Java中对象变量存储的是一个地址，该地址指向对象值实际存储的地方。有时在C++中也需要实现这样的布置，这就用到了指针pointer。在 C++中，一个指向对象的变量叫做指针。如果T是一种数据类型，则 T* 是指向这种数据类型的指针。

就像 Java中一样，一个指针变量可以被初始化为空值 NULL，另外一个指针变量的值，或者一个调用new生成的新对象：

Employee* p = NULL;

Employee* q = new Employee(”Hacker, Harry”, 35000);

Employee* r = q;

实际上在C++中还有第四种可能，那就是指针可以被初始化为另外一个对象的地址，这需要使用地址操作符 & ：

Employee boss(”Morris, Melinda”, 83000);

Employee* s = &boss;

这实际上并不是什么好主意。保险的做法还是应该直接让指针指向使用 new生成的新对象。

到目前为止，C++ 指针看起来非常像 Java 的对象变量。然而，这里有一个很重要的语法的不同。我们必须使用星号操作符 * 来访问指针指向的对象。如果 p 是一个指向Employee对象的指针，则 *p 才代表了这个对象：

Employee* p = . . .;

Employee boss = *p;

当我们需要执行对象的函数或访问对象的一个数据域时，也需要使用 *p ：

(*p).setSalary(91000);

*p外面的括号是必需的，因为 . 操作符比 * 操作符有更高的优先级。C的设计者觉得这种写法很难看，所以他们提供了另外一种替代的写法，使用 -> 操作符来实现 * 和 . 操作符的组合功能。表达式

p->setSalary(91000);

可以调用对象*p的函数 setSalary 。你可以简单的记住 . 操作符是在对象上使用的，-> 操作符是在指针上使用的。

如果你不初始化一个指针，或者如果一个指针为空值 NULL 或指向的对象不再存在，则在它上面使用 * 或 -> 操作符就会出错。 不幸的是 C++ runtime 系统并不检查这个出错。如果你范了这个错误，你的程序可能会行为古怪或死机。

而在Java中，这些错误是不会发生的。所有的reference都必须初始化，所有的对象只要仍有reference指向它就不会被从内存中清除，因此你也不会有一个指向已被删除的对象的reference。Java的runtime 系统会检查reference是否为空，并在遇到空指针时抛出一个null pointer的例外(exception)。

C++ 和 Java还有一个显著的不同，就是 Java 有垃圾回收功能，能够自动回收被废弃的对象。而在C++中，需要程序员自己管理内存分配回收。

C++中当对象变量超出范围时可以自动被回收。但是使用new生成的对象必须用delete操作符手动删除，例如：

Employee* p = new Employee(”Hacker, Harry”, 38000);

. . .

delete p; /* 不在需要这个对象 */

如果你忘记删除一个对象，那么你的程序有可能最终用光所有内存。这就是我们常说的内存泄漏 (memory leak)。更重要的是，如果你如果删除了一个对象，然后又继续使用它，你可能覆盖不属于你的数据。如果你刚巧覆盖了用于处理内存回收的数据域，那么内存分配机制就可能运转失常而造成更严重的错误，而且很难诊断和修复。因此，在C++中最好尽量少用指针

9. 继承

C++和Java中继承的基本语法是很相似的。在C++中，使用 : public 代替Java中的extends 来表示继承关系 。 (C++ 也支持私有继承的概念，但是不太有用。)

默认情况下，C++中的函数不是动态绑定的。如果你需要某个函数实现动态绑定，需要使用virtual声明它为虚函数，例如：

class Manager : public Employee

{

public:

Manager(string name, double salary, string dept);

virtual void print() const;

private:

string department;

};

同Java一样，构造函数中调用父类的构造函数有特殊的语法。 Java使用关键字 super。C++中必须在子类的构造函数体外调用父类的构造函数。下面是一个例子：

Manager::Manager(string name, double salary, string dept)

: Employee(name, salary) /* 调用父类的构造函数 */

{ department = dept;

}

Java 中在子类函数中调用父类的函数时也使用关键字 super 。而在C++中是使用父类的名称加上操作符 ::表示，例如：

void Manager::print() const

{ Employee::print(); /* 调用父类的函数 */

cout << department << “\n”;

}

一个 C++ 对象变量只能存储特定类型的对象值。要想在C++中实现多态(polymorphism)，必须使用指针。一个 T* 指针可以指向类型为 T 或 T 的任意子类的对象，例如：

Employee* e = new Manager(”Morris, Melinda”, 83000, “Finance”);

你可以将父类和不同子类的对象混合收集到一个元素均为指针的向量中，然后调用动态绑定的函数，如下所示：

vector<Employee*> staff;

. . .

for (i = 0; i < staff.size(); i++)

staff[i]->print();

使用这个函数， 表达式 ++x 才有正确的显示以及正确的操作。
Passing by reference不仅仅是写operator++较好的方法，而是唯一的方法。


 C++在这里并没有给我们选择的余地。
 像下面的声明:
day *operator++(day *d);
是不能 通过编译的。
每个重载的操作符函数必须或者是一个类的成员， 或者使用类型T、 T & 或 T const & 为参数类型，
这里T是一个类(class)或列举(enumeration)类型。

也就是说，每一个重载操作符必须以类或列举类型为参数类型。

指针，即使是指向一个类或列举类型对象的指针，也不可以用。

C++ 不允许在重载操作符时重新定义内置操作符的含义，包括指针类型。
因此，我们不可以定义：
int operator++(int i); // 错误
因为它试图对int重新定义操作符 ++ 的含义。 我们也不可以定义：
int *operator++(int *i); // 错误
因为它试图对 int * 重新定义操作符 ++ 的含义

References vs. const pointers

C++ 中不允许定义”const reference”，
 因为一个reference天生就是const。也就是说，一旦将一个reference绑定到一个对象，就无法再将它重新绑定到另一个不同的对象。
在声 明一个reference之后没有写法可以将它重新绑定到另外一个对象。
例如：
int &ri = i;
将 ri 绑定到 i 。然后下面的赋值:
ri = j;
并不是把 ri 绑定到 j ，而是将 j 中的值赋给 ri 指向的对象，也就是赋给 i 。

简而言之，
一个pointer在它的有生之年可以指向许多不同的对象，
而一个reference只能够指向一个对象。
有些人认为这才是 reference和 pointer最大的不同。
我并不赞成。也许这是reference与pointer的一点不同， 但并不是reference和const pointer的不同。
在强调一遍，一旦一个reference与一个对象绑定，就不能再将它改指向另外的东西。
既然不能再绑定reference之后再 改变， 一个reference就必须在一出生就被绑定。
否则这个reference就永远不能被绑定到任何东西，也就毫无用处了。

上一段的讨论也同样完全适用于常量指针（const pointer）。
（注意，我这里说的是常量指针（const pointer）， 而不是指向常量的指针 “pointers to const”。)
 例如，
一个reference声明必须同时带有一个初始化赋值，如下所示：

void f()
{
int &r = i;
…
}

省略这个初始化赋值将产生一个编译错误：

void f()
{
int &r; //错误
…
}

一个常量指针的声明也同样必须带有一个初始化赋值，如下所示：

void f()
{
int *const p = &i;
…
}

省略这个初始化赋值同样会出错：

void f(){
int *const p; // 错误
…
}

在我看来
不能够对reference二次绑定作为reference与pointer的不同。
并不比常量指针和非常量指针的不同更为显著。

Null references

除了显示的不同，常量指针与reference还有一点非常不同，那就是，一个有效的reference必须指向一个对象；而一个指针不需要。一个指针，即使是一个常量指针， 都可以有空值。 一个空指针不指向任何东西。

这点不同就暗示当你想要确信一个参数必须指向一个对象的时候，应该使用reference作为参数类型。 例如，交换函数(swap function)，它接受两个int参数，并将两个参数的数值对调，如下所示：

int i, j;
swap(i, j);

将原本在 i 中的值放到 j 中， 并将原本在 j 中的值放到 i 中。我们可以这样写这个函数：

void swap(int *v1, int *v2)
{
int temp = *v1;
*v1 = *v2;
*v2 = temp;
}

这种定义下，函数要像这样被调用: swap(&i, &j);

这个接口暗示其中一个或两个参数都有可能为空(null)。而这个暗示是误导的。例如，调用
swap(&i, NULL);
的后果很可能是不愉快的。

而像下面这样定义reference为参数：

void swap(int &v1, int &v2)
{
int temp = v1;
v1 = v2;
v2 = temp;
}

清晰的表明了调用swap应该提供两个对象，它们的值将被交换。 并且这样定义的另一个好处是，在调用这个函数的时候，不需要使用那些&符号，看起来更顺眼：
swap(i, j);

Null references

除了显示的不同，
常量指针与reference还有一点非常不同，
那就是，一个有效的reference必须指向一个对象；

而一个指针不需要。
一个指针，即使是一个常量指针， 都可以有空值。 一个空指针不指向任何东西。

这点不同就暗示当你想要确信一个参数必须指向一个对象的时候，应该使用reference作为参数类型。
 例如，
交换函数(swap function)，它接受两个int参数，并将两个参数的数值对调，如下所示：

int i, j;
swap(i, j);

将原本在 i 中的值放到 j 中， 并将原本在 j 中的值放到 i 中。我们可以这样写这个函数：

void swap(int *v1, int *v2)
{
int temp = *v1;
*v1 = *v2;
*v2 = temp;
}

这种定义下，函数要像这样被调用: swap(&i, &j);

这个接口暗示其中一个或两个参数都有可能为空(null)。而这个暗示是误导的。例如，调用
swap(&i, NULL);
的后果很可能是不愉快的。

而像下面这样定义reference为参数：

void swap(int &v1, int &v2)
{
int temp = v1;
v1 = v2;
v2 = temp;
}

清晰的表明了调用swap应该提供两个对象，它们的值将被交换。 并且这样定义的另一个好处是，在调用这个函数的时候，不需要使用那些&符号，看起来更顺眼：
swap(i, j);

更安全?

有些人认为既然reference不能够为空，那么它应该比指针更安全。
 我认为reference可能要安全一点，但不会安全很多。
虽然一个有效的reference不能为空，但是无效的可以呀。
实际上，在很多情况下程序有可 能产生无效的reference，而不只是空的reference。

 例如，
你可以定义一个reference，使它绑定到一个指针指向的对象，如下所示：

int *p;
…
int &r = *p;

如果指针*p在reference定义时刚好为空，则这个reference为空。
 从技术上来说，这个错误并不在于将reference绑定到一个空值，而是在于对一个空指针去参考。
 对一个空指针去参考产生了一个不确定的操作，也就意味着很多事都可能发生，而且大部分都不是什么好事。很有可能当程序将reference r 绑定到*p (p所指向的对象)的时候，p实际上没有被去参考，甚至程序只是将p的值拷贝给实现r的指针。
而程序将会继续执行下去直到错误在后面的运行中更为明显的表 现出来，产生不可预知的危害。

下面的函数
展示了
另外一种产生无效reference的方法：

int &f()
{
int i;
…
return i;
}

这个函数返回一个指向本地变量 i 的reference。
然而当函数返回时，本地变量 i 的存储空间也就消失了。因此这个函数实际返回了一个指向被回收了的空间的reference。这个操作与返回一个指向本地变量的指针的后果相同。
有些编译 器可以在编译时发现这个错误，但也很有可能不会发现。

我喜欢reference，也有很好的理由使用它们代替pointer。

但如果你期望使用reference来使你的程序健壮性显著增强，那么你多半会失望的

参考资料：

1. Saks, Dan. “Introduction to References,” Embedded Systems Programming, January 2001, p. 81.
2. Saks, Dan. “References and const“, Embedded Systems Programming February 2001, p. 73.

在Visual C++中定义一般的函数为朋友函数通常是没有问题的。
然而对某些重载操作符的函数，
即使我们将它们定义为类的朋友函数，VC的编译器仍然会显示出错信息，
认为这些朋友函数无权访问类的私有成员。
我认为这应该是VC6.0的bug。

以下代码就是个例子:

// 头文件 “Sample.h”
            #include<iostream>
            using namespace std;
            class Sample {
            public:
            Sample();
            friend ostream &operator<<(ostream &out, const Sample s);
            friend istream &operator>>(istream &in, Sample & s);
            private:
            int x;
            };

// 实现文件 “Sample.cpp”
            #include “Sample.h”
            Sample::Sample() {
            x=0;
            }
            istream &operator>>(istream &in, Sample & s) {
            cout<<”Please enter a value”<<endl;
            in >> s.x ;
            return in;
            }
            ostream &operator<<(ostream &out, const Sample s) {
            cout << s.x << endl;
            return out;
            }

以上代码在gnuc++中编译运行毫无问题。但是在VC++6.0中编译的时候就会出现以下的编译错误：

在VC++ 6.0中解决这个问题有以下几种方法：

• 在头文件中实现作为朋友函数的操作符函数的重载，也就是说在实现文件”Sample.cpp”中将函数重载的实现去掉，而将头文件修改如下：
  

  // 修改后的头文件 1 “Sample.h” #include<iostream> using namespace std; class Sample { public: Sample(); friend ostream &operator<<(ostream &out, const Sample s); friend ostream &operator<<(ostream &out, const Sample s) { cout << s.x << endl; return out; } friend istream &operator>>(istream &in, Sample & s); friend istream &operator>>(istream &in, Sample & s) { cout<<”Please enter a value”<<endl; in >> s.x ; return in; } private: int x; };

• 在头文件中类定义之前将类和朋友操作符函数的原型特别声明一下，也就是将头文件修改如下(实现文件”Sample.cpp”不用作任何修改)：
  

  // 修改后的头文件 2 “Sample.h” #include<iostream> using namespace std; // 以下3行代码为新加入 class Sample; ostream &operator<<(ostream &out, const Sample s); istream &operator>>(istream &in, Sample & s); class Sample { public: Sample(); friend ostream &operator<<(ostream &out, const Sample s); friend istream &operator>>(istream &in, Sample & s); private: int x; };

• 第三种方法是对I/O名空间的使用实行明确声明，也就是说在头文件”Sample.h”中直接写：
  #include<iostream>
  using std::ostream;
  using std::istream
  ….
  取代 “using namespace std;”
  注意：在这个例子里我们在实现文件 “Sample.cpp”中包含 “using namespace std;”这句话，否则在实现中就不能使用 “cout” , “cin”, “<< “, “>>” 和 endl 这些关键字和符号。修改后的完整代码如下：

   

  // Sample.h #include<iostream> using std::istream; using std::ostream; class Sample { public: Sample(); friend ostream &operator<<(ostream &out, const Sample s); /*friend ostream &operator<<(ostream &out, const Sample s) { cout << s.x << endl; return out; }*/ friend istream &operator>>(istream &in, Sample & s); /*friend istream &operator>>(istream &in, Sample & s) { cout<<”Please enter a value”<<endl; in >> s.x ; return in; }*/ private: int x; };

  // “Sample.cpp” #include “Sample.h” using namespace std; Sample::Sample() { x=5; } istream &operator>>(istream &in, Sample & s) { cout<<”Please enter a value”<<endl; in >> s.x ; return in; } ostream &operator<<(ostream &out, const Sample s) { cout << s.x << endl; return out; }

reinterpret_cast 可以将一个指针转换为任意其它类型的指针。
它也可以用来将一个指针转换为一个整型，或反之亦然。

这个操作符可以在互不相关的类之间进行指针转换，
操作的结果是简单的将一个指针的二进制数据(binary copy)复制到另一个指针。
对指针指向的内容不做任何检查或转换。

例如：

reinterpret_cast 对所有指针的处理与传统的类型转换符所作的一模一样。

_________________________________________________________________

static_cast

static_cast 可以执行所有能够隐含执行的类型转换，以及它们的反向操作（即使这种方向操作是不允许隐含执行的）。

用于类的指针，也就是说，它允许将一个引申类的指针转换为其基类类型（这是可以被隐含执行的有效转换），同时也允许进行相反的转换：将一个基类转换为一个引申类类型。

在后面一种情况中，不会检查被转换的基类是否真正完全是目标类型的。例如下面的代码是合法的：

static_cast除了能够对类指针进行操作，还可以被用来进行类中明确定义的转换，以及对基本类型的标准转换：

double d=3.14159265;
int i = static_cast<int>(d);

dynamic_cast

dynamic_cast 完全被用来进行指针的操作。它可以用来进行任何可以隐含进行的转换操作以及它们被用于多态类情况下的方向操作。

然而与static_cast不同的是，
 dynamic_cast 会检查后一种情况的操作是否合法，
也就是说它会检查类型转换操作是否会返回一个被要求类型的有效的完整的对象。

这种检查是在程序运行过程中进行的。如果被转换的指针所指向的对象不是一个被要求类型的有效完整的对象，返回值将会是一个空指针NULL 。

   class Base { virtual dummy(){}; };
   class Derived : public Base { };
   

   Base* b1 = new Derived;
   Base* b2 = new Base;
   Derived* d1 = dynamic_cast(b1);   // succeeds
Derived* d2 = dynamic_cast(b2);   // fails: returns NULL

如果类型转换被用在引用(reference)类型上，而这个转换不可能进行的话，一个bad_cast 类型的例外(exception)将会被抛出：

  class Base { virtual dummy(){}; };
  class Derived : public Base { };
  
  Base* b1 = new Derived;
  Base* b2 = new Base;
  Derived d1 = dynamic_cast(b1);   // succeeds
Derived d2 = dynamic_cast(b2);   // fails: exception thrown

const_cast

这种类型转换对常量const 进行设置或取消操作：

其他3种cast 操作符都不可以修改一个对象的常量属性(constness)。

typeid

ANSI-C++ 还定义了一个新的操作符叫做 typeid ，
它检查一个表达式的类型：

typeid (expression)

这个操作符返回一个类型为type_info的常量对象指针，这种类型定义在标准头函数中。这种返回值可以用操作符 == 和 != 来互相进行比较，
也可以用来通过name()函数获得一个描述数据类型或类名称的字符串，

例如：

// typeid, typeinfo #include <iostream.h> #include <typeinfo> class CDummy { }; int main () { CDummy* a,b; if (typeid(a) != typeid(b)) { cout << "a and b are of different types:\n"; cout << "a is: " << typeid(a).name() << '\n'; cout << "b is: " << typeid(b).name() << '\n'; } return 0; }

a and b are of different types: a is: class CDummy * b is: class CDummy

我们能够找到的关于名空间的最好的例子就是标准C++ 函数库本身。

如ANSI C++ 标准定义，
标准C++库中的所有类、对象和函数都是定义在名空间std下面的。

你可能已经注意到，我们在这个教程中全部忽略了这一点。作者决定这么做是因为这条规则几乎和ANSI 标准本身一样年轻 (1997) ，许多老一点的编译器并不兼容这条规则。

几乎所有的编译器，即使是那些与ANSI 标准兼容的编译器，都允许使用传统的头文件 (如iostream.h, stdlib.h, 等等)，就像我们在这个教程中所使用的一样。


然而，ANSI标准完全重新设计了这些函数库，
利用了模板功能，
而且遵循了这条规则将所有的函数和变量定义在了名空间std下。

该标准为这些头文件定义了新的名字，对针对C++的文件基本上是使用同样的名字，但没有.h的扩展名，

例如, iostream.h 变成了iostream。

如果我们使用ANSI-C++ 兼容的包含文件，我们必须记住所有的函数、类和对象是定义在名空间 std 下面的，例如：

// ANSI-C++ compliant hello world #include <iostream> int main () { std::cout << "Hello world in ANSI-C++\n"; return 0; }

Hello world in ANSI-C++

更常用的方法是使用using namespace ，这样我们就不必在所有标准空间中定义的函数或对象前面总是使用范围操作符::了 ：

// ANSI-C++ compliant hello world (II) #include <iostream> using namespace std; int main () { cout << "Hello world in ANSI-C++\n"; return 0; }

Hello world in ANSI-C++

对于STL 用户，强烈建议使用ANSI-compliant 方式来包含标准函数库。

template <class T> // 最常用的：一个class 参数。

template <class T, class U> // 两个class 参数。

template <class T, int N> // 一个class 和一个整数。

template <class T = char> // 有一个默认值。

template <int Tfunc (int)> // 参数为一个函数。

从编译器的角度来看，模板不同于一般的函数或类。
它们在需要时才被编译(compiled on demand)，
也就是说一个模板的代码直到需要生成一个对象的时候(instantiation)才被编译。
当需要instantiation的时候，编译器根据模板为特定的调用数据类型生成一个特殊的函数。


当工程变得越来越大的时候，程序代码通常会被分割为多个源程序文件。
在这种情况下，通常接口(interface)和实现(implementation)是分开的。


用一个函数库做例子
     接口通常包括所有能被调用的函数的原型定义。
                                    它们通常被定义在以.h 为扩展名的头文件 (header file) 中；
      而实现 (函数的定义) 
                                    则在独立的C++代码文件中。

模板这种类似宏(macro-like) 的功能，对多文件工程有一定的限制：
函数或类模板的实现 (定义) 必须与原型声明在同一个文件中。
也就是说我们不能再 将接口(interface)存储在单独的头文件中，
而必须将接口和实现放在使用模板的同一个文件中。

回到函数库的例子，如果我们想要建立一个函数模板的库，我们不能再使用头文件(.h) ，取而代之，我们应该生成一个模板文件(template file)，将函数模板的接口和实现 都放在这个文件中 (这种文件没有惯用扩展名，除了不要使用.h扩展名或不要不加任何扩展名)。


在一个工程中多次包含同时具有声明和实现的模板文件并不会产生链接错误 (linkage errors)，因为它们只有在需要时才被编译，而兼容模板的编译器应该已经考虑到这种情况，不会生成重复的代码。

在提醒一次，它其实是一个全域变量。唯一的不同是它的名字跟在class的后面。

就像我们会在class中包含static数据一样，我们也可以使它包含static 函数。
它们表示相同的含义：static函数是全域函数(global functions)，但是像一个指定class的对象成员一样被调用。
它们只能够引用static 数据，永远不能引用class的非静态(nonstatic)成员。
它们也不能够使用关键字this，因为this实际引用了一个对象指针，
但这些 static函数却不是任何object的成员，而是class的直接成员。

可以认为函数类型的地址类型的数字编译器会隐式转换成指针类型的数字

重载函数表示函数名字一样，但参数类型及个数不同的多个函数

 声明是告诉编译器一些信息，以协助编译器进行语法分析，避免编译器报错。而定义是告诉编译器生成一些代码，并且这些代码将由连接器使用。

extern long a, *pA, &ra;
    上面就声明（不是定义）了三个变量a、pA和ra。
因为extern表示外部的意思，因此上面就被认为是告诉编译器有三个外部的变量，为a、pA和ra，故被认为是声明语句，所以上面将不分配任何内存。
同样，对于函数，它也是一样的：
    extern void ABC( long );  或  extern long AB( short b );

地址类型的数字是在编译时期给编译器用的
指针类型的数字是在运行时期给代码用的

根据用户输入的不同而可能申请不同大小的内存时，则称此内存是动态分配的，后面说的从堆上分配就属于动态分配。

同样，静态分配的内存利用率不高或运用不够灵活，但代码容易编写且运行速度较快；动态分配的内存利用率高，不过编写代码时要复杂些，需自己处理内存的管理（分配和释放）且由于这种管理的介入而运行速度较慢并代码长度增加。
静态和动态的意义不仅仅如此，其有很多的深化，如硬编码和软编码、紧耦合和松耦合，都是静态和动态的深化。

  多字节字符串（MultiByte），用这种表示方式记录的文本文件称为是MBCS格式的

 宽字节字符串（WideChar），用这种表示方式记录的文本文件称为是Unicode格式的
         (一个short类型的数字来表示，即每个字符的长度固定为2字节)

http://www.dinkumware.com/exam/default.aspx
http://www.comeaucomputing.com/tryitout/
许多在线判题系统也可以用来进行在线编译：

http://acm.zju.edu.cn/
http://acm.pku.edu.cn/JudgeOnline/
http://acm.uva.es/
你可能会好奇这些网站使用的编译器的版本和编译参数到底是什么。有些网站会提供这些信息，而有些则不会。那么你就只能靠自己去发现这些“秘密”了。

工欲善其事，必先利其器。让我们先看看一些从编译器获取信息的小技巧。

1. 输出宏
在C++中， 字符串常数不能作为模板参数。大多数编译器会在错误信息中同时输出字符串的内容。下面的代码展示了这一技巧。

template<const char *> class A {};
#define F0(x) #x
#define F1(x) F0(x)
#define V1 F1(__GNUC__)
int main()
{
    A<V1> a1;
}

这里，宏F0和F1用于将整型转换成字符串。编译器会输出类似于"literal "3" is not a valid template argument because it is the address of an object with static linkage"的出错信息。里面的"3"就是你想知道的宏的内容。

2. 输出常数
同样，浮点数是不能作为模板参数的。编译器通常会在错误信息中包含浮点数的值。利用这一点，我们可以输出浮点常数。不过很不幸的是，VC会隐式的将浮点类型的模板参数转换成int（参见https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=296008）
下面是一种输出整型常量的方法：

template<int N>
class A
{
private:
    A();
};
int main()
{
    A<sizeof(char)> a;
}

3. 输出变量类型
有时候，你可能需要知道某些变量的实际类型，这时候你可以使用下面的代码：

struct Dummy {};
void Fun(const Dummy &);
int main()
{
    Fun(1+1U);
}

PS：如果你使用的是gcc，那么它会输出"not convert `2' to `const Dummy&'"，所以你需要将Fun的声明改成"template<typename T> void Fun(T);"（换句话说，在gcc中上面的代码也可以用于输出常数的值）

4. 输出包含路径
如果要获取STL头文件的路径，你可以使用：

#include <ext/hash_set>
using __gnu_cxx::hash_set;

int main()
{
    hash_set<> m;
}

PS：这里也可以使用vector。

好，现在是时候牛刀小试了。关于如何获取编译器的版本信息，可以参考这篇文章：Pre-defined Compiler Macros

下面是利用上面介绍的技巧获得的dinkumware网站的一些资料：

1. VC
版本 (_MSC_FULL_VER)：
         VC8 140050727
         VC7.1 13103077
         VC7 13009466
         VC6 12008804
包含路径：
         D:\cplt501_vc_source\include (with _CPPLIB_VER=501)

2. EDG
版本(__EDG_VERSION__):
         3.05 
编译参数：
         edgcc --alt -D_WIN32 -D_M_IX86 --no_inlining --diag_suppress=1290 --long_long --wchar_t_keyword -D_C99 -ID:\cplt501_gen_source/include/c -ID:\cplt501_gen_source/include -IC:\PROGRA~1\MICROS~2.NET\VC7/include --exceptions --microsoft -c sourceFile.cpp
因为使用了VC兼容模式进行编译，所以编译器可能会模拟VC的部分bug

3. GCC
版本：
         3.2.0
包含路径：
         D:/cplt501_gen_source/include and D:/Mingw/include/c++/3.2/
可以看到这里使用的GCC的版本已经相当陈旧了

文章出处：http://www.diybl.com/course/3_program/c++/cppsl/2008108/149011.html

true 0
false 非0