【C++进阶】深入理解C/C++(3)

【C++进阶】深入理解C/C++(3)

第二位候选者表现不错，那么，相比大多数程序员，他还有什么潜力没有被挖掘呢？

可以从以下几个角度去考察：

有关平台的问题—32位与64位的编程经验；

内存对齐；

CPU以及内存优化；

C语言的精髓；

 

接下来，主要分享一下以下相关内容：

内存模型；

优化；

C语言之精髓；

 

 

内存模型：

静态存储区（static storage）：如果一个对象的标识符被声明为具有内部链接或是外部链接，或是存储类型说明符是static，那么这个对象具有静态生存期。这个对象的生命周期是整个程序的运行周期。

PS：内部链接，也就是编译单元内可见，是需要使用static来修饰的，连接程序不可见；外部链接，是指别的编译单元可见，也就是链接程序可见。我这里还不太清楚为什么需要三种情况来说明。

 int* immortal(void)
 {
     static int storage = 42;
     return &storage;
 }

 

自动存储区（automatic storage）：如果一个对象没有被指明是内部链接还是外部链接，并且也没有static修饰，那么，这个对象具有自动生存期，也称之为本地生存期。一般使用auto说明符来修饰，只在块内的变量声明中允许使用，这样是默认的情况，因此，很少看到auto说明符。简单地说，自动存储区的变量，在一对{}之间有效。

 int* zombie(void)
 {
     auto int storage = 42;
     return &storage;
 }

分配的存储区域（allocated storage）：调用calloc函数，malloc函数，realloc函数分配的内存，称之为分配的存储区域。他们的作用域（生命周期会是更好的术语吗？）在分配和释放之间。

 

 int* finite(void)
 {
     int* ptr = malloc(sizeof(int*));
     *ptr = 42;
     return ptr;
 }

 

优化相关：

一般来说，编译的时候，你都应该打开优化选项。强制编译器更努力的去发现更多的潜在的问题。

上面，同样地代码，打开优化选项的编译器得到了警告信息：a 没有初始化。

  

C语言的精髓：

C语言的精髓体现在很多方面，但其本质在于一种社区情感（communitysentiment），这种社区情感建立在C语言的基本原则之上。

C语言原理简介：

1、  相信程序员；

2、  保持语言简单精炼；

3、  对每一种操作，仅提供一种方法；(译者注：？)

4、  尽可能的快，但不保证兼容性；

5、  保持概念上的简单；

6、  不阻止程序员做他们需要做的事。

  

 

现在来考察一下我们的候选者关于C++的知识：）

 

你：1到10分，你觉得你对C++的理解可以打几分？

第一个候选者：我觉得我可以打8到9分。

第二个候选者：4分，最多也就5分了。我还需要多加学习C++。

这时，C++之父Bjarne Stroustrup在远方传来声音：我觉得我可以打7分。(OH,MY GOD!!)

 

那么，下面的代码段，会输出什么？

 #include <iostream>

 struct X
 {
     int a;
     char b;
     int c;
 };

 int main(void)
 {
     std::cout << sizeof(X) << std::endl;
 }

 

第二个候选者：这个结构体是一个朴素的结构体（POD：plain old data），C++标准保证在使用POD的时候，和C语言没有任何区别。因此，在你的机器上（64位机器，运行在32位兼容模式下），我觉得会输出12.

顺便说一下，使用func(void)而不是用func()显得有点诡异，因为C++中，void是默认情况，这个相对于C语言的默认是任意多的参数，是不一样的。这个规则同样适用于main函数。当然，这不会带来什么伤害。但这样的代码，看起来就像是顽固的C程序员在痛苦的学习C++的时候所写的。下面的代码，看起来更像C++：

 #include <iostream>

 struct X
 {
     int a;
     char b;
     int c;
 };

 int main()
 {
     std::cout << sizeof(X) << std::endl;
 }

 

第一个候选者：这个程序会打印12.

你：好。如果我添加一个成员函数，会怎么样？比如：

 #include <iostream>

 struct X
 {
     int a;
     char b;
     int c;

     void set_value(int v) { a = v; }
 };

 int main()
 {
     std::cout << sizeof(X) << std::endl;
 }

第一个候选者：啊？C++中可以这样做吗？我觉得你应该使用类(class)。

你：C++中，class和struct有什么区别？

候选者：在一个class中，你可以有成员函数，但是我不认为在struct中可以拥有成员函数。莫非可以？难道是默认的访问权限不同？（Is it the default visibility that is different?）

不管怎样，现在程序会输出16.因为，会有一个指针指向这个成员函数。

你：真的？如果我多增加两个函数呢？比如：

 #include <iostream>

 struct X
 {
     int a;
     char b;
     int c;

     void set_value(int v) { a = v; }
     int get_value() { return a; }
     void increase_value() { a++; }
 };

 int main()
 {
     std::cout << sizeof(X) << std::endl;
 }

第一个候选者：我觉得对打印24，多了两个指针？

你：在我的机器上，打印的值比24小。

候选者：啊！对了，当然，这个struct有一个函数指针的表，因此他仅仅需要一个指向这个表的指针！我确实对此有一个很深的理解，我差点忘记了，呵呵。

你：事实上，在我的机器上，这段代码输出了12.

候选者心里犯嘀咕：哦？可能是某些诡异的优化措施在捣鬼，可能是因为这些函数永远不会被调用。

 

你对第二个候选者说：你怎么想的？

第二个候选者：在你的机器上？我觉得还是12？

你：好，为什么？

候选者：因为以这种方式来增加成员函数，不会增加struct的所占内存的大小。对象对他的函数一无所知，反过来，是函数知道他具体属于哪一个对象。如果你把这写成C语言的形式，就会变得明朗起来了。

你：你是指这样的？

 struct X
 {
     int a;
     char b;
     int c;
 };

 void set_value(struct X* this, int v) { this->a = v; }
 int get_value(struct X* this) { return this->a; }
 void increase_value(struct X* this) { this->a++; }

第二个候选者：恩。就想这样的。现在很明显很看出，类似这样的函数是不会增加类型和对象的内存大小的。

 

你：那么现在呢？

 #include <iostream>

 struct X
 {
     int a;
     char b;
     int c;

     virtual void set_value(int v) { a = v; }
     int get_value() { return a; }
     void increase_value() { a++; }
 };

 int main()
 {
     std::cout << sizeof(X) << std::endl;
 }

//注意改变：第一个成员函数变成了虚函数。

第二个候选者：类型所占用的内存大小很有可能会增加。C++标准没有详细说明虚类（virtual class）和重载（overriding）具体如何实现。但是一般都是维护一个虚函数表，因此你需要一个指针指向这个虚函数表。所以，这种情况下会增加8字节。这个程序是输出20吗？

你：我运行这段程序的时候，得到了24.

候选者：别担心。极有可能是某些额外的填充，以便对齐指针类型（之前说的内存对齐问题）。

你：不错。再改一下代码。

 #include <iostream>

 struct X
 {
     int a;
     char b;
     int c;

     virtual void set_value(int v) { a = v; }
     virtual int get_value() { return a; }
     virtual void increase_value() { a++; }
 };

 int main()
 {
     std::cout << sizeof(X) << std::endl;
 }

现在会发生什么？

第二个候选者：依旧打印24.每一个类，只有一个虚函数表指针的。

你：恩。什么是虚函数表？

候选者：在C++中，一般使用虚函数表技术来支持多态性。它基本上就是函数调用的跳转表（jump table），依靠虚函数表，在继承体系中，你可以实现函数的重载。

 

让我们来看看另一段代码：

 #include "B.hpp"

 class A {
     public:
       A(int sz) { sz_ = sz; v = new B[sz_]; }
       ~A() { delete v; }
       //...
     private:
       //...
       B* v;
       int sz_;
 };

看看这段代码。假设我是一名资深的C++程序员，现在要加入你的团队。我向你提交了这么个代码段。请从学术的层面，尽可能详细轻柔的给我讲解这段代码可能存在的陷阱，尽可能的跟我说说一些C++的处理事情的方式。

第一个候选者：这是一段比较差的代码。这是你的代码？首先，不要使用两个空格来表示缩进。还有class A后面的大括号要另起一行。sz_？我从来没见过如此命名的。你应该参照GoF标准_sz或且微软标准m_sz来命名。（GoF标准？）

你：还有呢？

候选者：恩？你是不是觉得在释放一个数组对象的时候，应该使用delete []来取代delete？说真的，我的经验告诉我，没必要。现代的编译器可以很好的处理这个事情。

你：好？有考虑过C++的“rule of three“原则吗？你需要支持或是不允许复制这一类对象吗？

PS：

（来自维奇百科http://en.wikipedia.org/wiki/Rule_of_three_(C%2B%2B_programming)）

The rule of three (also known asthe Law of The Big Three or The Big Three) is a rule of thumb in C++ that claimsthat if a class defines one of the following itshould probably explicitly define all three:

§  destructor

§  copy constructor

§  assignment operator

也就是说，在C++中，如果需要显式定义析构函数、拷贝构造函数、赋值操作符中的一个，那么通常也会需要显式定义余下的两个。

 

第一个候选者：恩。无所谓了。听都没听说过tree-rule。当然，如果用户要拷贝这一类对象的话，会出现问题。但是，这也许就是C++的本质，给程序员无穷尽的噩梦。

顺便说一下，我想你应该知道哎C++中所有的析构函数都应该定义为virtual函数。我在一些书上看到过这个原则，这主要是为了防止在析构子类对象时候出现内存泄露。

你心里嘀咕：或是类似的玩意。Another ice cream perhaps?（我还是没搞明白这到底哪门情感）

 

令人愉悦的第二个候选者登场了：）

 

候选者：哦，我该从何说起呢？先关注一些比较重要的东西吧。

首先是析构函数。如果你使用了操作符new[]，那么你就应该使用操作符delete[]进行析构。使用操作符delete[]的话，在数组中的每一个对象的析构函数被调用以后，所占用的内存会被释放。例如，如果像上面的代码那样写的话，B类的构造函数会被执行sz次，但是析构函数仅仅被调用1次。这个时候，如果B类的构造函数动态分配了内存，那么就是造成内存泄漏。

接下类，会谈到“rule of three”。如果你需要析构函数，那么你可能要么实现要么显式禁止拷贝构造函数和赋值操作符。由编译器生成的这两者中任何一个，很大可能不能正常工作。

还有一个小问题，但是也很重要。通常使用成员初始化列表来初始化一个对象。在上面的例子中，还体现不出来这样做的重要性。但是当成员对象比较复杂的时候，相比让对象隐式地使用默认值来初始化成员，然后在进行赋值操作来说，使用初始化列表显式初始化成员更为合理。

先把代码修改一下：）然后再进一步阐述问题。

你改善了一下代码，如下： 

 #include "B.hpp"

 class A
 {
     public:
       A(int sz) { sz_ = sz; v = new B[sz_]; }
       ~A() { delete[] v; }
       //...
     private:
       A(const A&);
       A& operator=(const A&);
       //...
       B* v;
       int sz_;
 };

这个时候，这位候选者（第二个）说：好多了。

你进一步改进，如下：

 #include "B.hpp"

 class A
 {
     public:
       A(int sz) { sz_ = sz; v = new B[sz_]; }
       virtual ~A() { delete[] v; }
       //...
     private:
       A(const A&);
       A& operator=(const A&);
       //...
       B* v;
       int sz_;
 };

 

第二位候选者忙说道：别着急，耐心点。

接着他说：在这样的一个类中，定义一个virtual的析构函数，有什么意义？这里没有虚函数，因此，如果以此作为基类，派生出一个类，有点不可理喻。我知道是有一些程序员把非虚类作为基类来设计继承体系，但是我真的觉得他们误解了面向对象技术的一个关键点。我建议你析构函数的virtual说明符去掉。virtual这个关键字，用在析构函数上的时候，他有这么个作用：指示这个class是否被设计成一个基类。存在virtual，那么表明这个class应该作为一个基类，那么这个class应该是一个virtual class。

还是改一下初始化列表的问题吧：）

 

于是代码被你修改为如下： 

 #include "B.hpp"

 class A
 {
     public:
       A(int sz):sz_(sz), v(new B[sz_]) { }
       ~A() { delete[] v; }
       //...
     private:
       A(const A&);
       A& operator=(const A&);
       //...
       B* v;
       int sz_;
 };

 

第二个候选者说：恩，有了初始化列表。但是，你有没有注意到由此有产生了新的问题？

你编译的时候使用了-Wall选项吗？你应该使用-Wextra、-pedantic还有-Weffc++选项。如果没有警告出现，你可能没有注意到这里发生的错误。但是如果你提高了警告级别，你会发现问题不少。

一个不错的经验法则是：总是按照成员被定义的顺序来书写初始化列表，也就是说，成员按照自己被定义的顺序来呗初始化。在这个例子中，当v(new B[sz_])执行的时候，sz_还没有被定义。然后，sz_被初始化为sz。

事实上，C++代码中，类似的事情太常见了。

 

你于是把代码修改为：

 #include "B.hpp"

 class A
 {
     public:
       A(int sz):v(new B[sz]), sz_(sz) { }
       ~A() { delete[] v; }
       //...
     private:
       A(const A&);
       A& operator=(const A&);
       //...
       B* v;
       int sz_;
 };

第二个候选者：现在好多了。还有什么需要改进的吗？接下来我会提到一些小问题。。。

在C++代码中，看到一个光秃秃的指针，不是一个好的迹象。很多好的C++程序员都会尽可能的避免这样使用指针。当然，例子中的v看起来有点像STL中的vector，或且差不多类似于此的东西。

对于你的私有变量，你貌似使用了一些不同的命名约定。在此，我的看法是，只要这些变量是私有的，你爱怎么命名就怎么命名。你可以使得你的变量全部以_作为后缀，或且遵循微软命名规范，m_作为前缀。但是，请你不要使用_作为前缀来命名你的变量，以免和C语言保留的命名规范、Posix以及编译器的命名规则相混淆：）

 

（待续）

转自：http://blog.csdn.net/rockics/article/details/7036312