[分享]C++的一些FAQ

为什么一个空类的大小不为 0？

要清楚，两个不同的对象的地址也是不同的。基于同样的理由，new总是返回指向不同对象
的指针。
看看：

class Empty { };

void f()
{
Empty a, b;
if (&a == &b) cout << "impossible: report error to compiler supplier";

Empty* p1 = new Empty;
Empty* p2 = new Empty;
if (p1 == p2) cout << "impossible: report error to compiler supplier";
}

有一条有趣的规则：一个空的基类并不一定有分隔字节。

struct X : Empty {
int a;
// ...
};

void f(X* p)
{
void* p1 = p;
void* p2 = &p->a;
if (p1 == p2) cout << "nice: good optimizer";
}

这种优化是允许的，可以被广泛使用。它允许程序员使用空类以表现一些简单的概念。现在
有些编译器提供这种“空基类优化”(empty base class optimization)。

[此贴子已经被作者于2006-7-10 8:58:22编辑过]

为什么不能有虚拟构造函数？

虚拟调用是一种能够在给定信息不完全(given partial information)的情况下工作
的机制。特别地，虚拟允许我们调用某个函数，对于这个函数，仅仅知道它的接口，而不知
道具体的对象类型。但是要建立一个对象，你必须拥有完全的信息。特别地，你需要知道要
建立的对象的具体类型。因此，对构造函数的调用不可能是虚拟的。

当要求建立一个对象时，一种间接的技术常常被当作“虚拟构造函数”来使用。有关例子，
请参见《C++程序设计语言》第三版 15.6.2.节。

下面这个例子展示一种机制：如何使用一个抽象类来建立一个适当类型的对象。

struct F { // 对象建立函数的接口
virtual A* make_an_A() const = 0;
virtual B* make_a_B() const = 0;
};

void user(const F& fac)
{
A* p = fac.make_an_A(); // 将A 作为合适的类型
B* q = fac.make_a_B(); // 将B 作为合适的类型
// ...
}

struct FX : F {
A* make_an_A() const { return new AX(); } // AX是A 的派生
B* make_a_B() const { return new BX(); } // AX是 B的派生
};

struct FY : F {
A* make_an_A() const { return new AY(); } // AY是A 的派生
B* make_a_B() const { return new BY(); } // BY是B的派生

};

int main()
{
user(FX()); // 此用户建立 AX 与BX
user(FY()); // 此用户建立 AY 与BY
// ...
}

这是所谓的“工厂模式”(the factory pattern)的一个变形。关键在于，user 函数
与 AX 或AY这样的类的信息被完全分离开来了。

为什么重载在继承类中不工作？

这个问题（非常常见）往往出现于这样的例子中：

#include<iostream>
using namespace std;

class B {
public:
int f(int i) { cout << "f(int): "; return i+1; }
// ...
};

class D : public B {
public:
double f(double d) { cout << "f(double): "; return d+1.3; }
// ...
};

int main()
{
D* pd = new D;

cout << pd->f(2) << '\n';
cout << pd->f(2.3) << '\n';
}

它输出的结果是：

f(double): 3.3
f(double): 3.6

而不是象有些人猜想的那样：

f(int): 3
f(double): 3.6

换句话说，在 B 和 D 之间并没有发生重载的解析。编译器在 D 的区域内寻找，找到了一个
函数double f(double)，并执行了它。它永远不会涉及（被封装的）B的区域。在C++
中，没有跨越区域的重载——对于这条规则，继承类也不例外。更多的细节，参见《C++语
言的设计和演变》和《C++程序设计语言》。

但是，如果我需要在基类和继承类之间建立一组重载的 f()函数呢？很简单，使用 using
声明：

class D : public B {
public:
using B::f; // make every f from B available
double f(double d) { cout << "f(double): "; return d+1.3; }
// ...
};

进行这个修改之后，输出结果将是：

f(int): 3
f(double): 3.6

这样，在 B 的 f()和 D 的 f()之间，重载确实实现了，并且选择了一个最合适的 f()进行
调用。

我应该将“const”放在类型之前还是之后？

我把它放在前面，但那仅仅是个人爱好问题。“const T”和“T const”总是都被允许
的，而且是等效的。例如：

const int a = 1; // ok
int const b = 2; // also ok

我猜想第一种版本可能会让少数（更加固守语法规范）的程序员感到迷惑。

为什么？当我发明“const”（最初的名称叫做“readonly”，并且有一个对应的
“writeonly”）的时候，我就允许它出现在类型之前或之后，因为这样做不会带来任何
不明确。标准之前的 C和C++规定了很少的（如果有的话）特定的顺序规范。

我不记得当时有过任何有关顺序问题的深入思考或讨论。那时，早期的一些使用者——特别
是我——仅仅喜欢这种样子：

const int c = 10;

看起来比这种更好：

int const c = 10;

也许我也受了这种影响：在我最早的一些使用“readonly”的例子中

readonly int c = 10;

比这个更具有可读性：

int readonly c = 10;

我创造的那些最早的使用“const”的（C 或 C++）代码，看来已经在全球范围内取代了
“readonly”。

我记得这个语法的选择在几个人——例如 Dennis Ritchie——当中讨论过，但我不记得
当时我倾向于哪种语言了。

注意在固定指针（const pointer）中，“const”永远出现在“*”之后。例如：

int *const p1 = q; // 指向 int变量的固定指针
int const* p2 = q; //指向int 常量的指针
const int* p3 = q; //指向int 常量的指针

为什么 delete 不会将操作数置 0？

考虑一下：

delete p;
// ...
delete p;

如果在...部分没有涉及到 p 的话，那么第二个“delete p;”将是一个严重的错误，因
为 C++的实现（译注：原文为 a C++ implementation，当指 VC++这样的实现了 C++
标准的具体工具）不能有效地防止这一点（除非通过非正式的预防手段）。既然delete 0
从定义上来说是无害的，那么一个简单的解决方案就是，不管在什么地方执行了“delete
p;”，随后都执行“p=0;”。但是，C++并不能保证这一点。

一个原因是，delete 的操作数并不需要一个左值（lvalue）。考虑一下：

delete p+1;
delete f(x);

在这里，被执行的 delete 并没有拥有一个可以被赋予 0 的指针。这些例子可能很少见，
但它们的确指出了，为什么保证“任何指向被删除对象的指针都为 0”是不可能的。绕过这
条“规则”的一个简单的方法是，有两个指针指向同一个对象：

T* p = new T;
T* q = p;
delete p;
delete q; // 糟糕！

C++显式地允许delete操作将操作数左值置 0，而且我曾经希望C++的实现能够做到这一
点，但这种思想看来并没有在C++的实现中变得流行。

如果你认为指针置0 很重要，考虑使用一个销毁的函数：

template<class T> inline void destroy(T*& p) { delete p; p = 0; }

考虑一下，这也是为什么需要依靠标准库的容器、句柄等等，来将对 new 和 delete 的显
式调用降到最低限度的另一个原因。

注意，通过引用来传递指针（以允许指针被置 0）有一个额外的好处，能防止 destroy()
在右值上（rvalue）被调用：

int* f();
int* p;
// ...
destroy(f()); // 错误：应该使用一个非常量（non-const）的引用传递右值
destroy(p+1); // 错误：应该使用一个非常量（non-const）的引用传递右值

我如何定义一个类内部（in-class）的常量？

如果你需要一个通过常量表达式来定义的常量，例如数组的范围，你有两种选择：

class X {
static const int c1 = 7;
enum { c2 = 19 };

char v1[c1];
char v2[c2];

// ...
};

乍看起来，c1的声明要更加清晰，但是要注意的是，使用这种类内部的初始化语法的时候，
常量必须是被一个常量表达式初始化的整型或枚举类型，而且必须是static 和const 形
式。这是很严重的限制：

class Y {
const int c3 = 7; // 错误：不是 static
static int c4 = 7; // 错误：不是 const
static const float c5 = 7; // 错误：不是整型
};

我倾向使用枚举的方式，因为它更加方便，而且不会诱使我去使用不规范的类内初始化语法。

那么，为什么会存在这种不方便的限制呢？一般来说，类在一个头文件中被声明，而头文件
被包含到许多互相调用的单元去。但是，为了避免复杂的编译器规则，C++要求每一个对象
只有一个单独的定义。如果 C++允许在类内部定义一个和对象一样占据内存的实体的话，这
种规则就被破坏了。对于C++在这个设计上的权衡，请参见《C++语言的设计和演变》。

如果你不需要用常量表达式来初始化它，那么可以获得更大的弹性：

class Z {
static char* p; // 在定义中初始化
const int i; // 在构造函数中初始化
public:
Z(int ii) :i(ii) { }
};

char* Z::p = "hello, there";

你可以获取一个 static成员的地址，当且仅当它有一个类外部的定义的时候：

class AE {
// ...
public:
static const int c6 = 7;
static const int c7 = 31;
};

const int AE::c7; // 定义

int f()
{
const int* p1 = &AE::c6; // 错误：c6 没有左值
const int* p2 = &AE::c7; // ok
// ...
}

有没有“指定位置删除”(placement delete)？

没有，不过如果你需要的话，可以自己写一个。

看看这个指定位置创建(placement new)，它将对象放进了一系列Arena中；

class Arena {
public:
void* allocate(size_t);
void deallocate(void*);
// ...
};

void* operator new(size_t sz, Arena& a)
{
return a.allocate(sz);
}

Arena a1(some arguments);
Arena a2(some arguments);

这样实现了之后，我们就可以这么写：

X* p1 = new(a1) X;
Y* p2 = new(a1) Y;
Z* p3 = new(a2) Z;
// ...

但是，以后怎样正确地销毁这些对象呢？没有对应于这种“placement new”的内建的
“placement delete”，原因是，没有一种通用的方法可以保证它被正确地使用。在C++
的类型系统中，没有什么东西可以让我们确认，p1一定指向一个由 Arena类型的a1分派
的对象。p1可能指向任何东西分派的任何一块地方。

然而，有时候程序员是知道的，所以这是一种方法：

template<class T> void destroy(T* p, Arena& a)
{
if (p) {
p->~T(); // explicit destructor call
a.deallocate(p);
}
}

现在我们可以这么写：

destroy(p1,a1);
destroy(p2,a2);
destroy(p3,a3);

如果 Arena 维护了它保存着的对象的线索，你甚至可以自己写一个析构函数，以避免它发
生错误。

这也是可能的：定义一对相互匹配的操作符 new()和 delete()，以维护《C++程序设计
语言》15.6中的类继承体系。参见《C++语言的设计和演变》10.4 和《C++程序设计语言》
19.4.5。

我必须在类声明处赋予数据吗？

不必须。如果一个接口不需要数据时，无须在作为接口定义的类中赋予数据。代之以在派生
类中给出它们。参见“为什么编译要花这么长的时间？”。

有时候，你必须在一个类中赋予数据。考虑一下复数类的情况：

template<class Scalar> class complex {
public:
complex() : re(0), im(0) { }
complex(Scalar r) : re(r), im(0) { }
complex(Scalar r, Scalar i) : re(r), im(i) { }
// ...

complex& operator+=(const complex& a)
{ re+=a.re; im+=a.im; return *this; }
// ...
private:
Scalar re, im;
};

设计这种类型的目的是将它当做一个内建（built-in）类型一样被使用。在声明处赋值是
必须的，以保证如下可能：建立真正的本地对象（genuinely local objects）(比如
那些在栈中而不是在堆中分配的对象)，或者使某些简单操作被适当地inline 化。对于那
些支持内建的复合类型的语言来说，要获得它们提供的效率，真正的本地对象和 inline
化都是必要的。

为什么不能为模板参数定义约束（constraints）？

可以的，而且方法非常简单和通用。

看看这个：

template<class Container>
void draw_all(Container& c)
{
for_each(c.begin(),c.end(),mem_fun(&Shape::draw));
}

如果出现类型错误，可能是发生在相当复杂的 for_each()调用时。例如，如果容器的元
素类型是int，我们将得到一个和for_each()相关的含义模糊的错误(因为不能够对对一
个int值调用Shape::draw 的方法)。

为了提前捕捉这个错误，我这样写：

template<class Container>
void draw_all(Container& c)
{
Shape* p = c.front(); // accept only containers of
Shape*s

for_each(c.begin(),c.end(),mem_fun(&Shape::draw));
}

对于现在的大多数编译器，中间变量 p 的初始化将会触发一个易于了解的错误。这个窍门
在很多语言中都是通用的，而且在所有的标准创建中都必须这样做。在成品的代码中，我也
许可以这样写：

template<class Container>
void draw_all(Container& c)
{
typedef typename Container::value_type T;
Can_copy<T,Shape*>(); // accept containers of only
Shape*s

for_each(c.begin(),c.end(),mem_fun(&Shape::draw));
}

这样就很清楚了，我在建立一个断言(assertion)。Can_copy 模板可以这样定义：

template<class T1, class T2> struct Can_copy {
static void constraints(T1 a, T2 b) { T2 c = a; b = a; }
Can_copy() { void(*p)(T1,T2) = constraints; }
};

Can_copy(在运行时)检查 T1 是否可以被赋值给 T2。Can_copy<T,Shape*>检查 T 是
否是 Shape*类型，或者是一个指向由 Shape 类公共继承而来的类的对象的指针，或者是
被用户转换到Shape*类型的某个类型。注意这个定义被精简到了最小：

一行命名要检查的约束，和要检查的类型
一行列出指定的要检查的约束(constraints()函数)
一行提供触发检查的方法(通过构造函数)

注意这个定义有相当合理的性质：

你可以表达一个约束，而不用声明或复制变量，因此约束的编写者可以用不着去设想变量如
何被初始化，对象是否能够被复制，被销毁，以及诸如此类的事情。(当然，约束要检查这
些属性的情况时例外。)
使用现在的编译器，不需要为约束产生代码
定义和使用约束，不需要使用宏
当约束失败时，编译器会给出可接受的错误信息，包括“constraints”这个词（给用户
一个线索），约束的名字，以及导致约束失败的详细错误（例如“无法用 double*初始化
Shape*”）。

那么，在C++语言中，有没有类似于 Can_copy——或者更好——的东西呢？在《C++语言
的设计和演变》中，对于在 C++中实现这种通用约束的困难进行了分析。从那以来，出现了
很多方法，来让约束类变得更加容易编写，同时仍然能触发良好的错误信息。例如，我信任
我在 Can_copy 中使用的函数指针的方式，它源自 Alex Stepanov 和 Jeremy Siek。
我并不认为 Can_copy()已经可以标准化了——它需要更多的使用。同样，在 C++社区中，
各种不同的约束方式被使用；到底是哪一种约束模板在广泛的使用中被证明是最有效的，还
没有达成一致的意见。

但是，这种方式非常普遍，比语言提供的专门用于约束检查的机制更加普遍。无论如何，当
我们编写一个模板时，我们拥有了C++提供的最丰富的表达力量。看看这个：

template<class T, class B> struct Derived_from {
static void constraints(T* p) { B* pb = p; }
Derived_from() { void(*p)(T*) = constraints; }
};

template<class T1, class T2> struct Can_copy {
static void constraints(T1 a, T2 b) { T2 c = a; b = a; }
Can_copy() { void(*p)(T1,T2) = constraints; }
};

template<class T1, class T2 = T1> struct Can_compare {
static void constraints(T1 a, T2 b) { a==b; a!=b; a<b; }
Can_compare() { void(*p)(T1,T2) = constraints; }
};

template<class T1, class T2, class T3 = T1> struct Can_multiply {
static void constraints(T1 a, T2 b, T3 c) { c = a*b; }
Can_multiply() { void(*p)(T1,T2,T3) = constraints; }
};

struct B { };
struct D : B { };
struct DD : D { };
struct X { };

int main()
{
Derived_from<D,B>();
Derived_from<DD,B>();
Derived_from<X,B>();
Derived_from<int,B>();
Derived_from<X,int>();

Can_compare<int,float>();
Can_compare<X,B>();
Can_multiply<int,float>();
Can_multiply<int,float,double>();
Can_multiply<B,X>();

Can_copy<D*,B*>();
Can_copy<D,B*>();
Can_copy<int,B*>();
}

// 典型的“元素必须继承自Mybase*”约束:

template<class T> class Container : Derived_from<T,Mybase> {
// ...
};

事实上，Derived_from并不检查来源（derivation），而仅仅检查转换（conversion），
不过这往往是一个更好的约束。为约束想一个好名字是很难的。

我应该如何对付内存泄漏？

写出那些不会导致任何内存泄漏的代码。很明显，当你的代码中到处充满了 new 操作、
delete操作和指针运算的话，你将会在某个地方搞晕了头，导致内存泄漏，指针引用错误，
以及诸如此类的问题。这和你如何小心地对待内存分配工作其实完全没有关系：代码的复杂
性最终总是会超过你能够付出的时间和努力。于是随后产生了一些成功的技巧，它们依赖于
将内存分配（allocations）与重新分配（deallocation）工作隐藏在易于管理的类型
之后。标准容器（standard containers）是一个优秀的例子。它们不是通过你而是自
己为元素管理内存，从而避免了产生糟糕的结果。想象一下，没有 string 和 vector 的
帮助，写出这个：

#include<vector>
#include<string>
#include<iostream>
#include<algorithm>
using namespace std;

int main() // small program messing around with strings
{
cout << "enter some whitespace-separated words:\n";
vector<string> v;
string s;
while (cin>>s) v.push_back(s);

sort(v.begin(),v.end());

string cat;
typedef vector<string>::const_iterator Iter;
for (Iter p = v.begin(); p!=v.end(); ++p) cat += *p+"+";
cout << cat << '\n';
}

你有多少机会在第一次就得到正确的结果？你又怎么知道你没有导致内存泄漏呢？

注意，没有出现显式的内存管理，宏，造型，溢出检查，显式的长度限制，以及指针。通过
使用函数对象和标准算法（standard algorithm），我可以避免使用指针——例如使用
迭代子（iterator），不过对于一个这么小的程序来说有点小题大作了。

这些技巧并不完美，要系统化地使用它们也并不总是那么容易。但是，应用它们产生了惊人
的差异，而且通过减少显式的内存分配与重新分配的次数，你甚至可以使余下的例子更加容
易被跟踪。早在 1981 年，我就指出，通过将我必须显式地跟踪的对象的数量从几万个减少
到几打，为了使程序正确运行而付出的努力从可怕的苦工，变成了应付一些可管理的对象，
甚至更加简单了。

如果你的程序还没有包含将显式内存管理减少到最小限度的库，那么要让你程序完成和正确
运行的话，最快的途径也许就是先建立一个这样的库。

模板和标准库实现了容器、资源句柄以及诸如此类的东西，更早的使用甚至在多年以前。异
常的使用使之更加完善。

如果你实在不能将内存分配/重新分配的操作隐藏到你需要的对象中时，你可以使用资源句
柄（resource handle），以将内存泄漏的可能性降至最低。这里有个例子：我需要通过
一个函数，在空闲内存中建立一个对象并返回它。这时候可能忘记释放这个对象。毕竟，我
们不能说，仅仅关注当这个指针要被释放的时候，谁将负责去做。使用资源句柄，这里用了
标准库中的 auto_ptr，使需要为之负责的地方变得明确了。

#include<memory>
#include<iostream>
using namespace std;

struct S {
S() { cout << "make an S\n"; }
~S() { cout << "destroy an S\n"; }
S(const S&) { cout << "copy initialize an S\n"; }
S& operator=(const S&) { cout << "copy assign an S\n"; }
};

S* f()
{
return new S; // 谁该负责释放这个 S？
};

auto_ptr<S> g()
{
return auto_ptr<S>(new S); // 显式传递负责释放这个S
}

int main()
{
cout << "start main\n";
S* p = f();
cout << "after f() before g()\n";
// S* q = g(); // 将被编译器捕捉
auto_ptr<S> q = g();
cout << "exit main\n";
// *p产生了内存泄漏
// *q被自动释放
}

在更一般的意义上考虑资源，而不仅仅是内存。

如果在你的环境中不能系统地应用这些技巧（例如，你必须使用别的地方的代码，或者你的
程序的另一部分简直是原始人类（译注：原文是 Neanderthals，尼安德特人，旧石器时
代广泛分布在欧洲的猿人）写的，如此等等），那么注意使用一个内存泄漏检测器作为开发
过程的一部分，或者插入一个垃圾收集器（garbage collector）。

怎样从输入中读取一个字符串？

你可以用这种方式读取一个单独的以空格结束的词：

#include<iostream>
#include<string>
using namespace std;

int main()
{
cout << "Please enter a word:\n";

string s;
cin>>s;

cout << "You entered " << s << '\n';
}

注意，这里没有显式的内存管理，也没有可能导致溢出的固定大小的缓冲区。

如果你确实想得到一行而不是一个单独的词，可以这样做：


#include<iostream>
#include<string>
using namespace std;

int main()
{
cout << "Please enter a line:\n";

string s;
getline(cin,s);

cout << "You entered " << s << '\n';
}

为什么我不能重载点符号，::，sizeof，等等？

大多数的运算符能够被程序员重载。例外的是：

. (点符号) :: ?: sizeof

并没有什么根本的原因要禁止重载?:。仅仅是因为，我没有发现有哪种特殊的情况需要重
载一个三元运算符。注意一个重载了 表达式1？表达式2：表达式 3 的函数，不能够保证
表达式 2：表达式3 中只有一个会被执行。

Sizeof 不能够被重载是因为内建的操作（built-in operations），诸如对一个指向
数组的指针进行增量操作，必须依靠它。考虑一下：

X a[10];
X* p = &a[3];
X* q = &a[3];
p++; // p指向a[4]
// 那么p 的整型值必须比 q的整型值大出一个 sizeof(X)

所以，sizeof(X)不能由程序员来赋予一个不同的新意义，以免违反基本的语法。

在 N::m 中，无论 N 还是 m 都不是值的表达式；N 和 m 是编译器知道的名字，::执行一个
（编译期的）范围解析，而不是表达式求值。你可以想象一下，允许重载 x::y的话，x 可
能是一个对象而不是一个名字空间（namespace）或者一个类，这样就会导致——与原来
的表现相反——产生新的语法（允许 表达式 1::表达式 2）。很明显，这种复杂性不会带
来任何好处。

理论上来说，.（点运算符）可以通过使用和->一样的技术来进行重载。但是，这样做会导
致一个问题，那就是无法确定操作的是重载了.的对象呢，还是通过.引用的一个对象。例
如：


class Y {
public:
void f();
// ...
};

class X { // 假设你能重载.
Y* p;
Y& operator.() { return *p; }
void f();
// ...
};

void g(X& x)
{
x.f(); // X::f还是Y::f还是错误？
}

这个问题能够用几种不同的方法解决。在标准化的时候，哪种方法最好还没有定论。更多的
细节，请参见《C++语言的设计和演变》。

考完试再看
下午c++最后一个
现在我可不想整理我思路

给置顶了，那有空就翻翻以前的贴子，看看有什么经常性的问题，弄个索引什么之类的。

---------------------------------------------

晕，水平不够，分辨不出来。

[此贴子已经被作者于2006-7-9 9:10:28编辑过]

p1 是void*型的指针，可以指向其他类型。

希望多多发这种帖子
这种帖子人人都需要
特别我这样的隔绝人

想问下为什么对cin对象可以直接进行逻辑判断.
也就是while(cin)中cin处于正常状态的时候是true.而非正常状态为false.
自己写类的时候怎样编写可以达到同样效果?

[此贴子已经被作者于2006-8-8 13:09:51编辑过]

我可以通过编译，编译器的问题可能。

static const int a = 10;

a是静态常量，属于类的常量，只有一份
你那样写，的常量属于类对象，有多少非静态的对象，就有多少个。

好贴，赞一个。
By the way FAQ是什么的缩写？

这些是个好东西!

好地方啊

恩恩，回了

谢列