C++编程思想（第1卷）

按有用程度 按页码先后 最新笔记

• 

  第364页

  onesuper (穷则独善其身，达则兼济姑娘)

  /代码内容已省略/ 有了多态，player 可以不必考虑 i 是哪个 instrument，直接调用 i.play() ，i 就会发出它应该发出的声音。但问题时怎么找到 play 的代码段呢？ 如果基类方法不是 virtual， 运行时代码已经确定了，运行到 i.play()，就会自动跳到基类 play 代码段入口。（early binding） 但如果发现基类方法是 virtual，程序还不知道接下去到哪执行？这时会触发编译器进行 late bin... (更多)

  class Instrument {
  public:
       virtual void play() {...}
  }
  
  class Violet : public Instrument {
  public:
      void play() {...}
  }
  
  void player(Instrument& i) {
      i.play();
  }
  
  int main() {
      Violet v;
      tune(v);
  }
  

  有了多态，player 可以不必考虑 i 是哪个 instrument，直接调用 i.play() ，i 就会发出它应该发出的声音。但问题时怎么找到 play 的代码段呢？

  如果基类方法不是 virtual， 运行时代码已经确定了，运行到 i.play()，就会自动跳到基类 play 代码段入口。（early binding）

  但如果发现基类方法是 virtual，程序还不知道接下去到哪执行？这时会触发编译器进行 late binding 来生成对应的代码入口。

  具体方法就是根据对象 v 中保存的 VPTR 指针找到 VTABLE 这张表，入口位于VTABLE[offset]。

  VPTR 和 VTABLE 在对象 violet 实例化的时候已经生成好（violet 已经知道自己是个小提琴= =），直到基类 virtual 函数被调用时才触发索引过程。

  因为虽然 violet 知道自己是个小提琴，但是 player 的代码段不能在编译时确定，如果舍弃多态，那么在编译时就可以绑定，即基类 play 函数代码。

  现在需要在运行时根据传入的对象来确定 player 到底该生成什么样的代码，我到底是拉小提琴还是弹吉他。

  late bingding 比 early binding 多了一个索引的过程，这个过程因为需要编译器的介入，减慢了调用的速度。

  开发效率和程序效率不可兼得，barne 选择了前者，于是乎 c++ 有了 virtual 关键字。 (收起)

  2012-02-08 22:57:20   回应

  收藏

  推荐
• 

  第392页

  onesuper (穷则独善其身，达则兼济姑娘)

  代码复用技术比较 1.c方法： 拷贝原来的代码，然后进行修改 = = 2.smalltalk方法： 继承类型树上和要实现的那个类最近的那个类，而不能随意创建 3.c++方法 模板，由编译完成参数代换 (更多)

  代码复用技术比较

  1.c方法：

  拷贝原来的代码，然后进行修改 = =

  2.smalltalk方法：

  继承类型树上和要实现的那个类最近的那个类，而不能随意创建

  3.c++方法

  模板，由编译完成参数代换 (收起)

  2012-02-08 20:57:24   回应

  收藏

  推荐
• 

  第310页

  onesuper (穷则独善其身，达则兼济姑娘)

  为什么不能 delete void* ？ delete需要知道指针的类型，在释放内存之前，调用改类型的析构函数（这也是c++引进delete的根本原因） 该析构函数中可能又有对其它资源的 delete 操作，如果不调用就会泄露内存。 而在 C 中，所有结构体的 initialize 和 destroy 都需要程序员自己调用，增加了出错的可能性。 (更多)

  为什么不能 delete void* ？

  delete需要知道指针的类型，在释放内存之前，调用改类型的析构函数（这也是c++引进delete的根本原因）

  该析构函数中可能又有对其它资源的 delete 操作，如果不调用就会泄露内存。

  而在 C 中，所有结构体的 initialize 和 destroy 都需要程序员自己调用，增加了出错的可能性。 (收起)

  2012-02-05 16:49:07   回应

  收藏

  推荐

• 

  第114页

  onesuper (穷则独善其身，达则兼济姑娘)

  C的缺陷：include头文件来声明函数，名字冲突……而且每次调用的时候都要传一个结构体指针 作者又接着调侃C的弱类型：在C中，我们常常发现能使程序通过编译，然后我们必须再花力气使它工作。 (更多)

  C的缺陷：include头文件来声明函数，名字冲突……而且每次调用的时候都要传一个结构体指针

  作者又接着调侃C的弱类型：

  在C中，我们常常发现能使程序通过编译，然后我们必须再花力气使它工作。

  (收起)

  2011-12-16 15:08:10   回应

  收藏

  推荐
• 

  第142页

  onesuper (穷则独善其身，达则兼济姑娘)

  c++ class的访问保护检查是在编译阶段完成的，访问控制信息（哪些成员是private，哪些是public）不会传递给连接器，程序在运行期间也不会做检查。 (更多)

  c++ class的访问保护检查是在编译阶段完成的，访问控制信息（哪些成员是private，哪些是public）不会传递给连接器，程序在运行期间也不会做检查。 (收起)

  2012-01-12 20:27:29   回应

  收藏

  推荐
• 

  第144页

  onesuper (穷则独善其身，达则兼济姑娘)

  这里作者介绍了一种减少重复编译的技术：句柄类。 不适用句柄类： 接口代码 /代码内容已省略/ 实现代码 /代码内容已省略/ 客户端代码 /代码内容已省略/ 因为在公共接口中定义了B，导致每一次对B进行修改以后，客户端代码都要进行重新编译（B的定义改变后，客户端中A重新定义以后的对象大小必然也改变，因.. (更多)

  这里作者介绍了一种减少重复编译的技术：句柄类。

  不适用句柄类：

  接口代码

  // A.h 
  class A {
      struct  B {
          int i;
      } *b; // 嵌套定义的私有成员b是一个指向B的指针
  public:
      void method1();
      void method1();
  }
  

  实现代码

  // A.cpp
  void A::method1() {
      //do something
  }
  
  void A::method2() {
      //do something
  }
  

  客户端代码

  #include "A.h"
  int main() {
      A a;
      a.method1();
      a.method2();
  }
  

  因为在公共接口中定义了B，导致每一次对B进行修改以后，客户端代码都要进行重新编译（B的定义改变后，客户端中A重新定义以后的对象大小必然也改变，因为在A中嵌套定义了B的结构，因此A的结构随B而变）。解决方法是在接口部分只保留一个B类型的指针，把类的定义放到实现代码中。

  使用了句柄类：

  接口代码

  // A.h 
  class A {
      struct B; //仅仅声明
      B* b;      //因为A中的成员变量只是一个指针，大小由机器决定，因此在客户端中每次定义以后的大小都相同，无需重新编译
  public:
      void method1();
      void method1();
  }
  

  实现代码

  // A.cpp
  struct A::B {
      int i;
  }
  
  void A::method1() {
      //do something
  }
  
  void A::method2() {
      //do something
  }
  

  (收起)

  2012-01-12 20:38:09   回应

  收藏

  推荐

• 

  第364页

  onesuper (穷则独善其身，达则兼济姑娘)

  /代码内容已省略/ 有了多态，player 可以不必考虑 i 是哪个 instrument，直接调用 i.play() ，i 就会发出它应该发出的声音。但问题时怎么找到 play 的代码段呢？ 如果基类方法不是 virtual， 运行时代码已经确定了，运行到 i.play()，就会自动跳到基类 play 代码段入口。（early binding） 但如果发现基类方法是 virtual，程序还不知道接下去到哪执行？这时会触发编译器进行 late bin... (更多)

  class Instrument {
  public:
       virtual void play() {...}
  }
  
  class Violet : public Instrument {
  public:
      void play() {...}
  }
  
  void player(Instrument& i) {
      i.play();
  }
  
  int main() {
      Violet v;
      tune(v);
  }
  

  有了多态，player 可以不必考虑 i 是哪个 instrument，直接调用 i.play() ，i 就会发出它应该发出的声音。但问题时怎么找到 play 的代码段呢？

  如果基类方法不是 virtual， 运行时代码已经确定了，运行到 i.play()，就会自动跳到基类 play 代码段入口。（early binding）

  但如果发现基类方法是 virtual，程序还不知道接下去到哪执行？这时会触发编译器进行 late binding 来生成对应的代码入口。

  具体方法就是根据对象 v 中保存的 VPTR 指针找到 VTABLE 这张表，入口位于VTABLE[offset]。

  VPTR 和 VTABLE 在对象 violet 实例化的时候已经生成好（violet 已经知道自己是个小提琴= =），直到基类 virtual 函数被调用时才触发索引过程。

  因为虽然 violet 知道自己是个小提琴，但是 player 的代码段不能在编译时确定，如果舍弃多态，那么在编译时就可以绑定，即基类 play 函数代码。

  现在需要在运行时根据传入的对象来确定 player 到底该生成什么样的代码，我到底是拉小提琴还是弹吉他。

  late bingding 比 early binding 多了一个索引的过程，这个过程因为需要编译器的介入，减慢了调用的速度。

  开发效率和程序效率不可兼得，barne 选择了前者，于是乎 c++ 有了 virtual 关键字。 (收起)

  2012-02-08 22:57:20   回应

  收藏

  推荐
• 

  第392页

  onesuper (穷则独善其身，达则兼济姑娘)

  代码复用技术比较 1.c方法： 拷贝原来的代码，然后进行修改 = = 2.smalltalk方法： 继承类型树上和要实现的那个类最近的那个类，而不能随意创建 3.c++方法 模板，由编译完成参数代换 (更多)

  代码复用技术比较

  1.c方法：

  拷贝原来的代码，然后进行修改 = =

  2.smalltalk方法：

  继承类型树上和要实现的那个类最近的那个类，而不能随意创建

  3.c++方法

  模板，由编译完成参数代换 (收起)

  2012-02-08 20:57:24   回应

  收藏

  推荐
• 

  第310页

  onesuper (穷则独善其身，达则兼济姑娘)

  为什么不能 delete void* ？ delete需要知道指针的类型，在释放内存之前，调用改类型的析构函数（这也是c++引进delete的根本原因） 该析构函数中可能又有对其它资源的 delete 操作，如果不调用就会泄露内存。 而在 C 中，所有结构体的 initialize 和 destroy 都需要程序员自己调用，增加了出错的可能性。 (更多)

  为什么不能 delete void* ？

  delete需要知道指针的类型，在释放内存之前，调用改类型的析构函数（这也是c++引进delete的根本原因）

  该析构函数中可能又有对其它资源的 delete 操作，如果不调用就会泄露内存。

  而在 C 中，所有结构体的 initialize 和 destroy 都需要程序员自己调用，增加了出错的可能性。 (收起)

  2012-02-05 16:49:07   回应

  收藏

  推荐