午夜精品久久久久,日韩午夜免费,一区二区三区免费网站

Sequoiadb与spark�Ҏ��步骤

Tue, 26 May 2015 09:13:00 GMT

hive.aux.jars.path file:///ocsdev/hadoop/apache-hive-1.1.0-bin/lib/hive-sequoiadb-apache.jar,file:///ocsdev/hadoop/apache-hive-1.1.0-bin/lib/sequoiadb.jar Sequoiadb store handler jar file

RDD初探

Sat, 18 Apr 2015 14:16:00 GMT

RDD初探 RDD�Q�resilient distributed dataset �Q�是Spark提出的一个创新性的概念�Q�它提供了�ƈ行计��个阶段中数据的有效�׃�n�Q��I补了MapReduce中的不��。与MapReduce单乏的Map和Reduce相比�Q�在RDD上，Spark提供了丰富的操作�Q�可以让�E�序开发�h员利用RDD接口非常�Ҏ��的编写出复杂的数据处理程序，先见见Spark版本的WordCount�E�序�Q? 仅仅两行代码�Q�相比MapReduce�Q�是不是��z�了很多�Q? 官网RDD的定义： Spark revolves around the concept of a resilient distributed dataset (RDD), which is a fault-tolerant collection of elements that can be operated on in parallel. There are two ways to create RDDs: parallelizing an existing collection in your driver program, or referencing a dataset in an external storage system, such as a shared filesystem, HDFS, HBase, or any data source offering a Hadoop InputFormat. RDD的特性： 1.分区的数据集 2.只读的数据集 3.只能从driver�E�序中已有的集合或外部存储进行创�? 4.定w��的，��p�|自动的快速重�? 分区分区�Q�RDD是一个分区的数据集，其分区的多少军_��着对这个RDD�q�行�q�行计算的粒度，在Spark中，每一个分区的计算在一个单独的��d��中执行。对RDD的分��言�Q�用户可以指定其分区的数目；如果没有�Q�系�l�将会��用默认��|��默认情况下，其分区数��个程序所分配到的资源的CPU核的数目�Q�如�Q? 指定分区�? 默认分区敎ͼ� 位置优先在Spark中，�U�性着�q�么一�U�思想�Q?#8220;�U�d��数据不如�U�d��计算”�Q�在Spark��d��调度的时候，��L��可能的��Q务分配到数据块存储的位置。如�Q�对HDFS文�g生成的RDD�Q�preferredLocation接口�q�回其每块数据所在的机器名或IP�Q�在后箋的�Q务调度中�Q�调度器��尽可能的将计算��d��分配到数据存储的位置�Q�如�Q? RDD依赖关系可以��_��RDD依赖关系是Spark��d��调度最�Ҏ��的依据�? 在RDD的�{换过�E�中�Q�每�ơ�{换都会生成一个新的RDD�Q�在用户�E�序中，对于某个RDD往往会有一�p�d��的复杂的转换�Q�这��P��Ş成了一条类似流水线��L��前后依赖关系�? 在Spark中，存在两种�c�d��的依赖，即窄依赖和宽依赖�Q? 窄依赖�Q�父RDD的每一个分区只被子RDD的一个分区所使用�Q�如�Q�map、filter�{�； 宽依赖�Q�父RDD的每一个分区只被子RDD的多个分区所使用�Q�如�Q�groupbyKey�{�；区分两种依赖的原因： 1.�H�依赖可以在集群的一个节点上如流水一般的执行�Q�无需物化很多无用的中间RDD�Q�大大提升了计算性能�Q? 2.�H�依赖对于节点计��失败后的恢复会更加有效�Q�只要重新计��其对应父RDD的相应分区即可； RDD操作 RDD支持两种操作 Transformations�Q�从一个已存的RDD生成一个新的RDD�Q�如map操作 Action�Q�执行一�ơ计��ƈ��相应的计算�l�果�q�回值driver�E�序�Q�如reduce 在Spark中，所有的Transformation都是惰性的�Q�他们只会记录其相应的依赖关�p�，而不会马上计��其�l�果�Q�只有在action要求计算�l�果时才会实际计��RDD的倹{�? Spark提供了丰富的RDD操作�Q�详�l�参�? http://spark.apache.org/docs/latest/api/scala/index.html#org.apache.spark.rdd.RDD RDD的持久化在Spark中，�q�有一个最重要的特性就是RDD的持久化。当你对一个RDD�q�行持久化操作时�Q�spark会将该RDD的每个分区的�W�一�ơ计��结果保存在相应的存储介质中。之后对该RDD的访问可以直接访问其存储的结果，�q�样我们可以��一些访问比较频�J�的RDD�q�行持久化到内存中来�Q�加快程序的处理旉��Q�官�|�提供的数据旉��常会加快速度10倍以上） RDD的持久化通过persist() �?cache() �Ҏ��实现�Q?

天边�?/a> 2015-04-18 22:16 发表评论

[转]The Biggest Changes in C++11

Sun, 05 May 2013 13:26:00 GMT

http://coolshell.cn/articles/5265.html

源文章来自前C++标准委员会的 Danny Kalev �?nbsp;The Biggest Changes in C++11 (and Why You Should Care)�Q�赖勇浩做了一�?a target="_blank">中文��译在这�?/a>。所以，我就不翻译了�Q�我在这里仅�Ҏ��中提到的�q�些变化“�q�问��Z��么要引入�q�些变化”的一个探讨，只有知道��Z��什么，用在什么地方，我们才能真正学到�q�个知识。而以此你可以更深入地了解�q�些变化。所以，本文不是��译。因为写得有些仓促，所以难免有问题�Q�还请大家指正�?/p>

Lambda 表达�?/h4>
Lambda表达式来源于函数式编�E�，说白��׃��是在��用的地方定义函数�Q�有的语�a��?#8220;闭包”�Q�如�?lambda 函数没有传回�?例如 `void` )�Q�其回返�c�d��可被完全忽略�?定义在与 lambda 函数相同作用域的变量参考也可以被��用。这�U�的变量集合一般被�U�C�� closure�Q�闭包）。我在这里就不再讲这个事了。表辑ּ�的简单语法如下，

1

`[capture](parameters)->return_type {body}`

原文的作者给��Z��下面的例子：

1

2

3

4

5

6

7

8

9

10

`int` `main()`

`{`

   `char` `s[]="Hello World!";`

   `int` `Uppercase = 0;` `//modified by the lambda`

   `for_each(s, s+sizeof(s), [&Uppercase] (char` `c) {`

    `if` `(isupper(c))`

     `Uppercase++;`

    `});`

`cout << Uppercase <<` `" uppercase letters in: "` `<< s <`
`}`

在传�l�的STL中for_each() �q�个玩意最后那个参数需要一�?#8220;函数对象”�Q�所谓函数对象，其实是一个class�Q�这个class重蝲了operator()�Q�于是这个对象可以像函数的式��L��使用。实��C��个函数对象�ƈ不容易，需要��用template�Q�比如下面这个例子就是函数对象的��单例子（实际的实现远比这个复杂）�Q?/p>

1

2

3

4

5

6

7

8

9

`template` `<class` `T>`

`class` `less`

`{`

`public:`

    `bool` `operator()(const` `T&l,` `const` `T&r)const`

    `{`

        `return` `l < r;`

    `}`

`};`

所以，C++引入Lambda的最主要原因��是1�Q�可以定义匿名函敎ͼ�2�Q�编译器会把其�{成函数对�?/strong>。相信你会和我一��P��会疑问�ؓ什么以前STL中的ptr_fun()�q�个函数对象不能用？�Q�ptr_fun()��是把一个自然函数�{成函数对象的�Q�。原因是�Q�ptr_fun() 的局限是其接收的自然函数只能�?�?个参数�?/p>
那么�Q�除了方便外�Q��ؓ什么一定要使用Lambda呢？它比传统的函数或是函数对象有什么好处呢�Q�我个�h所理解的是�Q�这�U�函��C��q�以�?#8220;闭包”�Q�就是因为其限制了别人的讉K��Q�更�U�有。也可以认�ؓ他是一�ơ性的�Ҏ��。Lambda表达式应该是��z�的�Q�极�U�有的，��Z��更易的代码和更方便的�~�程�?/p>

自动�c�d��推导 auto

在这一节中�Q�原文主要介�l�了两个关键�?auto �?deltype�Q�示例如下：

1

2

3

4

auto x=0; //x has type int because 0 is int

auto c='a'; //char

auto d=0.5; //double

auto national_debt=14400000000000LL;//long long

auto 最大的好处��是让代码简�z�，��其是那些模板类的声明，比如�Q�STL中的容器的�P代子�c�d��?/p>

1

vector<int>::const_iterator ci = vi.begin();

可以变成�Q?/p>

1

auto ci = vi.begin();

模板�q�个�Ҏ��让C++的代码变得很难读�Q�不信你可以看看STL的源码，那是一个�ؕ啊。��用auto必需一个初始化��|��~�译器可以通过�q�个初始化值推导出�c�d��。因为auto是来��化模板类引入的代码难�ȝ��问题�Q�如上面的示例，iteration�q�种�c�d��最适合用auto的，但是�Q�我们不应该把其滥用�?/p>
比如下面的代码的可读性就降低了。因为，我不知道ProcessData�q�回什么？int? bool? �q�是对象�Q�或是别的什么？�q�让你后面的�E�序不知道怎么做�?/p>

1

auto obj = ProcessData(someVariables);

但是下面的程序就没有问题�Q�因为pObject的型别在后面的new中有了�?/p>

1

auto pObject = new SomeType::SomeOtherType();

自动化推�?decltype

关于 decltype 是一个操作符�Q�其可以评估括号内表辑ּ�的类型，其规则如下：

如果表达式e是一个变量，那么��是�q�个变量的类型�?/li>
如果表达式e是一个函敎ͼ�那么��是�q�个函数�q�回值的�c�d��?/li>
如果不符�?�?�Q�如果e是左��|��c�d��为T�Q�那么decltype(e)是T&�Q�如果是叛_��|��则是T�?/li>

原文�l�出的示例如下，我们可以看到�Q�这个让的确我们的定义变量省了很多事�?/p>

1

2

3

const vector<int> vi;

typedef decltype (vi.begin()) CIT;

CIT another_const_iterator;

�q�有一个适合的用法是用来typedef函数指针�Q�也会省很多事。比如：

1

2

3

decltype(&myfunc) pfunc = 0;

typedef decltype(&A::func1) type;

auto �?decltype 的差别和关系

Wikipedia 上是�q�么说的�Q�关于decltype的规则见上）

1

2

3

4

5

6

7

8

9

10

11

12

13

14

#include

int main()

{

    const std::vector<int> v(1);

    auto a = v[0];        // a 的类型是 int

    decltype(v[0]) b = 1; // b 的类型是 const int&, 因�ؓ函数的返回类型是

                          // std::vector::operator[](size_type) const

    auto c = 0;           // c 的类型是 int

    auto d = c;           // d 的类型是 int

    decltype(c) e;        // e 的类型是 int, 因�ؓ c 的类型是int

    decltype((c)) f = c; // f 的类型是 int&, 因�ؓ (c) 是左�?/code>
    decltype(0) g;        // g 的类型是 int, 因�ؓ 0 是右�?/code> }

如果auto �?decltype 在一起��用会是什么样子？能看下面的示例，下面�q�个�C�Z��也是引入decltype的一个原�?#8212;—让C++有能力写一�?“ forwarding function 模板”�Q?/p>

1

2

3

template< typename LHS, typename RHS>

  auto AddingFunc(const LHS &lhs, const RHS &rhs) -> decltype(lhs+rhs)

{return lhs + rhs;}

�q�个函数模板看�v来相当费解，其用��C��auto �?decltype 来扩展了已有的模板技术的不��。怎么个不��_��Q�在上例中，我不知道AddingFunc会接收什么样�c�d��的对象，�q�两个对象的 + 操作�W�返回的�c�d��也不知道�Q�老的模板函数无法定义AddingFunc�q�回值和�q�两个对象相加后的返回值匹配，所以，你可以��用上�q�的�q�种定义�?/p>
�l�一的初始化语法

C/C++的初始化的方法比较，C++ 11 用大括号�l�一了这些初始化的方法�?/p>
比如�Q�POD的类型�?/p>

1

2

int arr[4]={0,1,2,3};

struct tm today={0};

关于POD相说两句�Q�所谓POD��是Plain Old Data�Q�当class/struct�?em>极简�?trivial)、属�?em>标准布局(standard-layout)�Q�以及他的所有非静态（non-static�Q�成员都是POD�Ӟ��会被视�ؓPOD。如�Q?/p>

1

2

3

struct A { int m; }; // POD

struct B { ~B(); int m; }; // non-POD, compiler generated default ctor

struct C { C() : m() {}; ~C(); int m; }; // non-POD, default-initialising m

POD的初始化有点怪，比如上例�Q�new A; 和new A(); 是不一��L��Q�对于其内部的m�Q�前者没有被初始化，后者被初始化了�Q�不�?的编译器行�ؓ不一��P��VC++和GCC不一��P��。而非POD的初始化�Q�则都会被初始化�?/p>
从这点可以看出，C/C++的初始化问题很奇怪，所以，在C++ 2011版中��做了统一。原文作者给��Z��如下的示例：

1

2

3

4

5

6

7

8

9

C c {0,0}; //C++11 only. 相当�? C c(0,0);

int* a = new int[3] { 1, 2, 0 }; /C++11 only

class X {

    int a[4];

    public:

        X() : a{1,2,3,4} {} //C++11, member array initializer

};

容器的初始化�Q?/p>

1

2

3

4

5

// C++11 container initializer

vector vs={ "first", "second", "third"};

map singers =

{ {"Lady Gaga", "+1 (212) 555-7890"},

{"Beyonce Knowles", "+1 (212) 555-0987"}};

�q�支持像Java一��L��成员初始化：

1

2

3

4

5

6

class C

{

   int a=7; //C++11 only

public:

   C();

};

Delete �?Default 函数

我们知道C++的编译器在你没有定义某些成员函数的时候会�l�你的类自动生成�q�些函数�Q�比如，构造函敎ͼ�拯��构造，析构函数�Q�赋值函数。有些时候，我们不想要这些函敎ͼ�比如�Q�构造函敎ͼ�因�ؓ我们惛_��实现单例模式。传�l�的做法是将其声明成private�c�d��?/p>
在新的C++中引入了两个指示�W�，delete意�ؓ告诉�~�译器不自动产生�q�个函数�Q�default告诉�~�译器��生一个默认的。原文给��Z��下面两个例子�Q?/p>

1

2

3

4

5

struct A

{

    A()=default; //C++11

    virtual ~A()=default; //C++11

};

再如delete

1

2

3

4

5

6

7

struct NoCopy

{

    NoCopy & operator =( const NoCopy & ) = delete;

    NoCopy ( const NoCopy & ) = delete;

};

NoCopy a;

NoCopy b(a); //compilation error, copy ctor is deleted

�q�里�Q�我惌��一下，��Z��么我们需要default�Q�我什么都不写不就是default吗？不全然是�Q�比如构造函敎ͼ�因�ؓ只要你定义了一个构造函敎ͼ��~�译器就不会�l�你生成一个默认的了。所以，��Z��要让默认的和自定义的共存�Q�才引入�q�个参数�Q�如下例所�C�：

1

2

3

4

5

struct SomeType

{

SomeType() = default; // 使用�~�译器生成的默认构造函�?/code>
SomeType(OtherType value); };

关于delete�q�有两个有用的地�Ҏ��

1�Q�让你的对象只能生成在栈内存上：

1

2

3

struct NonNewable {

    void *operator new(std::size_t) = delete;

};

2�Q�阻止函数的其�Ş参的�c�d��调用�Q�（若尝试以 double 的�Ş参调�?nbsp;f()�Q�将会引发编译期错误�Q?�~�译器不会自动将 double 形参转型�?int 再调�?code>f()�Q�如果传入的参数是double�Q�则会出现编译错误）

1

2

void f(int i);

void f(double) = delete;

nullptr

C/C++的NULL宏是个被有很多潜在BUG的宏。因为有的库把其定义成整�?�Q�有的定义成 (void*)0。在C的时代还好。但是在C++的时代，�q�就会引发很多问题。你可以上网看看。这是�ؓ什么需�?nbsp;nullptr 的原因�?nbsp;nullptr 是强�c�d��的�?/p>

1

2

3

4

5

6

void f(int); //#1

void f(char *);//#2

//C++03

f(0); //二义�?/code>
//C++11 f(nullptr) //无二义性，调用f(char*)

所以在新版中请�?nullptr 初始化指针�?/p>
委托构�?/h4>
在以前的C++中，构造函��C��间不能互相调用，所以，我们在写�q�些�怼�的构造函数里�Q�我们会把相同的代码攑ֈ�一个私有的成员函数中�?/p>

1

2

3

4

5

6

7

8

9

10

class SomeType {

private:

  int number;

  string name;

  SomeType( int i, string& s ) : number(i), name(s){}

public:

  SomeType( )               : SomeType( 0, "invalid" ){}

  SomeType( int i )         : SomeType( i, "guest" ){}

  SomeType( string& s ) : SomeType( 1, s ){ PostInit(); }

};

但是�Q��ؓ了方便�ƈ不��?#8220;委托构�?#8221;�q�个事出玎ͼ�最主要的问题是�Q�基�cȝ��构造不能直接成为派生类的构造，��q��是基�cȝ��构造函数够了，�z��c�还要自己写自己的构造函敎ͼ�

1

2

3

4

5

6

7

8

9

10

11

class BaseClass

{

public:

  BaseClass(int iValue);

};

class DerivedClass : public BaseClass

{

public:

  using BaseClass::BaseClass;

};

上例中，�z��c�L��动��承基�cȝ��构造函敎ͼ� �~�译器可以��用基�cȝ��构造函数完成派生类的构造�?而将基类的构造函数带入派生类的动�?无法选择性地部分带入�Q?所以，要不��是�l�承基类全部的构造函敎ͼ�要不��是一个都不��?不手动带�?�?此外�Q�若牉|��到多重��承，从多个基�cȝ��承而来的构造函��C��可以有相同的函数�{�֐�(signature)�?而派生类的新加入的构造函��C��不可以和�l�承而来的基�c�L��造函数有相同的函数签名，因�ؓ�q�相当于重复声明。（所谓函数签名就是函数的参数�c�d��和顺序不�Q?/p>
叛_��引用和move语义

在老版的C++中，临时性变量（�U�Cؓ叛_�?#8221;R-values”�Q�位于赋值操作符之右�Q�经常用作交换两个变量。比如下面的�C�Z��中的tmp变量。示例中的那个函数需要传递两个string的引用，但是在交换的�q�程中��生了对象的构造，内存的分配还有对象的拯��构造等�{�动作，成本比较高�?/p>

1

2

3

4

5

6

void naiveswap(string &a, string &b)

{

string temp = a;

a=b;

b=temp;

}

C++ 11增加一个新的引用（reference�Q�类型称作右值引用（R-value reference�Q�，标记�?tt>typename &&。他们能够以non-const值的方式传入�Q�允许对象去改动他们。这��修正允许特定对象创造出move语义�?/p>

举例而言�Q�上面那个例子中�Q�string�c�M��保存了一个动态内存分存的char*指针�Q�如果一个string对象发生拯��构造（如：函数�q�回�Q�，string�c�里的char*内存只能通过创徏一个新的��时对象，�q�把函数内的对象的内存copy到这个新的对象中�Q�然后销毁��时对象及其内存�?strong>�q�是原来C++性能上重点被批评的事�?/p>

能过叛_��引用，string的构造函数需要改�?#8220;move构造函�?#8221;�Q�如下所�C�。这样一来，使得�Ҏ��?span style="font-family: monospace">stirng的右值引用可以单�U�地从右值复制其内部C-style的指针到新的string�Q�然后留下空的右倹{��这个操作不需要内存数�l�的复制�Q�而且�I�的暂时对象的析构也不会释放内存。其更有效率�?/p>

class string
{
    string (string&&); //move constructor
    string&& operator=(string&&); //move assignment operator
};

The C++11 STL中广泛地使用了右值引用和move语议。因此，很多��法和容器的性能都被优化了�?/p>

C++ 11 STL 标准�?/h4>
C++ STL库在2003�q�经历了很大的整�Ҏ��?nbsp;Library Technical Report 1 (TR1)�?TR1 中出��C��很多新的容器�c?(`unordered_set`, `unordered_map`, `unordered_multiset`, �?nbsp;`unordered_multimap`) 以及一些新的库支持诸如�Q�正则表辑ּ��Q?tuples�Q�函数对象包装，�{�等�?C++11 批准�?TR1 成�ؓ正式的C++标准�Q�还有一些TR1 后新加的一些库�Q�从而成��Z��新的C++ 11 STL标准库。这个库主要包含下面的功能：

�U�程�?/h5>
�q�们��׃��多说了，以前的STL饱受�U�程安全的批评。现在好了。C++ 11 支持�U�程�c�M��。这��涉及两个部分：�W�一、设计一个可以��多个�U�程在一个进�E�中共存的内存模型；�W�二、�ؓ�U�程之间的交互提供支持。第二部分将��q��序库提供支持。大家可以看�?a target="_blank">promises and futures�Q�其用于对象的同步�?nbsp;async() 函数模板用于发�v�q�发��d��Q��?nbsp;thread_local 为线�E�内的数据指定存储类型。更多的东西�Q�可以查�?Anthony Williams�?nbsp;Simpler Multithreading in C++0x.

新型��指针

C++98 的知能指针是 auto_ptr�Q?在C++ 11中被废弃了�?/code>C++11 引入了两个指针类�Q?nbsp;shared_ptr �?unique_ptr�?shared_ptr只是单纯的引用计数指针，unique_ptr 是用来取�?code>auto_ptr�?nbsp;unique_ptr 提供 auto_ptr 大部份特性，唯一的例外是 auto_ptr 的不安全、隐性的左值搬�U�R��不�?nbsp;auto_ptr�Q?code>unique_ptr 可以存放�?C++0x 提出的那些能察觉搬移动作的容器之中�?/p>

��Z��么要�q�么�qԌ��大家可以看看《More Effective C++》中�?auto_ptr的讨论�?/p>

新的��法

定义了一些新的算法： all_of(), any_of() �?nbsp;none_of()�?/code>








1
2
3
4
5
6
7
8


#include <algorithm>
//C++11 code
//are all of the elements positive?
all_of(first, first+n, ispositive()); //false
//is there at least one positive element?
any_of(first, first+n, ispositive());//true
// are none of the elements positive?
none_of(first, first+n, ispositive()); //false
使用新的copy_n()���法�Q�你可以很方便地拯���数组�?/p>






1
2
3
4
5


#include <algorithm>
int source[5]={0,12,34,50,80};
int target[5];
//copy 5 elements from source to target
copy_n(source,5,target);
使用 iota() 可以用来创徏递增的数列。如下例所�C�：






1
2
3
4
5


include <numeric>
int a[5]={0};
char c[3]={0};
iota(a, a+5, 10); //changes a to {10,11,12,13,14}
iota(c, c+3, 'a'); //{'a','b','c'}
��M���Q�看下来�Q�C++11 �q�是很学院派�Q�很多实用的东西�q�是没有�Q�比如： XML�Q�sockets�Q�reflection�Q�当然还有垃圑֛�收。看来要�{�到C++ 20了。呵��c��不�q�C++ 11在性能上还是很快。参�?Google’s benchmark tests。原文还引用Stroustrup 的观点：C++11 是一门新的语�a�——一个更好的 C++�?/p>
如果把所有的改变都列出来�Q�你会发现真多啊。我估计C++ Primer那本书的厚度要增加至��?0%以上。C++的门槛会不会���来���高了呢�Q�我不知道，但我个�h觉得�q�门语言的确是变得越来越令�h望而却步了。（惌��v了某人和我说的一句话——学技术真的是太篏了，�q�是搞方法论好�؜些？�Q?/p>

天边�?/a> 2013-05-05 21:26 发表评论



各编译器对于C++11新特性的支持情况
Sun, 05 May 2013 13:11:00 GMT
http://wiki.apache.org/stdcxx/C%2B%2B0xCompilerSupport
The following table lists C++0x features and their support in popular compilers. 





Status Of C++ 0x Language Features in Compilers 


C++ 0x FEATURE 

PAPER(S) 

HP aCC 

EDG eccp 

GCC 

Intel C++ 

MSVC 

IBM XLC++ 

Sun/ Oracle C++ 

Embarcadero C++ Builder 

Digital Mars C++ 

Clang 


alignas 

N2341 





4.8 













3.0 


alignof 

N2341 





4.5 









Yes 



2.9 


Atomic operations 

N2427 





4.4 

13.0 

11.0 









3.1 


auto 

v0.9: N1984, v1.0: N2546 



4.1(v0.9) 

4.4(v1.0) 

11.0(v0.9) 

10.0(v0.9) 

11.1 (V1.0) 







Yes 


C99 preprocessor 

N1653 





4.3 

11.1 



10.1 

5.9 



Yes 

Yes 


Concepts ^[removed] 

N2617 





ConceptGcc 

















constexpr 

N2235 





4.6 

13.0 



12.1 







3.1 


decltype 

v1.0: N2343, v1.1: N3276 



4.1(v1.0) 

4.3(v1.0) 4.8.1(v1.1) 

11.0(v1.0) 

10.0(v1.0), 11.0(v1.1) 

11.1 (V1.0) 



Yes 



2.9 


Defaulted And Deleted Functions 

N2346 



4.1 

4.4 

12.0 











3.0 


Delegating Constructors 

N1986 





4.7 




11.0 nov'12 

11.1 







3.0 


Explicit conversion operators 

N2437 





4.5 

13.0 

11.0 nov'12 

12.1 



Yes 



3.0 


Extended friend Declarations 

N1791 



4.1 

4.7 

11.0 

10.0*** 

V1R11,11.1 







2.9 


extern template 

N1987 

3, 5, 6 



3.3 

9 

6.0 

V1R11,11.1 



Yes 



Yes 


Forward declarations for enums 

N2764 





4.6 



11.0 

12.1 







3.1 


Inheriting Constructors 

N2540 





4.8 


















Initializer Lists 

N2672 





4.4 

13.0 

11.0 nov'12 









3.1 


Lambda expressions and closures 

v0.9: N2550, v1.0: N2658, v1.1: N2927 



4.1(v0.9) 

4.5(v1.1) 

11.0(v0.9)
12.0(v1.0) 

10.0(v1.0), 11.0(v1.1) 









3.1 


Local and Unnamed Types as Template Arguments 

N2657 





4.5 

12.0 

10.0 









2.9 


long long 

N1811 

Yes 

Yes 

Yes 

Yes 

Yes 

Yes 

Yes 

Yes 

Yes 

Yes 


Namespace Association 

N2535 





4.4 






11.1 







2.9 


New character types 

N2249 





4.4 













2.9 


New function declaration syntax for deduced return types 

N2541 



4.1 

4.4 

12.1 

10.0 

12.1 







2.9 


nullptr 

N2431 





4.6 

12.1* 

10.0 









2.9 


Unicode String Literals 

N2442 





4.4 

11.0* 





5.7 

Yes 



3.0 


Raw String Literals 

N2442 





4.5 




11.0 nov'12 









Yes 


User-defined Literals 

N2765 





4.7 













3.1 


Right Angle Brackets 

N1757 



4.1 

4.3 

11.0 

8.0 

12.1 







Yes 


R-Value References, std::move 

v1.0: N2118, v2.0: N2844, v2.1: N2844+, v3.0: N3053 



4.1(v1.0) 

4.3(v1.0)
4.5(v2.1)
4.6(v3.0) 

11.1(v1.0)
12.0(v2.0) 

10.0(v2.0), 11.0(v2.1) 

12.1(v2.1) 



Yes 



Yes 


static_assert 

N1720 



4.1 

4.3 

11.0 

10.0 

11.1 



Yes 



2.9 


Strongly-typed enums 

N2347 





4.4 

12.0 

11.0 

12.1 



Yes 



2.9 


Template aliases 

N2258 





4.7 

12.1 











3.0 


Thread-Local Storage 

N2659 





4.8 (4.4****) 

11.1***


10.0*** 



5.9*** 





2.9**** 


Unrestricted Unions 

N2544 





4.6 














3.0 


Built-in Type Traits 

N1836 

6.16 

4.0 

4.3 

10.0 

8.0 





Yes 



3.0 


Variadic Templates 

v0.9: N2242, v1.0: N2555 



4.1(v0.9) 

4.3(v0.9) 4.4(v1.0) 

12.1(v0.9) 

11.0 nov'12 

11.1 (v0.9) 







2.9(1.0) 


Range-based for-loop 

N2930 





4.6 

13.0 

11.0 









3.0 


override and final 

v0.8: N2928, v0.9: N3206, v1.0: N3272 





4.7 

12.0(v0.8)*** 

8.0(v0.8)*** 11.0(v1.0) 









2.9 


Attributes 

N2761 





4.8 

12.1 














ref-qualifiers 

N2439 





4.8.1 













2.9 


Non-static data member initializers 

N2756 





4.7 













3.0 


Dynamic initialization and destruction with concurrency (Magic statics) 

N2660 





4.3 

? 











2.9 

* — 1) unicode string literals is a feature of the EDG frontend, but it is undocumented at Intel C++ compiler (/Qoption,cpp,"--uliterals" option enables it) 
 

天边�?/a> 2013-05-05 21:11 发表评论


gprof——GNU性能分析工具
Mon, 22 Apr 2013 08:39:00 GMT
转蝲�?/em>http://www.cnblogs.com/feisky/archive/2010/03/09/1681997.html

gprof介绍
gprof是GNU profiler工具。可以显�C�程序运行的“flat profile”�Q�包括每个函数的调用�ơ数�Q�每个函数消耗的处理器时间。也可以昄���“调用�?#8221;�Q�包括函数的调用关系�Q�每个函数调用花费了多少旉���。还可以昄���“注释的源代码”�Q�是�E�序源代码的一个复本，标记有程序中每行代码的执行次数�?/p>
为gprof�~�译�E�序

在编译或链接源程序的时候在�~�译器的命��o行参��C��加入“-pg”选项�Q�编译时�~�译器会自动在目标代码中插入用于性能���试的代码片断，�q�些代码在程序在�q�行旉���集�ƈ记录函数的调用关�p�d��调用�ơ数�Q�以及采集�ƈ记录函数自��n执行旉���和子函数的调用时��_���E�序�q�行�l�束后，会在�E�序退出的路径下生成一个gmon.out文�g。这个文件就是记录�ƈ保存下来的监控数据。可以通过命��o行方式的gprof或图形化的Kprof来解读这些数据�ƈ对程序的性能�q�行分析。另外，如果��x��看库函数的profiling�Q�需要在�~�译是再加入“-lc_p”�~�译参数代替“-lc”�~�译参数�Q�这��L��序会链接libc_p.a库，才可以��生库函数的profiling信息。如果想执行一行一行的profiling�Q�还需要加�?#8220;-g”�~�译参数�?br />例如如下命��o行：gcc -Wall -g -pg -lc_p example.c -o example
Gprof基本用法�Q?/em>

1�Q?使用 -pg �~�译和链接你的应用程序�?/p>
2�Q?执行你的应用�E�序使之生成供gprof 分析的数据�?
3�Q?使用gprof �E�序分析你的应用�E�序生成的数据�?
$gprof -b a.out gmon.out       
Flat profile: 
Each sample counts as 0.01 seconds.
no time accumulated 
  %   cumulative   self              self     total           
time   seconds   seconds    calls  Ts/call  Ts/call  name    
  0.00      0.00     0.00        1     0.00     0.00  function 
                        Call graph 
granularity: each sample hit covers 2 byte(s) no time propagated 
index % time    self  children    called     name
                0.00    0.00       1/1           main [8]
[1]      0.0    0.00    0.00       1         function [1]
----------------------------------------------- 
Index by function name 
   [1] function 
gprof产生的信�?/h1>

%                        the percentage of the total running time of the
time                     program used by this function.
                           函数使用旉���占所有时间的癑ֈ�比�?br />cumulative          a running sum of the number of seconds accounted
seconds             for by this function and those listed above it.
                           函数和上列函数篏计执行的旉����?br />self                    the number of seconds accounted for by this
seconds             function alone.  This is the major sort for this
                          listing.
                          函数本��n所执行的时间�?br />calls                   the number of times this function was invoked, if
                          this function is profiled, else blank.
                          函数被调用的�ơ数
self                   the average number of milliseconds spent in this
ms/call               function per call, if this function is profiled,
                         else blank.
                          每一�ơ调用花费在函数的时间microseconds�?br />total                  the average number of milliseconds spent in this
ms/call               function and its descendents per call, if this
                          function is profiled, else blank.
                          每一�ơ调用，��p��在函数及其衍生函数的�q�_��旉���microseconds�?br />name                 the name of the function.  This is the minor sort
                          for this listing. The index shows the location of
                          the function in the gprof listing. If the index is
                          in parenthesis it shows where it would appear in
                          the gprof listing if it were to be printed.
                          函数�?/p>
命��o格式
gprof [可执行文件] [gmon.out文�g] [其它参数] 
�Ҏ��号中的内容可以省略。如果省略了“可执行文�?#8221;�Q�gprof会在当前目录下搜索a.out文�g作�ؓ可执行文�Ӟ��而如果省略了gmon.out文�g�Q�gprof也会在当前目录下��L��gmon.out。其它参数可以控制gprof输出内容的格式等信息。最常用的参数如下： 
l -b 不再输出�l�计图表中每个字�D늚�详细描述�?
l -p 只输出函数的调用图（Call graph的那部分信息�Q��?
l -q 只输出函数的旉���消耗列表�?
l -e Name 不再输出函数Name 及其子函数的调用图（除非它们有未被限制的其它父函敎ͼ�。可以给定多�?-e 标志。一�?-e 标志只能指定一个函数�?
l -E Name 不再输出函数Name 及其子函数的调用图，此标志类��g�� -e 标志�Q�但它在��L��间和癑ֈ�比时间的计算中排除了由函数Name 及其子函数所用的旉����?
l -f Name 输出函数Name 及其子函数的调用图。可以指定多�?-f 标志。一�?-f 标志只能指定一个函数�?
l -F Name 输出函数Name 及其子函数的调用图，它类��g�� -f 标志�Q�但它在��L��间和癑ֈ�比时间计���中仅��用所打印的例�E�的旉���。可以指定多�?-F 标志。一�?-F 标志只能指定一个函数�?F 标志覆盖 -E 标志�?
l -z 昄���使用�ơ数为零的例�E�（按照调用计数和篏�U�时间计���）�?
不过,gprof不能昄���对象之间的��承关�p?�q�也是它的弱�?


天边�?/a> 2013-04-22 16:39 发表评论


【�{】浅析系�l�的大小端模�?
Thu, 19 Jan 2012 03:39:00 GMT


转蝲来源�Q?a >http://blog.csdn.net/dragonbooker/article/details/6173321
大端模式
　　所谓的大端模式�Q�是指数据的低位�Q�就是权��D�����的后面那几位）保存在内存的高地址中，而数据的高位�Q�保存在内存的低地址中，�q�样的存储模式有点儿�c�M��于把数据当作字符串顺序处理：地址由小向大增加�Q�而数据从高位往低位放； 
 
���端模式
　　所谓的���端模式�Q�是指数据的低位保存在内存的低地址中，而数 据的高位保存在内存的高地址中，�q�种存储模式���地址的高低和数据位权有效地结合�v来，高地址部分权值高�Q�低地址部分权��g���Q�和我们的逻辑�Ҏ��一致�?/span> 
 
��Z��么有大小端模式之�?/span>
��Z��么会有大���端模式之分呢？�q�是因�ؓ在计���机�pȝ��中，我们是以字节为单位的�Q�每个地址单元都对应着一个字节，一个字节�ؓ 8bit。但是在C语言中除�?/span>8bit�?/span>char之外�Q�还�?/span>16bit�?/span>short型，32bit�?/span>long型（要看具体的编译器�Q�，另外�Q�对于位数大�?/span> 8位的处理器，例如16位或�?/span>32位的处理器，�׃��寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。因此就��D��了大端存储模式和���端存储模式。例如一�?/span>16bit�?/span>short�?/span>x�Q�在内存中的地址�?/span>0x0010�Q?/span>x的��gؓ0x1122�Q�那�?/span>0x11为高字节�Q?/span>0x22��Z��字节。对�?/span> 大端模式�Q�就��?/span>0x11攑֜�低地址中，�?/span>0x0010中，0x22攑֜�高地址中，�?/span>0x0011中。小端模式，刚好相反。我们常用的X86�l�构是小端模式，�?/span>KEIL C51则�ؓ大端模式。很多的ARM�Q?/span>DSP都�ؓ���端模式。有�?/span>ARM处理器还可以��q��件来选择是大端模式还是小端模式�?/span>
二、�D例说�?/span>
大家都知道字�W?#8216;A’�?/span>ASCII码��gؓ65�Q�十�q�制�Q�也���是0x41�Q�那么这个值在不同大小端模式的�pȝ��中存攄���方式分别为：
大端模式�Q?/span>00 00 00 41 -----高低模式
���端模式�Q?/span>41 00 00 00  -----低低模式
三、��用代码判断大���端模式
可以通过声明一个联合（union�Q�判断大���端模式�Q?/span>
 
/**
 * �Ҏ��一 得到当前�pȝ��的大���端属�?/span>, 此方法要保证�?/span>32位机���试
 */
static union { 
       char c[4]; 
    unsigned long l; 
} 
 
endian_test = { { 'l', '?', '?', 'b' } }; 　　
 
#define ENDIANNESS ((char)endian_test.l)
 
/**
 * �Ҏ���?/span>: 得到当前�pȝ��的大���端属�?/span>
 */
static union {
     short n;
     char c[sizeof(short)];
}un;
 
int getEndian()
{
   un.n = 0x0102;
 
   if ((un.c[0] == 1 && un.c[1] == 2))
   {
     printf("big endian/n");
   }
   else if ((un.c[0] == 2 && un.c[1] == 1))
   {
     printf("little endian/n");
   }
   else 
     printf("error!/n");
 
   return 0;
}
 
/**
 * �Ҏ���?/span>: 得到当前�pȝ��的大���端属�?/span>
 */
int getEndian()
{
   int c = 1;                               // big-endian: 00 00 00 01 little-endian: 01 00 00 00
  // int c = 0x02000001;          // big-endian: 02 00 00 01 little-endian: 01 00 00 02
 
   if ((*(char *)&c) == 1)               // �?/span>c变量所在地址上的一个字节�?/span>
   {
     printf("little endian/n");
   }
   else
     printf("big endian");
 
   return 0;
}


天边�?/a> 2012-01-19 11:39 发表评论


【�{】TCP三次握手/四次挥手详解
Wed, 11 Jan 2012 15:49:00 GMT
来源�Q?a >http://blog.csdn.net/sfwork/article/details/6876692
1、徏立连接协议（三次握手�Q?wbr>
�Q?�Q�客��L��发送一个带SYN标志的TCP报文到服务器。这是三�ơ握手过�E�中的报�?�?br />�Q?�Q?服务器端回应客户端的�Q�这是三�ơ握手中的第2个报文，�q�个报文同时带ACK标志和SYN标志。因此它表示对刚才客��L��SYN报文的回应；同时又标志SYN�l�客��L���Q�询问客��L��是否准备好进行数据通讯�?br />�Q?�Q?客户必须再次回应服务�D�一个ACK报文�Q�这是报文段3�?br />2、连接终止协议（四次挥手�Q?wbr>
　 　�׃��TCP�q�接是全双工的，因此每个方向都必���d��独进行关闭。这原则是当一方完成它的数据发送�Q务后���p��发送一个FIN来终止这个方向的�q�接。收��C���?FIN只意味着�q�一方向上没有数据流动，一个TCP�q�接在收��C��个FIN后仍能发送数据。首先进行关闭的一方将执行��d��关闭�Q�而另一�Ҏ��行被动关闭�?br />　�Q?�Q?TCP客户端发送一个FIN�Q�用来关闭客户到服务器的数据传送（报文�D?�Q��?br />　�Q?�Q?服务器收到这个FIN�Q�它发回一个ACK�Q�确认序号�ؓ收到的序号加1�Q�报文段5�Q�。和SYN一��P��一个FIN���占用一个序受��?br />　�Q?�Q?服务器关闭客��L��的连接，发送一个FIN�l�客��L���Q�报文段6�Q��?br />　�Q?�Q?客户�D�发回ACK报文���认�Q��ƈ���确认序可����|��ؓ收到序号�?�Q�报文段7�Q��?br />CLOSED: �q�个没什么好说的了，表示初始状态�?br />LISTEN: �q�个也是非常�Ҏ��理解的一个状态，表示服务器端的某个SOCKET处于监听状态，可以接受�q�接了�?br />SYN_RCVD: �q�个状态表�C�接受到了SYN报文�Q�在正常情况下，�q�个状态是服务器端的SOCKET在徏立TCP�q�接时的三次握手会话�q�程中的一个中间状态，很短暂，基本上用netstat你是很难看到�q�种状态的�Q�除非你�Ҏ��写了一个客��L�����试�E�序�Q�故意将三次TCP握手�q�程中最后一个ACK报文不予发送。因此这�U�状态时�Q�当收到客户端的ACK报文后，它会�q�入到ESTABLISHED状态�?br />SYN_SENT: �q�个状态与SYN_RCVD遥想呼应�Q�当客户端SOCKET执行CONNECT�q�接�Ӟ��它首先发送SYN报文�Q�因此也随即它会�q�入��C��SYN_SENT状态，�q�等待服务端的发送三�ơ握手中的第2个报文。SYN_SENT状态表�C�客��L��已发送SYN报文�?br />ESTABLISHED�Q�这个容易理解了�Q�表�C����接已�l�徏立了�?br />FIN_WAIT_1: �q�个状态要好好解释一下，其实FIN_WAIT_1和FIN_WAIT_2状态的真正含义都是表示�{�待�Ҏ��的FIN报文。而这两种状态的区别是：FIN_WAIT_1状态实际上是当SOCKET在ESTABLISHED状态时�Q�它想主动关闭连接，向对方发送了FIN报文�Q�此时该SOCKET卌���入到FIN_WAIT_1状态。而当�Ҏ��回应ACK报文后，则进入到FIN_WAIT_2状态，当然在实际的正常情况下，无论�Ҏ��何种情况下，都应该马上回应ACK报文�Q�所以FIN_WAIT_1状态一般是比较难见到的�Q�而FIN_WAIT_2状态还有时常常可以用netstat看到�?br />FIN_WAIT_2�Q�上面已�l�详�l�解释了�q�种状态，实际上FIN_WAIT_2状态下的SOCKET�Q�表�C�半�q�接�Q�也��x��一方要求close�q�接�Q�但另外�q�告诉对方，我暂时还有点数据需要传送给你，�E�后再关闭连接�?br />TIME_WAIT: 表示收到了对方的FIN报文�Q��ƈ发送出了ACK报文�Q�就�{?MSL后即可回到CLOSED可用状态了。如果FIN_WAIT_1状态下�Q�收��C���Ҏ��同时带FIN标志和ACK标志的报文时�Q�可以直接进入到TIME_WAIT状态，而无��ȝ���q�FIN_WAIT_2状态�?br />CLOSING: �q�种状态比较特�D�，实际情况中应该是很少见，属于一�U�比较罕见的例外状态。正常情况下�Q�当你发送FIN报文后，按理来说是应该先收到�Q�或同时收到�Q�对方的ACK报文�Q�再收到�Ҏ��的FIN报文。但是CLOSING状态表�C�Z��发送FIN报文后，�q�没有收到对方的ACK报文�Q�反而却也收��C���Ҏ��的FIN报文。什么情况下会出现此�U�情况呢�Q�其实细想一下，也不隑־�出结论：那就是如果双方几乎在同时close一个SOCKET的话�Q�那么就出现了双方同时发送FIN报文的情况，也即会出现CLOSING状态，表示双方都正在关闭SOCKET�q�接�?br />CLOSE_WAIT: �q�种状态的含义其实是表�C�在�{�待关闭。怎么理解呢？当对方close一个SOCKET后发送FIN报文�l�自己，你系�l�毫无疑问地会回应一个ACK报文�l�对方，此时则进入到CLOSE_WAIT状态。接下来呢，实际上你真正需要考虑的事情是察看你是否还有数据发送给�Ҏ���Q�如果没有的话，那么你也���可以close�q�个SOCKET�Q�发送FIN报文�l�对方，也即关闭�q�接。所以你在CLOSE_WAIT状态下�Q�需要完成的事情是等待你��d��闭连接�?br />LAST_ACK: �q�个状态还是比较容易好理解的，它是被动关闭一方在发送FIN报文后，最后等待对方的ACK报文。当收到ACK报文后，也即可以�q�入到CLOSED可用状态了�?br />最后有2个问题的回答�Q�我自己分析后的�l�论�Q�不一定保�?00%正确�Q?br />1�?��Z��么徏立连接协议是三次握手�Q�而关闭连接却是四�ơ握手呢�Q?br />�q�是因�ؓ服务端的LISTEN状态下的SOCKET当收到SYN报文的徏�q�请求后�Q�它可以把ACK和SYN�Q�ACK起应�{�作用，而SYN起同步作用）攑֜�一个报文里来发送。但关闭�q�接�Ӟ��当收到对方的FIN报文通知�Ӟ��它仅仅表�C�对�Ҏ��有数据发送给你了�Q�但未必你所有的数据都全部发送给�Ҏ��了，所以你可以未必会马上会关闭SOCKET,也即你可能还需要发送一些数据给�Ҏ��之后�Q�再发送FIN报文�l�对�Ҏ��表示你同意现在可以关闭连接了�Q�所以它�q�里的ACK报文和FIN报文多数情况下都是分开发送的�?br />2�?��Z��么TIME_WAIT状态还需要等2MSL后才能返回到CLOSED状态？
�q�是因�ؓ�Q�虽然双斚w��同意关闭�q�接了，而且握手�?个报文也都协调和发送完毕，按理可以直接回到CLOSED状态（���好比从SYN_SEND状态到ESTABLISH状态那��P���Q�但是因为我们必��要假想�|�络是不可靠的，你无法保证你最后发送的ACK报文会一定被�Ҏ��收到�Q�因此对方处于LAST_ACK状态下的SOCKET可能会因�����时未收到ACK报文�Q�而重发FIN报文�Q�所以这个TIME_WAIT状态的作用���是用来重发可能丢失的ACK报文�?img src ="http://m.shnenglu.com/tianbianlan/aggbug/164020.html" width = "1" height = "1" />

天边�?/a> 2012-01-11 23:49 发表评论


B+数的实现--优秀代码
Tue, 08 Nov 2011 04:32:00 GMT
优秀代码
http://idlebox.net/2007/stx-btree/


天边�?/a> 2011-11-08 12:32 发表评论


[转]C++ 对象的内存布局
Thu, 29 Apr 2010 11:30:00 GMT

2008-11-14 作者：陈皓 来源�Q�csdn

前言
07�q?2月，我写了一���《C++虚函数表解析》的文章�Q�引起了大家的兴���。有很多朋友�Ҏ��的文章留了言�Q�有鼓励我的�Q�有批评我的�Q�还有很多问问题的。我在这里一�q�对大家的留�a�表示感谢。这也是我�ؓ什么再写一���箋�a�的原因。因为，在上一���文章中�Q�我用了的示例都是非常简单的�Q�主要是��Z��说明一些机理上的问题，也是��Z��图一些表达上方便和简单。不惻I���q�篇文章成�ؓ了打开C++对象模型内存布局的一个引子，引发了大家对C++对象的更深层�ơ的讨论。当�Ӟ��我之前的文章�q�有很多斚w��没有涉及�Q�从我个人感觉下来，在谈�����函数表里�Q�至���有以下�q�些内容没有涉及�Q?/p>
1�Q�有成员变量的情��c�?/p>
2�Q�有重复�l�承的情��c�?/p>
3�Q�有虚拟�l�承的情��c�?/p>
4�Q�有�ȝ��型虚拟��承的情况�?/p>
�q�些都是我本���文章需要向大家说明的东�ѝ��所以，�q�篇文章���会是《C++虚函数表解析》的一个箋���，也是一���高�U�进阶的文章。我希望大家在读�q�篇文章之前对C++有一定的基础和了解，�q�能先读我的上一���文章。因��������文章的深度可能会比较深�Q�而且会比较杂乱，我希望你在读本篇文章时不会有大脑思维紊�ؕ��D��大脑��L��的情��c�?-)
对象的媄响因�?/p>
���而言之，我们一个类可能会有如下的媄响因素：
1�Q�成员变�?/p>
2�Q�虚函数�Q���生虚函数表）
3�Q�单一�l�承�Q�只�l�承于一个类�Q?/p>
4�Q�多重��承（�l�承多个�c�）
5�Q�重复��承（�l�承的多个父�c�M��其父�c�L��相同的超�c�）
6�Q�虚拟��承（使用virtual方式�l�承�Q��ؓ了保证��承后父类的内存布局只会存在一份）
上述的东襉K��常是C++�q�门语言在语义方面对对象内部的媄响因素，当然�Q�还会有�~�译器的影响�Q�比如优化）�Q�还有字节对齐的影响。在�q�里我们都不讨论�Q�我们只讨论C++语言上的影响�?/p>
本篇文章着重讨��Z���q�几个情况下的C++对象的内存布局情况�?/p>
1�Q�单一的一般��承（带成员变量、虚函数、虚函数覆盖�Q?/p>
2�Q�单一的虚拟��承（带成员变量、虚函数、虚函数覆盖�Q?/p>
3�Q�多重��承（带成员变量、虚函数、虚函数覆盖�Q?/p>
4�Q�重复多重��承（带成员变量、虚函数、虚函数覆盖�Q?/p>
5�Q�钻矛_��的虚拟多重��承（带成员变量、虚函数、虚函数覆盖�Q?/p>
我们的目标就是，让事情越来越复杂�?/p>
知识复习
我们���单地复习一下，我们可以通过对象的地址来取得虚函数表的地址�Q�如�Q?/p>
typedef void(*Fun)(void);
Base b;
Fun pFun = NULL;
cout << "虚函数表地址�Q? << (int*)(&b) << endl;
cout << "虚函数表 �?�W�一个函数地址�Q? << (int*)*(int*)(&b) << endl;
// Invoke the first virtual function 
pFun = (Fun)*((int*)*(int*)(&b));
pFun();
我们同样可以用这�U�方式来取得整个对象实例的内存布局。因�����些东西在内存中都是连�l�分布的�Q�我们只需要��用适当的地址偏移量，我们���可以获得整个内存对象的布局�?/p>
本篇文章中的例程或内存布局主要使用如下�~�译器和�pȝ���Q?/p>
1�Q�Windows XP �?VC++ 2003
2�Q�Cygwin �?G++ 3.4.4
单一的一般���?/strong>

下面�Q�我们假设有如下所�C�的一个��承关�p�：

��h��意，在这个��承关�p�M���Q�父�c�，子类�Q�孙子类都有自己的一个成员变量。而了�c�覆盖了父类的f()�Ҏ���Q�孙子类覆盖了子�cȝ��g_child()及其���类的f()�?/p>
我们的源�E�序如下所�C�：
class Parent {
public:
int iparent;
Parent ():iparent (10) {}
virtual void f() { cout << " Parent::f()" << endl; }
virtual void g() { cout << " Parent::g()" << endl; }
virtual void h() { cout << " Parent::h()" << endl; }
 
};
 
class Child : public Parent {
public:
int ichild;
Child():ichild(100) {}
virtual void f() { cout << "Child::f()" << endl; }
virtual void g_child() { cout << "Child::g_child()" << endl; }
virtual void h_child() { cout << "Child::h_child()" << endl; }
};
 
class GrandChild : public Child{
public:
int igrandchild;
GrandChild():igrandchild(1000) {}
virtual void f() { cout << "GrandChild::f()" << endl; }
virtual void g_child() { cout << "GrandChild::g_child()" << endl; }
virtual void h_grandchild() { cout << "GrandChild::h_grandchild()" << endl; }
};
我们使用以下�E�序作�ؓ���试�E�序�Q�（下面�E�序中，我��用了一个int** pVtab 来作为遍历对象内存布局的指针，�q�样�Q�我���可以方便地像��用数�l�一��h��遍历所有的成员包括其虚函数表了�Q�在后面的程序中�Q�我也是用这��L���Ҏ��的，请不必感到奇怪，�Q?/p>
typedef void(*Fun)(void);
GrandChild gc; 
int** pVtab = (int**)&gc;
cout << "[0] GrandChild::_vptr->" << endl;
for (int i=0; (Fun)pVtab[0][i]!=NULL; i++){
pFun = (Fun)pVtab[0][i];
cout << " ["<
pFun();
}
cout << "[1] Parent.iparent = " << (int)pVtab[1] << endl;
cout << "[2] Child.ichild = " << (int)pVtab[2] << endl;
cout << "[3] GrandChild.igrandchild = " << (int)pVtab[3] << endl;
其运行结果如下所�C�：�Q�在VC++ 2003和G++ 3.4.4下）

    
        
            
            [0] GrandChild::_vptr->
                [0] GrandChild::f()
                [1] Parent::g()
                [2] Parent::h()
                [3] GrandChild::g_child()
                [4] Child::h1()
                [5] GrandChild::h_grandchild()
            [1] Parent.iparent = 10
            [2] Child.ichild = 100
            [3] GrandChild.igrandchild = 1000
            
        
    

使用囄���表示如下�Q?/p>

可见以下几个斚w���Q?/p>
1�Q�虚函数表在最前面的位�|��?/p>
2�Q�成员变量根据其�l�承和声明顺序依�ơ放在后面�?/p>
3�Q�在单一的��承中�Q�被overwrite的虚函数在虚函数表中得到了更新�?/p>
多重�l�承
下面�Q�再让我们来看看多重�l�承中的情况�Q�假设有下面�q�样一个类的��承关�p�R��注意：子类只overwrite了父�cȝ��f()函数�Q�而还有一个是自己的函敎ͼ�我们�q�样做的目的是�ؓ了用g1()作�ؓ一个标记来标明子类的虚函数表）。而且每个�c�M��都有一个自��q��成员变量�Q?/p>
 
我们的类�l�承的源代码如下所�C�：父类的成员初始�ؓ10�Q?0�Q?0�Q�子�cȝ���?00
class Base1 {
public:
int ibase1;
Base1():ibase1(10) {}
virtual void f() { cout << "Base1::f()" << endl; }
virtual void g() { cout << "Base1::g()" << endl; }
virtual void h() { cout << "Base1::h()" << endl; }
 
};
class Base2 {
public:
int ibase2;
Base2():ibase2(20) {}
virtual void f() { cout << "Base2::f()" << endl; }
virtual void g() { cout << "Base2::g()" << endl; }
virtual void h() { cout << "Base2::h()" << endl; }
};
class Base3 {
public:
int ibase3;
Base3():ibase3(30) {}
virtual void f() { cout << "Base3::f()" << endl; }
virtual void g() { cout << "Base3::g()" << endl; }
virtual void h() { cout << "Base3::h()" << endl; }
};
class Derive : public Base1, public Base2, public Base3 {
public:
int iderive;
Derive():iderive(100) {}
virtual void f() { cout << "Derive::f()" << endl; }
virtual void g1() { cout << "Derive::g1()" << endl; }
};
我们通过下面的程序来查看子类实例的内存布局�Q�下面程序中�Q�注意我使用了一个s变量�Q�其中用��C��sizof(Base)来找下一个类的偏�U�量。（因�ؓ我声明的是int成员�Q�所以是4个字节，所以没有对齐问题。关于内存的寚w��问题�Q�大家可以自行试验，我在�q�里��׃��多说了）
typedef void(*Fun)(void);
Derive d;
int** pVtab = (int**)&d;
cout << "[0] Base1::_vptr->" << endl;
pFun = (Fun)pVtab[0][0];
cout << " [0] ";
pFun();
pFun = (Fun)pVtab[0][1];
cout << " [1] ";pFun();
pFun = (Fun)pVtab[0][2];
cout << " [2] ";pFun();
pFun = (Fun)pVtab[0][3];
cout << " [3] "; pFun();
pFun = (Fun)pVtab[0][4];
cout << " [4] "; cout<
cout << "[1] Base1.ibase1 = " << (int)pVtab[1] << endl;
int s = sizeof(Base1)/4;
cout << "[" << s << "] Base2::_vptr->"<
pFun = (Fun)pVtab[s][0];
cout << " [0] "; pFun();
Fun = (Fun)pVtab[s][1];
cout << " [1] "; pFun();
pFun = (Fun)pVtab[s][2];
cout << " [2] "; pFun(); 
pFun = (Fun)pVtab[s][3];
out << " [3] ";
cout<
cout << "["<< s+1 <<"] Base2.ibase2 = " << (int)pVtab[s+1] << endl;
s = s + sizeof(Base2)/4;
cout << "[" << s << "] Base3::_vptr->"<
pFun = (Fun)pVtab[s][0];
cout << " [0] "; pFun();
 
pFun = (Fun)pVtab[s][1];
cout << " [1] "; pFun();
pFun = (Fun)pVtab[s][2];
cout << " [2] "; pFun(); 
 
pFun = (Fun)pVtab[s][3];
cout << " [3] ";
cout<
s++;
cout << "["<< s <<"] Base3.ibase3 = " << (int)pVtab[s] << endl;
s++;
cout << "["<< s <<"] Derive.iderive = " << (int)pVtab[s] << endl;
其运行结果如下所�C�：�Q�在VC++ 2003和G++ 3.4.4下）

    
        
            
            [0] Base1::_vptr->
                 [0] Derive::f()
                 [1] Base1::g()
                 [2] Base1::h()
                 [3] Driver::g1()
                 [4] 00000000      ç 注意�Q�在GCC下，�q�里�?/span>1
            [1] Base1.ibase1 = 10
            [2] Base2::_vptr->
                 [0] Derive::f()
                 [1] Base2::g()
                 [2] Base2::h()
                 [3] 00000000      ç 注意�Q�在GCC下，�q�里�?/span>1
            [3] Base2.ibase2 = 20
            [4] Base3::_vptr->
                 [0] Derive::f()
                 [1] Base3::g()
                 [2] Base3::h()
                 [3] 00000000
            [5] Base3.ibase3 = 30
            [6] Derive.iderive = 100
            
        
    

使用囄���表示是下面这个样子：

我们可以看到�Q?/p>
1�Q?每个父类都有自己的虚表�?/p>
2�Q?子类的成员函数被攑ֈ�了第一个父�cȝ��表中�?/p>
3�Q?内存布局中，其父�c�d��局依次按声明顺序排列�?/p>
4�Q?每个父类的虚表中的f()函数都被overwrite成了子类的f()。这样做���是��Z��解决不同的父�cȝ��型的指针指向同一个子�c�d��例，而能够调用到实际的函数�?/p>
重复�l�承

下面我们再来看看�Q�发生重复��承的情况。所谓重复��承，也就是某个基�c�被间接地重复��承了多次�?/p>
下图是一个��承图�Q�我们重载了父类的f()函数�?/p>

其类�l�承的源代码如下所�C�。其中，每个�c�都有两个变量，一个是整�Ş�Q?字节�Q�，一个是字符�Q?字节�Q�，而且�q�有自己的虚函数�Q�自己overwrite父类的虚函数。如子类D中，f()覆盖了超�cȝ��函数�Q?f1() 和f2() 覆盖了其父类的虚函数�Q�Df()�������q��虚函数�?/p>
class B
{
public:
int ib;
char cb;
public:
B():ib(0),cb('B') {}
virtual void f() { cout << "B::f()" << endl;}
virtual void Bf() { cout << "B::Bf()" << endl;}
};
class B1 : public B
{
public:
int ib1;
char cb1;
public:
B1():ib1(11),cb1('1') {}
virtual void f() { cout << "B1::f()" << endl;}
virtual void f1() { cout << "B1::f1()" << endl;}
virtual void Bf1() { cout << "B1::Bf1()" << endl;}
};
class B2: public B
{
public:
int ib2;
char cb2;
public:
B2():ib2(12),cb2('2') {}
virtual void f() { cout << "B2::f()" << endl;}
virtual void f2() { cout << "B2::f2()" << endl;}
virtual void Bf2() { cout << "B2::Bf2()" << endl;}
};
class D : public B1, public B2
{
public:
int id;
char cd;
public:
D():id(100),cd('D') {}
virtual void f() { cout << "D::f()" << endl;}
virtual void f1() { cout << "D::f1()" << endl;}
virtual void f2() { cout << "D::f2()" << endl;}
virtual void Df() { cout << "D::Df()" << endl;}
};
我们用来存取子类内存布局的代码如下所�C�：�Q�在VC++ 2003和G++ 3.4.4下）
typedef void(*Fun)(void);
int** pVtab = NULL;
Fun pFun = NULL;
D d;
pVtab = (int**)&d;
cout << "[0] D::B1::_vptr->" << endl;
pFun = (Fun)pVtab[0][0];
cout << " [0] "; pFun();
pFun = (Fun)pVtab[0][1];
cout << " [1] "; pFun();
pFun = (Fun)pVtab[0][2];
cout << " [2] "; pFun();
pFun = (Fun)pVtab[0][3];
cout << " [3] "; pFun();
pFun = (Fun)pVtab[0][4];
cout << " [4] "; pFun();
pFun = (Fun)pVtab[0][5];
cout << " [5] 0x" << pFun << endl;
cout << "[1] B::ib = " << (int)pVtab[1] << endl;
cout << "[2] B::cb = " << (char)pVtab[2] << endl;
cout << "[3] B1::ib1 = " << (int)pVtab[3] << endl;
cout << "[4] B1::cb1 = " << (char)pVtab[4] << endl;
cout << "[5] D::B2::_vptr->" << endl;
pFun = (Fun)pVtab[5][0];
cout << " [0] "; pFun();
pFun = (Fun)pVtab[5][1];
cout << " [1] "; pFun();
pFun = (Fun)pVtab[5][2];
cout << " [2] "; pFun();
pFun = (Fun)pVtab[5][3];
cout << " [3] "; pFun();
pFun = (Fun)pVtab[5][4];
cout << " [4] 0x" << pFun << endl;
cout << "[6] B::ib = " << (int)pVtab[6] << endl;
cout << "[7] B::cb = " << (char)pVtab[7] << endl; 
cout << "[8] B2::ib2 = " << (int)pVtab[8] << endl;
cout << "[9] B2::cb2 = " << (char)pVtab[9] << endl;
cout << "[10] D::id = " << (int)pVtab[10] << endl;
cout << "[11] D::cd = " << (char)pVtab[11] << endl;
�E�序�q�行�l�果如下�Q?/p>


    
        
            
            GCC 3.4.4
            
            
            VC++ 2003
            
        
        
            
            [0] D::B1::_vptr->
                 [0] D::f()
                 [1] B::Bf()
                 [2] D::f1()
                 [3] B1::Bf1()
                 [4] D::f2()
                 [5] 0x1
            [1] B::ib = 0
            [2] B::cb = B
            [3] B1::ib1 = 11
            [4] B1::cb1 = 1
            [5] D::B2::_vptr->
                 [0] D::f()
                 [1] B::Bf()
                 [2] D::f2()
                 [3] B2::Bf2()
                 [4] 0x0
            [6] B::ib = 0
            [7] B::cb = B
            [8] B2::ib2 = 12
            [9] B2::cb2 = 2
            [10] D::id = 100
            [11] D::cd = D
            
            
            [0] D::B1::_vptr->
                 [0] D::f()
                 [1] B::Bf()
                 [2] D::f1()
                 [3] B1::Bf1()
                 [4] D::Df()
                 [5] 0x00000000
            [1] B::ib = 0
            [2] B::cb = B
            [3] B1::ib1 = 11
            [4] B1::cb1 = 1
            [5] D::B2::_vptr->
                 [0] D::f()
                 [1] B::Bf()
                 [2] D::f2()
                 [3] B2::Bf2()
                 [4] 0x00000000
            [6] B::ib = 0
            [7] B::cb = B
            [8] B2::ib2 = 12
            [9] B2::cb2 = 2
            [10] D::id = 100
            [11] D::cd = D
            
        
    


下面是对于子�c�d��例中的虚函数表的图：

我们可以看见�Q�最��端的父�c�B其成员变量存在于B1和B2中，�q�被D�l���承下��M��。而在D中，其有B1和B2的实例，于是B的成员在D的实例中存在两䆾�Q�一份是B1�l�承而来的，另一份是B2�l�承而来的。所以，如果我们使用以下语句�Q�则会��生二义性编译错误：
D d;
d.ib = 0; //二义性错�?/p>
d.B1::ib = 1; //正确
d.B2::ib = 2; //正确
注意�Q�上面例�E�中的最后两条语句存取的是两个变量。虽然我们消除了二义性的�~�译错误�Q�但B�c�d��D中还是有两个实例�Q�这�U���扉K��成了数据的重复�Q�我们叫�q�种�l�承为重复���ѝ��重复的基类数据成员可能�q�不是我们想要的。所以，C++引入了虚基类的概��c�?/p>
�ȝ��型多重虚拟���?/strong> 

虚拟�l�承的出现就是�ؓ了解决重复��承中多个间接父类的问题的。钻矛_��的结构是其最�l�典的结构。也是我们在�q�里要讨论的�l�构�Q?/p>
上述�?#8220;重复�l�承”只需要把B1和B2�l�承B的语法中加上virtual 关键�Q�就成了虚拟�l�承�Q�其�l�承囑֦�下所�C�：

上图和前面的“重复�l�承”中的�cȝ��内部数据和接口都是完全一��L���Q�只是我们采用了虚拟�l�承�Q�其省略后的源码如下所�C�：
class B {……};
class B1 : virtual public B{……};
class B2: virtual public B{……};
class D : public B1, public B2{ …… };
在查看D之前�Q�我们先看一看单一虚拟�l�承的情��c��下面是一�D�在VC++2003下的���试�E�序�Q�（因�ؓVC++和GCC的内存而局上有一些细节上的不同，所以这里只�l�出VC++的程序，GCC下的�E�序大家可以�Ҏ��我给出的�E�序自己仿照着写一个去试一试）�Q?/p>
int** pVtab = NULL;
Fun pFun = NULL;
 
B1 bb1;
pVtab = (int**)&bb1;
cout << "[0] B1::_vptr->" << endl;
pFun = (Fun)pVtab[0][0];
cout << " [0] ";
pFun(); //B1::f1();
cout << " [1] ";
pFun = (Fun)pVtab[0][1];
pFun(); //B1::bf1();
cout << " [2] ";
cout << pVtab[0][2] << endl;
cout << "[1] = 0x";
cout << (int*)*((int*)(&bb1)+1) <
cout << "[2] B1::ib1 = ";
cout << (int)*((int*)(&bb1)+2) <
cout << "[3] B1::cb1 = ";
cout << (char)*((int*)(&bb1)+3) << endl; //B1::cb1
cout << "[4] = 0x";
cout << (int*)*((int*)(&bb1)+4) << endl; //NULL
cout << "[5] B::_vptr->" << endl;
pFun = (Fun)pVtab[5][0];
cout << " [0] ";
pFun(); //B1::f();
pFun = (Fun)pVtab[5][1];
cout << " [1] ";
pFun(); //B::Bf();
cout << " [2] ";
cout << "0x" << (Fun)pVtab[5][2] << endl;
cout << "[6] B::ib = ";
cout << (int)*((int*)(&bb1)+6) <
cout << "[7] B::cb = ";
其运行结果如下（我结��Z��GCC的和VC++2003的对比）�Q?/p>

    
        
            
            GCC 3.4.4
            
            
            VC++ 2003
            
        
        
            
            [0] B1::_vptr ->
                [0] : B1::f()
                [1] : B1::f1()
                [2] : B1::Bf1()
                [3] : 0
            [1] B1::ib1 : 11
            [2] B1::cb1 : 1
            [3] B::_vptr ->
                [0] : B1::f()
                [1] : B::Bf()
                [2] : 0
            [4] B::ib : 0
            [5] B::cb : B
            [6] NULL : 0
            
            
            [0] B1::_vptr->
                 [0] B1::f1()
                 [1] B1::Bf1()
                 [2] 0
            [1] = 0x00454310 ç该地址取值后�?/span>-4
            [2] B1::ib1 = 11
            [3] B1::cb1 = 1
            [4] = 0x00000000
            [5] B::_vptr->
                 [0] B1::f()
                 [1] B::Bf()
                 [2] 0x00000000
            [6] B::ib = 0
            [7] B::cb = B
            
        
    

�q�里�Q�大家可以自己对比一下。关于细节上�Q�我会在后面一�q�再说�?/p>
下面的测试程序是看子�c�D的内存布局�Q�同��h��VC++ 2003的（因�ؓVC++和GCC的内存布局上有一些细节上的不同，而VC++的相对要清楚很多�Q�所以这里只�l�出VC++的程序，GCC下的�E�序大家可以�Ҏ��我给出的�E�序自己仿照着写一个去试一试）�Q?/p>
D d;
pVtab = (int**)&d;
cout << "[0] D::B1::_vptr->" << endl;
pFun = (Fun)pVtab[0][0];
cout << " [0] "; pFun(); //D::f1();
pFun = (Fun)pVtab[0][1];
cout << " [1] "; pFun(); //B1::Bf1();
pFun = (Fun)pVtab[0][2];
cout << " [2] "; pFun(); //D::Df();
pFun = (Fun)pVtab[0][3];
cout << " [3] ";
cout << pFun << endl;
//cout << pVtab[4][2] << endl;
cout << "[1] = 0x";
cout << (int*)((&dd)+1) <
cout << "[2] B1::ib1 = ";
cout << *((int*)(&dd)+2) <
cout << "[3] B1::cb1 = ";
cout << (char)*((int*)(&dd)+3) << endl; //B1::cb1
//---------------------
cout << "[4] D::B2::_vptr->" << endl;
pFun = (Fun)pVtab[4][0];
cout << " [0] "; pFun(); //D::f2();
pFun = (Fun)pVtab[4][1];
cout << " [1] "; pFun(); //B2::Bf2();
pFun = (Fun)pVtab[4][2];
cout << " [2] ";
cout << pFun << endl;
cout << "[5] = 0x";
cout << *((int*)(&dd)+5) << endl; // ???
cout << "[6] B2::ib2 = ";
cout << (int)*((int*)(&dd)+6) <
cout << "[7] B2::cb2 = ";
cout << (char)*((int*)(&dd)+7) << endl; //B2::cb2
cout << "[8] D::id = ";
cout << *((int*)(&dd)+8) << endl; //D::id
cout << "[9] D::cd = ";
cout << (char)*((int*)(&dd)+9) << endl;//D::cd
cout << "[10] = 0x";
cout << (int*)*((int*)(&dd)+10) << endl;
//---------------------
cout << "[11] D::B::_vptr->" << endl;
pFun = (Fun)pVtab[11][0];
cout << " [0] "; pFun(); //D::f();
pFun = (Fun)pVtab[11][1];
cout << " [1] "; pFun(); //B::Bf();
pFun = (Fun)pVtab[11][2];
cout << " [2] ";
cout << pFun << endl;
cout << "[12] B::ib = ";
cout << *((int*)(&dd)+12) << endl; //B::ib
cout << "[13] B::cb = ";
cout << (char)*((int*)(&dd)+13) <
下面�l�出�q�行后的�l�果�Q�分VC++和GCC两部份）

    
        
            
            GCC 3.4.4
            
            
            VC++ 2003
            
        
        
            
            [0] B1::_vptr ->
                [0] : D::f()
                [1] : D::f1()
                [2] : B1::Bf1()
                [3] : D::f2()
                [4] : D::Df()
                [5] : 1
            [1] B1::ib1 : 11
            [2] B1::cb1 : 1
            [3] B2::_vptr ->
                [0] : D::f()
                [1] : D::f2()
                [2] : B2::Bf2()
                [3] : 0
            [4] B2::ib2 : 12
            [5] B2::cb2 : 2
            [6] D::id : 100
            [7] D::cd : D
            [8] B::_vptr ->
                [0] : D::f()
                [1] : B::Bf()
                [2] : 0
            [9] B::ib : 0
            [10] B::cb : B
            [11] NULL : 0
            
            
            [0] D::B1::_vptr->
                 [0] D::f1()
                 [1] B1::Bf1()
                 [2] D::Df()
                 [3] 00000000
            [1] = 0x0013FDC4  ç 该地址取值后�?/span>-4
            [2] B1::ib1 = 11
            [3] B1::cb1 = 1
            [4] D::B2::_vptr->
                 [0] D::f2()
                 [1] B2::Bf2()
                 [2] 00000000
            [5] = 0x4539260   ç 该地址取值后�?/span>-4
            [6] B2::ib2 = 12
            [7] B2::cb2 = 2
            [8] D::id = 100
            [9] D::cd = D
            [10]  = 0x00000000
            [11] D::B::_vptr->
                 [0] D::f()
                 [1] B::Bf()
                 [2] 00000000
            [12] B::ib = 0
            [13] B::cb = B
            
        
    

关于虚拟�l�承的运行结果我��׃����d��了（前面的作囑ַ��l�让我��生了很严重的厌倦感�Q�所以就偷个懒了�Q�大家见谅了�Q?/p>
在上面的输出�l�果中，我用不同的颜色做了一些标明。我们可以看到如下的几点�Q?/p>
1�Q�无论是GCC�q�是VC++�Q�除了一些细节上的不同，其大体上的对象布局是一��L��。也���是��_��先是B1�Q�黄�Ԍ���Q�然后是B2�Q�绿�Ԍ���Q�接着是D�Q�灰�Ԍ���Q�而B�q�个���类�Q�青蓝色�Q�的实例都放在最后的位置�?/p>
2�Q�关于虚函数表，���其是第一个虚表，GCC和VC++有很重大的不一栗���但仔细看下来，�q�是VC++的虚表比较清晰和有逻辑性�?/p>
3�Q�VC++和GCC都把B�q�个���类攑ֈ�了最后，而VC++有一个NULL分隔�W�把B和B1和B2的布局分开。GCC则没有�?/p>
4�Q�VC++中的内存布局有两个地址我有些不是很明白�Q�在其中我用�U�色标出了。取其内�Ҏ��-4。接道理来说�Q�这个指针应该是指向B�c�d��例的内存地址�Q�这个做法就是�ؓ了保证重复的父类只有一个实例的技术）。但取值后却不是。这�Ҏ��目前�q��ƈ不太清楚�Q�还向大家请教�?/p>
5�Q�GCC的内存布局中在B1和B2中则没有指向B的指针。这点可以理解，�~�译器可以通过计算B1和B2的size而得出B的偏�U�量�?/p>
�l�束�?/strong>

C++�q�门语言是一门比较复杂的语言�Q�对于程序员来说�Q�我们似乎永�q�摸不清楚这门语�a�背着我们在干了什么。需要熟悉这门语�a��Q�我们就必需要了解C++里面的那些东西，需要我们去了解他后面的内存对象。这��h��们才能真正的了解C++�Q�从而能够更好的使用C++�q�门最隄����~�程语言�?/p>
在文章束之前�q�是介绍一下自己吧。我从事软�g研发有十个年头了�Q�目前是软�g开发技术主���，技术方面，��L��Unix/C/C++�Q�比较喜�Ƣ网�l�上的技术，比如分布式计���，�|�格计算�Q�P2P�Q�Ajax�{�一切和互联�|�相关的东西。管理方面比较擅长于团队������Q�技术趋势分析，��目���理。欢�q�大家和我交���，我的MSN和Email是：haoel@hotmail.com 



天边�?/a> 2010-04-29 19:30 发表评论


Fri, 24 Jul 2009 03:48:00 GMT
     摘要:  
在C++�~�程中，有一点让人挺遗憾的就是C++���不支持正则表达式，�q�让很多用户��Z���~�写支持正则表达式程序而不得不攑ּ�C++。然而，Boost.Regex库填补了C++在这斚w��的空白，它��C++很好的支持各�U�引擎的正则表达式�?       �l�合我的学习�Q�逐步分析Boost.Regex库�?  &nbs...  阅读全文

天边�?/a> 2009-07-24 11:48 发表评论

Status Of C++ 0x Language Features in Compilers
C++ 0x FEATURE	PAPER(S)	HP aCC	EDG eccp	GCC	Intel C++	MSVC	IBM XLC++	Sun/ Oracle C++	Embarcadero C++ Builder	Digital Mars C++	Clang
`alignas`	N2341			4.8							3.0
`alignof`	N2341			4.5					Yes		2.9
Atomic operations	N2427			4.4	13.0	11.0					3.1
`auto`	v0.9: N1984, v1.0: N2546		4.1(v0.9)	4.4(v1.0)	11.0(v0.9)	10.0(v0.9)	11.1 (V1.0)				Yes
C99 preprocessor	N1653			4.3	11.1		10.1	5.9		Yes	Yes
Concepts ^[removed]	N2617			ConceptGcc
`constexpr`	N2235			4.6	13.0		12.1				3.1
`decltype`	v1.0: N2343, v1.1: N3276		4.1(v1.0)	4.3(v1.0) 4.8.1(v1.1)	11.0(v1.0)	10.0(v1.0), 11.0(v1.1)	11.1 (V1.0)		Yes		2.9
Defaulted And Deleted Functions	N2346		4.1	4.4	12.0						3.0
Delegating Constructors	N1986			4.7		11.0 nov'12	11.1				3.0
Explicit conversion operators	N2437			4.5	13.0	11.0 nov'12	12.1		Yes		3.0
Extended `friend` Declarations	N1791		4.1	4.7	11.0	10.0***	V1R11,11.1				2.9
`extern template`	N1987	3, 5, 6		3.3	9	6.0	V1R11,11.1		Yes		Yes
Forward declarations for enums	N2764			4.6		11.0	12.1				3.1
Inheriting Constructors	N2540			4.8
Initializer Lists	N2672			4.4	13.0	11.0 nov'12					3.1
Lambda expressions and closures	v0.9: N2550, v1.0: N2658, v1.1: N2927		4.1(v0.9)	4.5(v1.1)	11.0(v0.9) 12.0(v1.0)	10.0(v1.0), 11.0(v1.1)					3.1
Local and Unnamed Types as Template Arguments	N2657			4.5	12.0	10.0					2.9
`long long`	N1811	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes
Namespace Association	N2535			4.4			11.1				2.9
New character types	N2249			4.4							2.9
New function declaration syntax for deduced return types	N2541		4.1	4.4	12.1	10.0	12.1				2.9
`nullptr`	N2431			4.6	12.1*	10.0					2.9
Unicode String Literals	N2442			4.4	11.0*			5.7	Yes		3.0
Raw String Literals	N2442			4.5		11.0 nov'12					Yes
User-defined Literals	N2765			4.7							3.1
Right Angle Brackets	N1757		4.1	4.3	11.0	8.0	12.1				Yes
R-Value References, std::move	v1.0: N2118, v2.0: N2844, v2.1: N2844+, v3.0: N3053		4.1(v1.0)	4.3(v1.0) 4.5(v2.1) 4.6(v3.0)	11.1(v1.0) 12.0(v2.0)	10.0(v2.0), 11.0(v2.1)	12.1(v2.1)		Yes		Yes
`static_assert`	N1720		4.1	4.3	11.0	10.0	11.1		Yes		2.9
Strongly-typed `enum`s	N2347			4.4	12.0	11.0	12.1		Yes		2.9
Template aliases	N2258			4.7	12.1						3.0
Thread-Local Storage	N2659			4.8 (4.4****)	11.1***	10.0***		5.9***			2.9****
Unrestricted Unions	N2544			4.6							3.0
Built-in Type Traits	N1836	6.16	4.0	4.3	10.0	8.0			Yes		3.0
Variadic Templates	v0.9: N2242, v1.0: N2555		4.1(v0.9)	4.3(v0.9) 4.4(v1.0)	12.1(v0.9)	11.0 nov'12	11.1 (v0.9)				2.9(1.0)
Range-based for-loop	N2930			4.6	13.0	11.0					3.0
override and final	v0.8: N2928, v0.9: N3206, v1.0: N3272			4.7	12.0(v0.8)***	8.0(v0.8)*** 11.0(v1.0)					2.9
Attributes	N2761			4.8	12.1
ref-qualifiers	N2439			4.8.1							2.9
Non-static data member initializers	N2756			4.7							3.0
Dynamic initialization and destruction with concurrency (Magic statics)	N2660			4.3	?						2.9

午夜精品久久久久,日韩午夜免费,一区二区三区免费网站

Sequoiadb与spark�Ҏ��步骤

RDD初探

[转]The Biggest Changes in C++11

自动�c�d��推导 auto

自动化推�?decltype

auto �?decltype 的差别和关系

�l�一的初始化语法

Delete �?Default 函数

nullptr

叛_��引用和move语义

新型�����指针

新的���法

各编译器对于C++11新特性的支持情况

gprof——GNU性能分析工具

gprof介绍

为gprof�~�译�E�序

Gprof基本用法�Q?/em>

命��o格式

【�{】浅析系�l�的大小端模�?

二、�D例说�?/span>

三、��用代码判断大���端模式

【�{】TCP三次握手/四次挥手详解

B+数的实现--优秀代码

[转]C++ 对象的内存布局

新型��指针

新的��法

三、��用代码判断大��端模式