C++ Built-In Array 的语义

C++ 编译花了大量精力使得class和原始类（primitive types）的用法一致。比如array的应用：

A a[100]；// A is class

int b[100]；

虽然a是用户定义的类的对象，但是用起来与整数型的array相比并无差别。我们现在看看语义上的差别。

A 是POD类（完全具有值语义的类）

如果A是具有值语义的POD（参见我关于值语义的博客：http://www.cnblogs.com/ly8838/p/3929025.html ），测试显示A 的创建和读写与一般变量没有任何差别，当然性能也不会有差别。

也就是说，A a[3] ；和 A a1， a2，a3；在语义上完全一样，也没有丝毫性能上的区别。

A 是有默认的构造函数（但没有destructor）的类

我们有一个简单的struct：

struct StackObject

{

int _a;

int _b;

StackObject(): _a(0), _b(1)

{

}

};

和简单的测试函数：

void TestArraySemantics()

{

StackObject sa[10]; //line 1：call vector constructor iterator

sa[0]._a= 1;

sa[9]._b = 10;

}

在VC++2010中运行时，我们看到line1调用了编译自生的函数。这是一个通用的“矩阵构造循环（vector constructor iterator）”:

它的大致实施如下：

void Vector_constructor_iterator(

int array_size,

int array_element_size,

void (*Ctr)(void *addr),

char *arrayStartAddress)

{

for(int i = 0; i < array_size; ++i)

{

void *objAddr = arrayStartAddress + i * array_element_size;

Ctr(objAddr);

}

这是一个典型的 C 函数，它将 StackObject 的构造函数作为函数指针进行调用。

从这个函数来看，它使得A a[3]；和A a1，a2， a3；的语义发生了根本变化。我们不但要调用编译产生的函数，还要用指针间接地调用StackObject的构造函数。测试结果显示，用array比不用array的“构造”速度大约下降30%。考虑到array的应用价值，这个速度的下降是可以理解和接受的。

A 是有默认构造函数以及destructor的类

加了destructor后，A a[10] 的语义又有了新的变化。如果读了我的上篇关于异常处理的博客（http://www.cnblogs.com/ly8838/p/3961119.html ）可知：编译必须保证所有创建的object“全部”被摧毁，所以它必须“记住”创建过程中的热点。

我们加另一个dummy 类，来测试destructor对array 的影响：

struct StackObject2

{

int _a;

int _b;

StackObject2(): _a(0), _b(1)

{

}

~StackObject2()

{

_a = _b = 0;

}

};

我们的测试函数改为

void TestArraySemantics()

{

clock_t begin = clock();

for (int i = 0; i < 100000; ++i)

{

StackObject sa[3]; //line1：test without d’tr

sa[0]._a= 1;

sa[1]._b = 2;

sa[2]._b = 3;

}

clock_t end = clock();

auto spent = double(end - begin) / CLOCKS_PER_SEC;

printf("spent for 'array' is %f\n", spent);

begin = clock();

for (int i = 0; i < 100000; ++i)

{

StackObject2 sa[3]; //line2：test with d’tr

sa[0]._a= 1;

sa[1]._b = 2;

sa[2]._b = 3;

}

end = clock();

spent = double(end - begin) / CLOCKS_PER_SEC;

printf("spent for 'array with dtro' is %f\n", spent);

begin = clock();

for (int i = 0; i < 100090; ++i)

{

StackObject sa1, sa2, sa3; //line3：test without array

sa1._a= 1;

sa2._b = 2;

sa3._b = 3;

}

end = clock();

spent = double(end - begin) / CLOCKS_PER_SEC;

printf("spent for 'none-array' is %f\n", spent);

}

上面的line2试图创建带有destructor的StackObject2类的array. 在VC++，我们注意到这时编译产生另一名字稍稍不同的函数“eh vector constructor iterator”，然而察看生成的代码，发现它和vector constructor iterator大大不同了。它的伪码大致如此：

void Vector_constructor_iterator_with_dtor(

int array_size,

int array_element_size,

void (*Ctr)(void *addr),

void (*Dtr)(void *addr),

char *arrayStartAddress)

{

int lastCreated = -1;

try

{

for(int i = 0; i < array_size; ++i)

{

void *objAddr = arrayStartAddress + i * array_element_size;

Ctr(objAddr);

lastCreated = i;

}

catch(...)

{

// destroy partially created array in case or fault

for(int i = 0; i <= lastCreated; ++i)

{

void *objAddr = arrayStartAddress + i * array_element_size;

Dtr (objAddr);

}

比较伪码我们看出：Vector_constructor_iterator_with_dtor 和　Vector_constructor_iterator　的主要区别是增加了异常处理的机制，用来销毁“已经构造”的矩阵元素。

运行　TestArraySemantics　表明，带有destructor的类的array构造速度下降了近　300%。

所以，去除不必要的destructor的重要性又一次充分体现。

结论

C++ built-in array对class object的支持是十分重要的语言构造，它是C++把class object和原始变量同样对待的又一反映，它大大增加了C++的附加值。

然而我们一如既往，需要对C++这一语言构造的语义深入了解。以便正确使用C++ built-in array。