missing idea

Subject: Thinking in C++ 2e
————————

Date: Sat, Apr 5, 2008 at 8:43 AM

[C and C++ compared] @ pp.91
 
 int func();
 
 C: a function with any number and type of argument
 C++: a function with no arguments
 ———-
Date: Sat, Apr 5, 2008 at 9:21 AM

  int i;
 is a definition. (and of course, a declaration.)
 
  extern int i;
 is a declaration.
 
 usually, multiple global (non-static)
  int i;
 will be stripped to one instance by the linker.
 ———-
Date: 2008/4/5

[Linker]
 
 pp.97
 
 When the linker finds a definition in a library, the entire object
 module,  not just the function definition, is linked into the
 executable program. Note that the whole library isn’t linked, just the
 object module in the library that contains the definition you want.
 
 也就是说，library其实是一个包含多个obj的文件，当linker在某个lib中解析到某个函数时，便会把其中的obj整个连接进来。
 ———-
Date: 2008/4/5

[Standard C++ Library] @pp.102
 
 在向后兼容的头文件中，是没有名字空间的。所以，
  #include <iostream.h>
 的含义就是
  #include <iostream>
  using namespace std;
 ———-
Date: Sun, Apr 6, 2008 at 11:06 PM

[C and C++ compared] @ pp.125
 
 func(void);
 
 C: a function returning int
 C++: error
 ———-
Date: Mon, Apr 7, 2008 at 10:53 AM

[Intrinsic Types] @ pp.143
 
 The Standard stipulates only the minimum and maximum value of a type,
 not the actual value domain of the type.
 Therefore, a short can be 64 bits long on a 64-bit platform.
 
  * valid type specifier usage:
 
 (long|short) (int)?
 (signed|unsigned) (long|short) (int)?
 (signed|unsigned) char
 long double
 
 
  * invalid, eg.:
 short float
 short double
 long float
 signed float
 ———-
Date: Mon, Apr 7, 2008 at 11:17 AM

[Pointer] @ pp.148
 
  int * a, b, c;
 
 defines a as a pointer to int, b and c as int’s.
 
 It’s better to do this way:
  int *a;
  int *b;
  int *c;
 ———-
Date: Mon, Apr 7, 2008 at 9:36 PM

[C and C++ compared] @ pp.166
 
  const int k;
 
 C: OK. containing garbage if a local variable.
 C++: error. const must be initialized.
 ———-
Date: 2008/4/7

[Operators] @ pp.173
 
 Shift operators: << and >>
 
 移位运算符的定义比较开放.
 
 这两种移动都是logical(不考虑符号)或者arithmetic(考虑符号)的, 不是shift-and-rotate(循环移位).
 
 当移位位数是负数时, 结果是undefined.
 
 左移的定义比较简单明了, 相当于乘以2的幂.
 
 右移就复杂了. 如果移位位数比被操作数的位数多, 结果是undefined.
 如果被操作数是signed, 那么结果还是implementation defined.
 
 参考MSDN.
 ———-
Date: Wed, Apr 9, 2008 at 11:36 PM

[C and C++ compared] @ pp.258
 
 struct X {};
 
 C: illegal.
 C++: legal. size nonzero, because each object must have a unique address.
 ———-
Date: Wed, Apr 9, 2008 at 11:52 PM

[Linkage] @ pp.262
 
 In Standard C++, file static is a deprecated feature.
 ———-
Date: 2008/4/9

[C and C++ compared] @ pp.262
 
 C和C++都允许函数被声明多次，条件是这些声明都一致。但是都不允许结构体的重新声明。
 ———-
Date: Thu, Apr 10, 2008 at 12:18 AM

[Identifier] @ pp.265, pp.404
 
 Identifiers with leading underscores are reserved for system use.
 
 See also:
 
 * C Primer Plus, 5e, Chapter 2, Keywords and Reserved Identifiers.
 
 Reserved identifiers include those beginning with an underscore
 character and the names of the standard library functions.
 
 * The C Programming Language, 2e, Appendix B – Standard Library
 
 External identifiers that begin with an underscore are reserved for
 use by the library, as are all other identifiers that begin with an
 underscore and an upper-case letter or another underscore.
 
 * The C++ Programming Language, 3e, 4.9.3 Names [dcl.name]
 
 Names starting with an underscore are reserved for special facilities
 in the implementation and the run-time environment, so such names
 should not be used in application programs.
 ———-
Date: 2008/4/11

[Encapsulation] @ pp.279
 
 原文所述
 If the interface and implementation are clearly separated and
 protected, you can accomplish this and require only a relink by the
 client programmer.
 
 这不总是正确的。如果实现变了的同时导致了类的成员变化，也就是定义变化了，则需要重新编译。否则以前编译的目标代码（obj）还会按照以前的类定义来分配或者理解内存对象，新的目标代码则按照新的定义。后果嘛，难以想象哦，当然是灾难性的。
 
 参考Don Box的Essential COM（潘爱民译）第1章。
 ———-
Date: 2008/4/13

[Internal] @ pp.288
 
 对象在内存中的存放，C++规定相同访问级别的成员(within a particular "access
 block")，保证在内存中是连续的。然而不同访问级别对应的区块(access
 block)不一定按照声明的顺序存放，甚至不一定是连续的，这是实现相关的(implementation-specific)。
 ———-
Date: 2008/4/14

[C and C++ compared] @ pp.308
 
 在C中，定义与初始化一般是分开的，因为定义总是在一个block的开始。C99改变了这一点，允许在作用域的任何位置定义变量了。
 
 在C++中，定义与初始化是不分家的。C++保证一个对象在建立的时候被初始化。C++提倡用到变量的时候再定义它。
 ———-
Date: 2008/4/14

[Special Members] @ pp.304
 
 有参数的构造函数会禁止编译器隐式生成无参数的构造函数。
 
 [Special Members] @ pp.305
 
 构造函数和析构函数都没有任何返回值。
 ———-
Date: 2008/4/14

[Lifetime and Scope] @ pp.306
 
 出了作用域的对象会被析构，包括用goto跳出的。但是setjmp和longjmp不会导致析构函数被调用。
 
 [Lifetime and Scope] @ pp.311
 
 栈上的对象空间是预先分配好的，到了对象被定义的序列点(sequence point)那里，才会调用构造函数。
 
 如果某些定义会被goto或者switch跳过，编译器会给出警告。
 ———-
Date: 2008/4/14

[Lifetime and Scope] @ pp.3
10
 
 for循环的循环变量，如果在初始化表达式里定义，例如
  for (int i = 0; …, …)
 其作用域是for循环。
 ———-
Date: 2008/4/14

[Initialization] @ pp.320
 
  int b[6] = {0};
 
 会用给出的值按顺序初始化数组，其余的值填0。这比for循环省事多了，也安全多了（不会出现off-by-one错误）。
 
  int c[] = {1, 2, 3, 4};
  char s[] = "string";
 
 则是让编译器自动决定数组的大小。
 
  Y y1[] = { Y(1,2), Y(2,3), Y(3,4) };
 
 有构造函数的类或者结构体可以这样初始化。
 ———-
Date: 2008/4/14

[Special Members] @ pp.323
 
 无参数的构造函数，确切地说，应该是，默认构造函数。
 
 当一个类没有定义任何构造函数时，编译器会自动生成一个默认构造函数。这个默认构造函数什么也不做。
 
 如果定义了任何的构造函数，则编译器就不会自动生成默认构造函数。当需要使用默认构造函数初始化对象时，就可能产生编译错误。
 
 一般的，应该定义默认构造函数，不要让编译器生成。
 ———-
Date: 2008/4/14

[Overloading] @ pp.331
 
 重载仅限于不同作用域(scope)或者不同参数(arguments)的函数。只有返回值(return value)不同的函数，是不能被重载的。
 ———-
Date: 2008/4/14

[Internal] @ pp.331
 
 Name mangling 或者叫 name decoration 的一个价值是 type-safe
 linkage。因为声明不同的函数会使编译器产生不同的 name decoration，从而错误的调用会在连接的时候产生解析错误。
 ———-
Date: 2008/4/14

[Aggregation Types] @ pp.339
 
 匿名联合(anonymous union)，也就是既没有类型名也没有变量名的联合。这样的联合，其成员的名字直接进入包含这个联合的scope。例如，
 
 int main() {
  union {
  int i;
  float f;
  };
  i = 12;
  f = 1.22;
 }
 
 或者
 
 struct Entry {
  char* name;
  Type t;
  union {
   char* s;
   int i;
  };
 };
 
 如果这个union是在文件作用域(file scope)的，则必须是静态(static)的。
 ———-
Date: 2008/4/14

[Declarations] @ pp.341
 
 默认参数有两个要求：
  1) 只有末尾的参数可以设置默认值。
  2) 调用的时候，一旦开始使用默认值，后面的就都必须使用默认值。
 
 默认参数在函数的声明时指明，注意不是函数定义时。因为编译器需要先知道默认参数，才能执行函数调用。
 
 因为默认参数是静态绑定的，所以永远不要重新定义继承来的默认参数。参考 Effective C++ Item 38。
 ———-
Date: 2008/4/15

[Design] @ pp.348
 
 接口的设计是最重要的，要想着调用者和读者。不要过分重视效率。
 
 如果使用默认参数会使实现内部根据这个参数选择分支，那么还不如把接口分开设计。
 
 使用默认参数的一种好处是，可以预先设计一些占位参数(placeholder arguments)，这样当接口需要新的参数的时候，调用代码基本不需要变化。
 ———-
Date: 2008/4/15

[Type Qualifiers] @ pp.354
 
 const 的作用有：
  1. 代替 #define，编译器尽量不为 const 分配空间，直接将其展开。如，
    const int i = 100;
  2. 标志不可修改的变量，编译器会分配空间，可以被动态或静态初始化，只是之后不再修改。如，
    const char c = cin.get();
    const int ii[] = { 1, 2, 3, 4 };
 
 文件作用域(file scope)的const，是static，也就是internal linkage的，一般不会被分配空间。
 除非明确指明extern，这时就会被分配空间了。
 
 当遇到隐式或显示的引用，用法1的 const 就会被分配空间。如，
  extern const int i;
 或者
  const int j = 5;
  long address = (long)&j;
 ———-
Date: 2008/4/15

[C and C++ compared] @ pp.358
 
 const 变量
 
 C:
  1) 含义是，不能通过这个变量修改内存（并不禁止如其它线程、其它指针等等的修改方式）。
  2) 不是一个编译器常量。不能用来代替 #define 或者字面常量。
  3) 默认是external linkage，不同文件中同名会冲突，总会被分配存储空间。
 
 C++:
  1) 包含C的含义，还是编译器认可的常量。
  2) 可以用来代替字面常量，从而代替 #define。
  3) 默认是internal linkage，不同文件中同名不会冲突，如果可能的话就不会被分配存储空间。
 ———-
Date: 2008/4/15

[C and C++ compared] @ pp.364
 
  char *s = "howdy";
 
 这里s指向的是静态只读的字符串。把const的东西赋给非const的东西，本来编译器应该报错的。不过为了迁就以往的C代码，这里就不报错了。但是，通过s修改静态只读的字符串，其结果是undefined。
 
 一般应该用字面常量来初始化一个数组，如
  char s[] = "howdy";
 ———-
Date: 2008/4/15

[Design] @ pp.365
 
 按值传递的参数，加上const修饰，实际上是没有意义的。如，
  void func(const int i);
 
 如果函数实现中需要限制const，那么在实现中声明一个const引用。如，
  void func(int i) {
    const int &ii = i;
    i++; // error
  }
 
 这样的话，函数声明可以避免给调用者造成疑惑。
 ———-
Date: 2008/4/15

[Design] @ pp.369
 
 按引用传递，实际上是按值传递指针或引用，这样的参数应该尽可能地加上const修饰。如，
 或者
  void func(const int *pi);
 
 否则函数对const的变量就不能适用了。
 ———-
Date: 2008/4/15

[Design] @ pp.372
 
 C++中传递对象的最好方式是按引用传递，const引用，这样可以减少临时对象的创建与清除。
 
 还有一个好处是，因为临时对象都是const的，所以用const引用传递，那么函数就可以接受临时对象。
 ———-
Date: 2008/4/16

[Internal] @ pp.415
 
 标准提到，类内的内联(inline)函数直到类的结尾括号，才会被生成代码。所以在类内的简单的内联函数互相引用还可以被内联。如，
  class Forward {
    int i;
  public:
    Forward() : i(0) {}
    // Call to undeclared function:
    int f() const { return g() + 1; }
    int g() const { return i; }
  };
 
 但其它情况下，调用未经定义的内联函数，很
可能会被编译器退化成普通调用。
 ———-
Date: 2008/4/16

[Internal] @ pp.431
 
 全局静态对象(global static objects)会在进入main()之前被初始化。
 局部静态对象(local static objects)会在第一次进入函数的时候被初始化。
 
 内建类型(intrinsic types)的静态变量被初始化为0；用户定义类型，也就是类对象，编译器会调用构造函数。
 
 静态对象，包括局部的(local)和全局的(global)，会在main()退出后或者在exit()中被析构。所以不要在析构函数中调用exit()，否则可能造成死循环。而abort()不会析构静态对象。析构的顺序与被构造的顺序相反。没有被构造的静态对象不会被析构。
 ———-
Date: 2008/4/16

[Linkage] @ pp.434
 
 在C++中，static的函数和变量、const的变量、inline的函数，是internal
 linkage的。所以能把const的变量和inline的函数放在头文件里。
 
 注意在C中const的变量是external linkage的。
 
 Linkage指的是一个名字对linker的可见性。在link/load时有地址的元素才有linkage的概念。所以类的声明和局部变量没有linkage。
 ———-
Date: 2008/4/17

[Namespaces] @ pp.439
 
 名字空间可以起别名。如
  namespace Bob = BobsSuperDuperLibrary;
 
 无名的名字空间(unnamed namespace)，对于每个translation
 unit是唯一的。它提供了一种隐藏名字的手段，这样就不再需要通过internal linkage来实现了。如，
  namespace {
    int i, j, k;
  }
 
 通过friend声明的名字，会被注入该类所在的名字空间（包括全局名字空间）。
 ———-
Date: 2008/4/17

[Namespaces] @ pp.441
 
 using directive:
  using namespace std;
 把名字空间中的所有名字引入当前的名字空间。
 
 using declaration:
  using std::cout;
 把指定的名字引入当前的名字空间。由于只是名字，所以对于函数，包含所有的重载。
 
 
 需要注意的是， using directive
 可能引入不同名字空间中的名字冲突，从而引起二义性(ambiguity)，但是直到这个名字被用到的时候，才会产生错误。
 
 using declaration 可以覆盖 using directive 引入的名字。
 
 由于 using declaration
 只是引入名字，所以可能引入相同参数类型的函数重载（这样的函数重载是不可能直接声明的），所以这将引入另一种二义性。而且也是直到函数被调用时，才会产生错误。
 ———-
Date: 2008/4/17

[Namespaces] @ pp.445
 
 using directive 和 using declaration 可以在 cpp 文件中使用，不应该在 h 文件中使用。
 
 否则显然会污染名字空间。
 ———-
Date: 2008/4/17

[Static Members] @ pp.450
 
 整数类型的静态常量成员，可以在类内初始化。这是为了能够用它来确定数组的大小，从而避免 enum hack。如，
  class Values {
    static const int size = 100;
  };
 
 所有其它类型的静态常量成员，包括但不限于浮点型、数组等，必须在外面，也就是类的实现文件中，定义和初始化。
 
 整数类型的静态常量成员，当遇到引用时，编译器就需要为它划分存储空间，从而需要在类的实现文件中定义它，而且这时不能再进行初始化了。（注意前面提到的只是初始化，没有定义。）如，
  static const int size;
 
 
 The C++ Programming Language, 3e, 10.4.6.2 [class.memconst] 是这么说的。
 
 
 这个行为我在 g++ 3.4.2 (mingw-special) 上验证通过。但是在 VC 8 (14.00.50727.42)
 上，在实现中的定义会被认作是重复定义。如果去掉，在 g++ 上又通不过。
 
 所以看来还是要避免引用整数类型的静态常量成员，让它们就充当 #define 的替代者就行了。
 ———-
Date: 2008/4/17

[Internal] @ pp.455
 
 静态对象的初始化顺序，在一个translation unit中是确定的，按照声明的顺序初始化，按照相反的顺序消亡。
 
 但是在不同的translation
 unit中的静态对象，初始化的顺序是由linker决定的，也就是不确定的。那么对于有依赖关系的静态对象，结果就是不确定的甚至可能是灾难性的。
 
 书中给出了2中解法。看书吧。
 ———-
Date: 2008/4/17

[Linkage] @ pp.466
 
 由extern后接一个字符串声明一种name decoration方式。如，
 
 extern "C"
 extern "C++"
 
 是标准规定的两种。
 ———-
Date: 2008/4/17

[Internal] @ pp.474
 
 编译器为按值传递的对象生成代码的过程，使用的是拷贝构造函数。
 ———-
Date: 2008/4/17

[References] @ pp.475, pp.477
 
 常引用(const reference)，可以被临时对象(temporary)初始化。如，
  const int &i = 1;
 
 编译器会先用字面常量初始化一个临时对象，然后用临时对象初始化常引用。
 ———-
Date: 2008/4/18

[Special Members] @ pp.480, pp.495
 
 拷贝构造函数(copy constructor)，编译器用它来生成按值传递的中间对象，包括参数和返回值。
 
 而且如下的定义也会调用拷贝构造函数。
  Composite c2(c);
  Composite c2 = c;
 
 如果用户不提供拷贝构造函数，那么编译器将自动生成一个。对于基本类型成员，是位拷贝(bitwise copy,
 bitcopy)；对于用户定义类型成员，是调用该类型的拷贝构造函数。
 
 （注意pp.496说的WoCC是bitwise copy是不对的，实际上是调用了string的拷贝。）
 ———-
Date: 2008/4/18

[Design] @ pp.498
 
 函数参数类型如果使用引用的话，调用这个函数不容易看出来它是否修改参数。如，
  char c;
  cin.get(c);
 
 所以，可以考虑这样，
 用常引用(const reference)来传递不修改的对象，用非常量指针(non-const pointer)来传递要修改的对象。
 ———-
Date: 2008/4/18

[Pointer to Member] @ pp.499
 
 成员指针实际上是一种偏移(offset)，它需要配合一个对象才能产生有效地址。
 
 例如，数据成员的指针，
  int ObjectClass::*pointerToMember = &ObjectClass::a;
  objectPointer->*pointerToMember = 47;
  object.*pointerToMember = 47;
 
 函数成员的指针，
  void (Widget::*pmem)(int) const = &Widget::h;
  (w.*pmem)(1);
  (wp->*pmem)(2);
 ———-
Date: Sat, Apr 19, 2008 at 11:32 AM

[Operator Overloading] @ pp.515
 
 declaration of unary operators:
 
 class Integer {
 …
 public:
  friend const Integer& operator+(const Integer& a);
  friend
const Integer operator-(const Integer& a);
  friend const Integer operator~(const Integer& a);
  friend Integer* operator&(Integer& a);
  friend int operator!(const Integer& a);
 
  friend const Integer& operator++(Integer& a);    // prefix
  friend const Integer operator++(Integer& a, int);    // postfix
  friend const Integer& operator–(Integer& a);    // prefix
  friend const Integer operator–(Integer&a, int);    // postfix
 };
 
 class Byte {
 …
 public:
  const Byte& operator+() const;
  const Byte operator-() const;
  const Byte operator~() const;
  Byte operator!() const;
  Byte* operator&();
 
  const Byte& operator++();    // prefix
  const Byte operator++(int);    // postfix
  const Byte& operator–();    // prefix
  const Byte operator–(int);    // postfix
 };
 ———-
Date: Sat, Apr 19, 2008 at 11:54 AM

[Operator Overloading] @ pp.520
 
 declaration of binary operators:
 
 class Integer {
 …
 public:
  friend const Integer operator+(const Integer& left, const Integer& right);
  friend const Integer operator-(const Integer& left, const Integer& right);
  friend const Integer operator*(const Integer& left, const Integer& right);
  friend const Integer operator/(const Integer& left, const Integer& right);
  friend const Integer operator^(const Integer& left, const Integer& right);
  friend const Integer operator&(const Integer& left, const Integer& right);
  friend const Integer operator|(const Integer& left, const Integer& right);
  friend const Integer operator<<(const Integer& left, const Integer& right);
  friend const Integer operator>>(const Integer& left, const Integer& right);
 
  friend Integer& operator+=(Integer& left, const Integer& right);
  friend Integer& operator-=(Integer& left, const Integer& right);
  friend Integer& operator*=(Integer& left, const Integer& right);
  friend Integer& operator/=(Integer& left, const Integer& right);
  friend Integer& operator%=(Integer& left, const Integer& right);
  friend Integer& operator^=(Integer& left, const Integer& right);
  friend Integer& operator&=(Integer& left, const Integer& right);
  friend Integer& operator|=(Integer& left, const Integer& right);
  friend Integer& operator>>=(Integer& left, const Integer& right);
  friend Integer& operator<<=(Integer& left, const Integer& right);
 
  friend int operator==(const Integer& left, const Integer& right);
  friend int operator!=(const Integer& left, const Integer& right);
  friend int operator<(const Integer& left, const Integer& right);
  friend int operator>(const Integer& left, const Integer& right);
  friend int operator<=(const Integer& left, const Integer& right);
  friend int operator>=(const Integer& left, const Integer& right);
  friend int operator&&(const Integer& left, const Integer& right);
  friend int operator||(const Integer& left, const Integer& right);
 };
 
 class Byte {
 …
 public:
  const Byte operator+(const Byte& right) const;
  const Byte operator-(const Byte& right) const;
  const Byte operator*(const Byte& right) const;
  const Byte operator/(const Byte& right) const;
  const Byte operator%(const Byte& right) const;
  const Byte operator^(const Byte& right) const;
  const Byte operator&(const Byte& right) const;
  const Byte operator|(const Byte& right) const;
  const Byte operator<<(const Byte& right) const;
  const Byte operator>>(const Byte& right) const;
 
  Byte& operator=(const Byte& right);    // only as member function
  Byte& operator+=(const Byte& right);
  Byte& operator-=(const Byte& right);
  Byte& operator*=(const Byte& right);
  Byte& operator/=(const Byte& right);
  Byte& operator%=(const Byte& right);
  Byte& operator^=(const Byte& right);
  Byte& operator&=(const Byte& right);
  Byte& operator!=(const Byte& right);
  Byte& operator>>=(const Byte& right);
  Byte& operator<<=(const Byte& right);
 
  int operator==(const Byte& right) const;
  int operator!=(const Byte& right) const;
  int operator<(const Byte& right) const;
  int operator>(const Byte& right) const;
  int operator<=(const Byte& right) const;
  int operator>=(const Byte& right) const;
  int operator&&(const Byte& right) const;
  int operator||(const Byte& right) const;
 };
 ———-
Date: 2008/4/19

[Operator Overloading] @ pp.531
 
 记住，在各种赋值运算中检查自身赋值(self-assignment)。例如，
 
 Integer& operator+=(Integer& left, const Integer& right) {
  if (&left == &right) {
    // self-assignment
  }
  left.i += right.i;
  return left;
 }
 ———-
Date: 2008/4/19

[Internal] @ pp.534
 
 return value optimization
 
 在按值传递返回值的函数中，如果返回语句这么写，
  return Integer(left.i + right.i);
 那么编译器就会在栈上的返回值容器中直接构造对象（1个构造函数调用）。反之，如果写成
  Integer tmp(left.i + right.i);
  return tmp;
 则会产生1个构造函数调用、1个拷贝构造函数调用、1个析构函数调用。
 
 前面那种情况被称为 return value optimization。
 ———-
Date: 2008/4/19

[Operator Overloading] @ pp.544
 
 运算符重载不能
  * 创造新的运算符
  * 改变运算符的优先级
 ———-
Date: Sat, Apr 19, 2008 at 2:29 PM

[Operator Overloading] @ pp.545
 
 为 iostream 重载运算符，如
 
 class A {
 …
 public:
  friend ostream& operator<<(ostream& os, const A& a);
  friend istream& operator>>(istream&is, A& a);
 };
 
 ostream& operator<<(ostream& os, const A&a) {
  … // e.g., os << a.member;
  return os;
 }
 
 istream& operator<<(istream& is, A& a) {
  … // e.g., is >> a.member;
  return is;
 }
 ———-
Date: Sat, Apr 19, 2008 at 2:35 PM

[Operator Overloading] @ pp.547
 
 basic guidelines for choosing between members and non-members:
 
 all una
ry operators
    member
 = () [] -> ->*
    member, must
 += -= /= *= ^= &= |= %= >>= <<=
    member
 all other binary operators
    non-member
 ———-
Date: 2008/4/19

[Internal] @ pp.549
 
 运算符=可能产生不同的两种调用：
  1) 拷贝构造函数(copy constructor)；
  2) 赋值运算符(operator=)。
 
 如，
  MyType b;
  MyType a = b;    // MyType(MyType&)
  a = b;    // operator=
 
 其实只需要记住一个原则：新对象必须初始化，而初始化过的对象才是真正的赋值。
 
 或者避免使用=号，使用另一种初始化类型，
  MyType a(b);
 ———-
Date: 2008/4/19

[Special Members] @ pp.560
 
 除了拷贝构造函数，运算符=也会被编译器自动生成，生成方式类似，也是成员递归调用+位拷贝的形式。
 
 不要让编译器自动生成拷贝构造函数(copy-constructor)和运算符=(operator=)，应该实现它们。
 
 如果不想给出实现，或者说不提供调用的可能性，可以将其声明为私有(private)。
 ———-
Date: 2008/4/20

[Type Conversion] @ pp.561
 
 一个参数（其它类型）的构造函数（或者后面都有默认参数的构造函数），会被编译器用来做自动类型转换(automatic type
 conversion)。也就是，当一个需要A类型参数的函数，被传入一个B类型的参数，而A恰好有一个接受B的构造函数，编译器自动由B创建一个A的临时对象，传入函数。
 
 为了避免这种情况，可以在这样的构造函数前面加上 explicit，告诉编译器这个构造函数不能被用于隐式类型转换(implicit conversion)。
 ———-
Date: 2008/4/20

[Type Conversion] @ pp.563
 
 类型转换函数(conversion functions)，或者叫做类型转换运算符(cast
 operator)，也可以帮助编译器实现自动类型转换(automatic type conversion)。
 
 这种方式与前面所说的构造函数的方式的区别是，构造函数是在目标类中的，类型转换运算符是在源类中的。构造函数可以在当前系统下添加新的转换方式，而类型转换运算符可以转换到内建类型。
 
 当双目的类型转换运算符被声明为友元(friend)时，就允许左运算子的隐式类型转换，如果是成员函数，则左运算子的类型必须是该类对象。如，
  1 – a;
  a + 1;
 ———-
Date: 2008/4/20

[Type Conversion] @ pp.566
 
 自动类型转换的一种常见的应用，就是 string 类型到 const char* 的转换。
 
 不过自动类型转换常常会产生二义性。为了避免这种二义性，可以干脆避免使用自动类型转换，或者在设计的时候考虑一条单一的转换路径。
 
 由于自动类型转换还可能牵扯到拷贝构造函数等等隐式行为，应该尽量少使用这种特性。
 ———-
Date: 2008/4/20

[Dynamic Objects] @ pp.581
 
 malloc() / free() 与 new / delete 应该配对使用，不要混用。否则行为是undefined。
 
 delete 空指针，是安全的，它什么也不做。所以 delete 完之后立即将指针置为空，能有效防止多次 delete。
 ———-
Date: 2008/4/20

[Dynamic Objects] @ pp.584
 
 delete void* 指针，因为对象类型不能确定，所以不能调用析构函数，只会释放内存。
 所以基本上可以认为，出现这种情况就是有错儿了。
 
 当程序出现内存泄露(memory leak)时，应该想到检查所有 delete 语句的指针类型。
 ———-
Date: 2008/4/20

[Dynamic Objects] @ pp.592
 
 在堆(heap)上建立对象数组，需要默认构造函数。每个新创建的对象都会被调用默认构造函数。
 
 在栈(stack)上建立对象数组，不一定需要调用默认构造函数。如果数据成员都是public的话，可以直接使用聚合类型初始化(aggregate
 initialization)表示法。
 ———-
Date: 2008/4/20

[Dynamic Objects] @ pp.592
 
 new [] 和 delete [] 应该配对使用。如果用 new [] 初始化的数组，由 delete
 释放，那么数组中除了第1个元素之外，其它的元素可能都不能被正确析构。
 ———-
Date: 2008/4/20

[Operator Overloading] @ pp.596
 
 重载 operator new 和 operator delete 可以改变编译器遇到 new 和 delete
 的时候分配和释放内存的行为。注意构造函数和析构函数永远会被调用，这里只是修改分配和释放内存的行为。
 
 重载 operator new 时，要加入错误处理机制，如返回空指针、调用 new-handler、或者抛出 bad_alloc
 异常等。这些行为在重载的 operator new 中必须手动添加。
 ———-
Date: 2008/4/20

[Operator Overloading] @ pp.597
 
 重载全局的 operator new 和 operator delete，会完全重载语言默认提供的机制，即使在重载的定义中也不能调用默认机制。
 
 而且在全局的 operator new 和 operator delete 中，不能使用 C++ 标准库提供的对象，如 cin、cout
 等，因为它们使用 new 来分配内存。
 
 void* operator new(size_t sz);
 void operator delete(void* m);
 ———-
Date: 2008/4/20

[Operator Overloading] @ pp.599
 
 在类内重载 operator new 和 operator delete，必定是类的静态成员(static)，这个关键字不必给出。
 
 对于该类的对象，它们会优先于全局的 operator new 和 operator delete
 被编译器使用。（继承(inheritance)引出的问题以后再说。）
 
 在类内重载的 operator new 和 operator delete 中可以使用 C++ 标准库的对象，如 cin、cout
 等，因为它们使用的是全局的 operator new 和 operator delete，这就不会造成死锁了。
 
 
 class Framis {
 …
  static unsigned char pool[];
  static bool alloc_map[];
 public:
 …
  void* operator new(size_t) throw(bad_alloc);
  void operator delete(void*);
 };
 ———-
Date: 2008/4/20

[Operator Overloading] @ pp.603
 
 在类内重载 operator new[] 和 operator delete[]，即可重载编译器为对象数组的分配和释放内存的行为。
 
 如果未重载这两个函数，那么分配对象数组会调用全局的 operator new 和 operator delete。
 
 
 class Widget {
  …
 public:
  void* operator new(size_t);
  void operator delete(void*);
  void* operator new[](size_t);
  void operator delete[](void*);
 }
 ———-
Date: 2008/4/20

[Internal] @ pp.605
 
 当 operator new 不能分配足够内存时，应该提示出错的状态。
 
 以往的习惯是返回空指针。这样编译器就不会调用构造函数。然后 new 表达式产生空指针，从而客户代
码得知失败。
 
 如今标准的约定是，应该抛出 bad_alloc 异常，从而跳出 operator new， new 表达式也被跳过。客户代码如果处理这种异常，即获得失败状态。
 ———-
Date: 2008/4/20

[Special Members] @ pp.619
 
 构造函数初始化列表(constructor initializer list)在定义构造函数的时候，用来初始化基类(base
 class)和成员对象(member object)。
 
 class Derived2 : public Derived 1 {
 …
 public:
  Derived2(int) : m3(1), Derived1(2), m4(3) {
    …
  }
 …
 };
 ———-
Date: 2008/4/20

[Internal] @ pp.625
 
 类的基类子对象(base class subobject)及成员对象(member object)的初始化顺序是：
 
  * 在每一层，基类的构造函数最先被调用；
  * 然后是成员对象的构造函数，被调用的顺序取决于类内的声明顺序，而不是构造函数的定义。
 
 析构函数的调用顺序与构造函数的调用顺序正好相反。因为要稳定构造和析构过程中的依赖关系。
 ———-
Date: 2008/4/20

[Inheritance] @ pp.625
 
 在子类(derived class)中，对基类(base class)中重名的函数，有两种情况：
 
  * 重定义(redefine)。这个名字被子类重新定义。基类中重名的函数，无论参数和返回类型是什么，都会被隐藏(name hiding)。除非是后一种情况。
  * 覆盖(override)。基类中的虚函数(virtual function)会被子类中的相同参数的函数覆盖。
 
 名字隐藏(name hiding)的原理，详见 pp.627。主要是重用名字则意味着类的设计有问题，可能本该用 composition
 而用了 inheritance。
 ———-
Date: 2008/4/20

[Inheritance] @ pp.633
 
 不会被继承的成员函数，包括
  * 构造函数
  * 析构函数
  * operator=
 
 因为子类(derived class)和基类(base class)在这几个函数上肯定不能相同。
 
 一般子类(derived class)的拷贝构造函数(copy
 constructor)和赋值运算符函数(operator=)都应该调用基类(base
 class)的相应函数（如通过构造函数初始化列表(constructor initializer
 list)）。否则编译器会调用默认构造函数(default constructor)进行拷贝，而对于赋值运算来说，什么也不做。
 
 
 类型转换运算符(cast operator)会被自动继承。仔细想想，既然基类，也就是子类的一个子对象能自动转换，那么子类当然也能自动转换喽。
 
 静态(static)成员函数会被继承。它们遵守相同的隐藏(name
 hiding)规则。静态(static)成员不可能是虚拟的(virtual)，所以不可能被覆盖(override)。
 ———-
Date: 2008/4/21

[Design] @ pp.637
 
 关于使用组合(composition)还是继承(inheritance)一般的设计思路，
 
 is-a: inheritance
 has-a: composition
 ———-
Date: Mon, Apr 21, 2008 at 4:05 PM

[Inheritance] @ pp.640
 
 通过 private 方式继承下来的成员，可以通过下面的方式使其可见，
 
 class Pet {
 public:
  char eat() const { return ‘a’; }
  int speak() const { return 2; }
  float sleep() const { return 3.0; }
  float sleep(int) const { return 4.0; }
 };
 
 class Goldfish : Pet { // Private inheritance
 public:
  Pet::eat; // Name publicizes member
  Pet::sleep; // Both overloaded members exposed
 };
 ———-
Date: 2008/4/21

[Design] @ pp.641
 
 不过终归还是应该谨慎使用 private inheritance。能用 composition 的话更好。
 ———-
Date: 2008/4/21

[Inheritance] @ pp.643
 
 重载的运算符(operator)，除了 operator= 之外，其余的都会被继承。
 
 显然，继承的运算符只是修改基类的子对象。
 ———-
Date: 2008/4/21

[Internal] @ pp.650
 
 总结一下，编译器会自动生成的特殊成员函数(special member)是：
 
  * 默认构造函数 (default constructor)
  * 拷贝构造函数 (copy constructor)
  * 赋值运算符 (operator=)
  * 析构函数 (destructor)
 
 自动生成的拷贝构造函数(copy constructor)和赋值运算符(operator=)，递归调用基类(base
 class)和数据成员(data member)的相应的函数，没有相应的函数的，进行位拷贝(bitwise copy)。
 
 如果定义了拷贝构造函数和赋值运算符，那么编译器不再帮我们做任何事情。如果没处理基类和数据成员，那么在拷贝构造函数(copy
 constructor)中它们的默认构造函数(default
 constructor)将被调用，在赋值运算符(operator=)中什么也不做。所以不要忘了处理基类和数据成员。如，
 
 Child(const Child& c) : Parent(c), i(c.i), m(c.m) {}
 ———-
Date: 2008/4/21

[Inheritance] @ pp.653
 
 向上类型转换(upcast)是类型安全的，因而编译器允许隐式转换。使用的情况如，
 
  * 指针或引用赋值
    Instrument *p = &wind;
    Instrument &r = wind;
  * 指针或引用参数传递
    void func(Instrument &r);
 
 参考 pp.647。
 ———-
Date: 2008/4/22

[C and C++ compared] @ pp.674
 
 C 和 C++ 的参数传递顺序都是从右向左压栈。这样，通过栈帧(stack frame)指针如 ebp + n (n > 0)
 的方式就可以从左向右读取参数了，当然这里可能还有返回地址和返回值等。
 
 这样做主要是为了实现 C 的可变参数(variable argument)函数。
 ———-
Date: 2008/4/22

[Internal] @ pp.676
 
 编译器创建的默认构造函数(default constructor)，其实也不是什么都不做，起码还要初始化 vptr 的。
 ———-
Date: 2008/4/22

[Design] @ pp.680
 
 You create an abstract class when you only want to manipulate a set of
 classes through a common interface, but the common interface doesn’t
 need to have an implementation (or at least, a full implementation).
 
 当需要通过一个通用的接口来操纵一组类，并且这个接口类不需要实现（或者至少不需要完全实现）时，我们使用抽象类。
 ———-
Date: 2008/4/22

[Design] @ pp.683
 
 因为纯虚函数(pure virtual function)使抽象类(abstract
 class)的对象不能被创建，也就迫使函数必须按引用(by
 reference)传递该抽象类，从而也就避免了按值传递引起的对象切割(object slicing)。
 ———-
Date: Tue, Apr 22, 2008 at 9:55 PM

[Virtual Functions] @ pp.684
 
 纯虚函数(pure virtual function)可以被定义。不过不能在类的声明内定义。如，
 
 
 class Pet {
 public:
  virtual void speak() const = 0;
  virtual void eat() const = 0;
  // Inline pure virtual de
finitions illegal:
  //!  virtual void sleep() const = 0 {}
 };
 
 // OK, not defined inline
 void Pet::eat() const {
  cout << "Pet::eat()" << endl;
 }
 
 void Pet::speak() const {
  cout << "Pet::speak()" << endl;
 }
 ———-
Date: 2008/4/22

[Virtual Functions] @ pp.693
 
 尽管在子类(derived class)中覆盖(override)虚函数(virtual
 functions)必须保证参数和返回值（还有修饰符如const等）一致，不过也有个小小的例外：如果基类(base
 class)中的虚函数返回A类的引用（或指针），那么子类中的覆盖可以返回A的子类的引用（或指针），编译器能自动进行向上类型转换(upcast)。如，
 
 class PetFood {
  …
 };
 
 class Pet {
 public:
  virtual string type() const = 0;
  virtual PetFood* eats() = 0;
 };
 
 class Cat : public Pet {
 public:
  …
  class CatFood : public PetFood {
  };
  CatFood* eats() { return &cf; }
 private:
  CatFood cf;
 };
 ———-
Date: 2008/4/22

[Special Members] @ pp.696
 
 不要小看构造函数的隐含调用，可能包括：检查 this 是否为空、基类构造函数的调用、成员对象的初始化、 vptr 的初始化，等等。
 
 所以，构造函数的内联可能引起代码膨胀。不过这些问题可以到代码优化的时候再考虑。
 ———-
Date: 2008/4/22

[Virtual Functions] @ pp.698
 
 构造函数(constructor)中的虚函数(virtual
 function)没有多态性(polymorphism)，换句话说，是静态绑定(early binding)的。
 
 可以这样想，一个类在进入构造函数之前初始化 vptr，这时它无法知道它自己有什么样的子类(derived class)，所以 vptr
 只能指向这个类自己的 vtable。沿着继承关系，子类的构造函数逐个被调用，最后生成的对象的 vptr 才指向它自身类别的 vtable。
 
 既然构造函数中的虚函数没有多态性，多数编译器会优化为静态绑定。
 ———-
Date: 2008/4/23

[Virtual Functions] @ pp.699
 
 析构函数(destructor)中的虚函数(virtual
 function)也没有多态性(polymorphism)。可以这样想，因为对象是自底向上析构的，从基类的析构函数呼叫子类覆盖的函数，实际上是在操作已经被析构了的部分，这显然是错误的。
 
 析构函数(destructor)都应该是虚函数(virtual function)，这样才能保证通过基类指针析构子类对象的时候行为是正常的。
 
 析构函数可以是纯虚函数(pure virtual
 function)，但是一定要给出函数体，因为编译器要调用所有类的析构函数。不过纯虚的析构函数，除了能使类成为抽象类之外，没有额外价值。
 ———-
Date: 2008/4/23

[Inheritance] @ pp.712
 
 dynamic_cast是一个类型安全(type-safe)的向下类型转换(downcast)操作，如果转换失败返回的是空指针。
 
 dynamic_cast使用vtable中的信息来确定对象的实际类型。所以使用dynamic_cast需要对象有vptr。
 
 尽管static_cast不允许跳出类的层次关系，使用静态类型转换终归是有风险的。这种情况还是用dynamic_cast好。
 
 而dynamic_cast被大量使用，是一种设计缺陷。好的设计应该利用多态性(polymorphism)，而不要经常类型转换。
 ———-
Date: 2008/4/23

[Templates] @ pp.731
 
 一些术语：
 
 @ pp.731
 parameterized type
 @ pp.733
 instantiation
 ———-
Date: Wed, Apr 23, 2008 at 11:07 PM

[Templates] @ pp.734
 
 模板类的声明，例如，
 
 template<class T>
 class Array {
  …
  T A[100];
 public:
  T& operator[](int index);
 };
 
 template<class T>
 T& Array<T>::operator[](int index) {
  return A[index];
 }
 ———-
Date: 2008/4/23

[Templates] @ pp.734
 
 一般模板类的声明，包括接口和实现，都应该包含在头文件(header)中。这样编译器才能在实例化(instantiation)的时候，能翻译相应的模板代码。
 
 编译器会通知连接器(linker)，去掉冗余的模板目标代码。
 
 有的编译器（可能是msvc）有一种机制能把实例化的模板代码生成一个动态连接库(dll)，这时模板的实现就应该放在一个单独的cpp源文件中。
 ———-
Date: 2008/4/24

[Design] @ pp.759
 
 迭代器(iterator)的 end() 的惯例是：
  end iterator 应被理解为 end sentinel，换句话说，就是 one past the
 end，因此不应该被解引用(dereference)。
 
 习惯的用法是，
 
  while(start != end)
    cout << start++ << endl;
 ———-
Date: 2008/4/26

[Templates] @ pp.777
 
 只要支持模板函数(function template)中用到的运算，那么函数模板就可以实例化(instantiate)为支持该数据类型的函数。如，
 
 template<class Iter>
 void drawAll(Iter start, Iter end) {
  while(start != end) {
    (*start)->draw();
    start++;
  }
 }
 
 int main() {
  Shape* sarray[] = {
    new Circle, new Square, new Line
  };
 
  // Even works with array pointers:
  drawAll(sarray,
    sarray + sizeof(sarray)/sizeof(*sarray));
 }
 ———-
Date: 2008/4/26

[Design] @ pp.778
 
 迭代器(iterator)的最大价值在于，它提供了一种访问容器(container)类的形式上统一的手段，从而为函数模板(function
 template)，也就是算法(algorithm)的一般化(generic)，提供了基础。