C++博客-半瓶醋-随笔分类-C++

侃一侃vc的std::string

johnny chan — Sat, 02 Apr 2011 14:51:00 GMT

那天心血来潮敲下了这坨代码：

cout << sizeof(std::string) << endl;

我的平台是XP+VC9.0，运行结果是32，不知道为什么要那么多，于是在源代码里捣鼓了一番，许久之后终于有了一点眉目，下面是我的一些总结。

一，结构布局
string的原型是

typedef basic_string<char, char_traits<char>, allocator<char> > string;

它是basic_string一个typedef，首先来看basic_string的类层次结构：

_Container_base_secure
       /\
       |
_String_base
       /\
       |
_String_val
       /\
       |
basic_string

_Container_base_secure里有一个_Iterator_base类型的指针成员_Myfirstiter，得占4个字节，_String_base没有数据成员，_String_val里有一个_Alval类型（一个allocator）的成员_Alty，没有数据成员，只占用1个字节，加上padding，也就是4个字节，basic_string有3个数据成员，一个union占16个字节，两个跟长度相关的整型变量各4个字节。所有类都不含虚函数，布局如下：

_Container_base_secure
    _Myfirstiter：_Iterator_base*  (4 bytes)

_String_base (nop)

_String_val
      _Alty：_Alval  (1 byte +3 bytes padding)

basic_string
    _Bx        :   _Bxty       (16 bytes)
    _Mysize :   size_type   (4 bytes)
    _Myres ：  size_type   (4 bytes)

这个是basic_string的union:

enum{ _BUF_SIZE = 16 / sizeof (_Elem) < 1 ? 1 : 16 / sizeof(_Elem)};
union _Bxty
{
_Elem _Buf[_BUF_SIZE];
_Elem* _Ptr;
} _Bx;

通过这个union可以看出vc的std::string在字符串长度较小的时候会使用一个栈上缓冲区（_Bxty::_Buf）来保存字符串内容，如果字符串长度超过了某个范围则会使用allocator分配动态内存(_Bxty::_Ptr)，_BUF_SIZE控制着这个范围值，_Buf缓冲区始终是16个字节大小。可以看出，vc的std::string没有使用通用Copy-On-Write技术，因为它没有reference count成员。那么vc采用的这个技术对于字符串的使用效率在实际使用中表现如何呢？

下面是一段测试拷贝不同字符串长度的代码:

#include <windows.h>
#include <stdio.h>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

template <size_t N>
void test_string()
{
    const size_t loop = 1000000; // 一百万次

    // 预先分配好内存
    vector<string> vec;
    vec.resize(loop);

    char szbuf[N] = {};
    memset(szbuf, 'a', N - 1);

    // 计算拷贝时间
    size_t time = GetTickCount();
    for (int i = 0; i < loop; ++i)
    {
        vec[i] = szbuf;
    }
    time = GetTickCount() - time;

    printf("buffer size: %u, loop: %u, used %u ms\n", N, loop, time);
}

int main(int argc, char* argv[])
{
    test_string<8>();
    test_string<12>();
    test_string<16>();
    test_string<20>();
    test_string<24>();
    test_string<32>();

    return 0;
}

编译使用release版全默认参数，结果如下：

buffer size: 4, loop: 1000000, used 78 ms
buffer size: 8, loop: 1000000, used 94 ms
buffer size: 12, loop: 1000000, used 93 ms
buffer size: 16, loop: 1000000, used 94 ms
buffer size: 20, loop: 1000000, used 422 ms
buffer size: 24, loop: 1000000, used 422 ms
buffer size: 32, loop: 1000000, used 438 ms

在字符串(包含0结尾字符)小于16个字节的时候消耗的时间都很低而且几乎一致(94ms)，而一旦超过了16个字节消耗时间则迅速增加，变成了422ms（近5倍）。可以看出，如果使用长度较小的字符串，在涉及大量拷贝处理的时候，vc这个技巧的效率还是挺高的。

下面是相同代码采用使用了Copy-On-Write技术的GNU std::string的运行结果（Ubuntu + gcc4.4 + -O2参数）：

buffer size: 8, loop: 1000000, used 140 ms
buffer size: 12, loop: 1000000, used 119 ms
buffer size: 16, loop: 1000000, used 140 ms
buffer size: 20, loop: 1000000, used 126 ms
buffer size: 24, loop: 1000000, used 154 ms
buffer size: 32, loop: 1000000, used 129 ms

速度增长很平均，在16字节以下的时候用时比vc多，但是超过16字节后效率比vc高（细节没去研究）。

二，虚析构函数

basic_string和它的基类_Container_base_secure的析构函数都不是virutual function，这在继承的时候会有副作用，先看下面这段代码：

class mystring : public std::string
{
public:
    ~mystring()
    {
        cout << "dctor" << endl;
    }
};

void main()
{
    std::string* pstr = new mystring();
    delete pstr; // ~mystring()没有被调用
}

没有虚函数所以析构函数无法动态绑定，上面的代码运行到delete时将直接调用std::string的析构函数，而不会去找mystring的析构函数。如果~mystring涉及到资源释放的话，那么无疑上面的代码将导致泄漏。

还有一点值得一提的就是对std::string或包含std::string的对象实施ZeroMemory

虽然大多数合格的C++程序员都知道不应该对非POD对象实施ZeroMomory，但是在工程实际中确实有这样的代码，而且他们运行的很正常(vc++下)，这是为什么呢？我试图做一个简单解释。

如上所述，std::string的继承体系里没有virtual function，对象布局里也就没有vptr，而且整个继承体系都采用的是单继承，bptr又省了（参考Lippman的），所以std::string对象的布局全是它的自身的数据成员，_Container_base_secure的_Myfirstiter是指针成员，本身在初始化时就需要置零，_String_val的_Alval成员是个allocator，只有函数不包含数据，调用时也就不必传this指针，所以给它置零不会有副作用，basic_string指针本身的三个成员分别是缓冲区，字符串长度和预留长度，初始化时将它们置零也是没有副作用的。所以对std::string进行ZeroMemory操作的代码依然运行的很正常。

johnny chan 2011-04-02 22:51 发表评论

有趣的条件运算符

johnny chan — Mon, 28 Mar 2011 15:02:00 GMT

一，缘起

平常都是把条件运算符当作简化if/else代码行数的另一种形式，今天偶然写下了下面这砣代码，就是让第二个和第三个表达式的具有不同类型，看看sizeof的结果：

#include <iostream>

int main()
{
    int n = sizeof(( true ? 3 : 3.14);    // 不同的类型
    printf(“Type size: %d\n”, n);
    return 0;
}

结果是: Type size: 8

二，细节

一个条件操作符是下面这样的形式:

exp1 ? exp2 : exp3

表达式exp1总是会被求值。exp2和exp3是否被执行依赖于exp1的值，如果exp1为真则exp2会被求值，否则exp3被求值。

Side Effect:

在执行exp2或者exp3之前，exp1的所有side effect必须全部求值或者更新完成，因为条件操作符的第一个操作数求值之后就是一个sequence point。如果exp2和exp3都有side effect，那么只有一个会被求值。

返回类型：

条件操作符的返回类型取决于exp2和exp3类型，编译器会检查exp2（可能是一个class type）能否转换为exp3或者exp3能否转换为exp2，如果两个都不满足，编译器就会抛出一个错误。

三，实践

只要exp2或expr3能转换为对方的类型，那么条件操作符就可以通过编译器，如果它们之间没有能够转换的规则，自然过不了编译器这一关，如下面这行代码:

sizeof(true ? “text” : 3.14); // error

sizeof(true ? “text” : 0); // OK, bug or feature?

为了利用C++给我们提供的强类型支持，我们应该在实践中让exp2和exp3的类型保持一致。

另外，BOOST_FOREACH里面用到了条件操作符的这个技巧来萃取容器表达式类型，同时避免对表达式求值，以此达到对rvalue的完美支持，其中的代码如下：

// 类型包装器

template< class T > struct type2type {};

// 转换T到type2type
template< class T >
type2type< T > encode_type( T const & t )
{
    return type2type< T >();
}

// 定义了到any2type的转换
struct any_type
{
    template< class T >
    operator type2type< T > () const
    {
        return type2type< T >();
    }
};

// 将表达式的类型转换为type2type< expression>，并避免对 expression求值
#define ENCODED_TYPEOF( expression )         ( true ? any_type() : encode_type( expression ) )

ENCODED_TYPEOF(expression)会被展开为 (true ? any_type() : encode_type(expression))，exp2的类型为any_type，exp3的类型为type2type，两个表达式的类型要一致，type2type又不能转换为any_type，所以只有给any_type定义一个转换操作符，让any_type能够转换为type2type。

最后我们得到ENCODE_TYPEOF(expression)的类型为type2type< expression>，并且没有对 expression求值。

参考:

http://drdobbs.com/cpp/184401310
http://geeksforgeeks.org/?p=9205
http://www.artima.com/cppsource/foreach2.html

johnny chan 2011-03-28 23:02 发表评论

C的可变参数列表

johnny chan — Sun, 21 Jun 2009 15:34:00 GMT

一，
当我们的程序调用函数的时候，系统会首先将函数的参数按照从右自左的顺序压入函数的栈中。如果底层的C语言实现让函数参数在内存中连续存储，那么我们只需要知道当前参数的地址，就可以依次访问参数列表中的其他参数。

这里为了举例方便，假设传递的3个都是int类型的参数。代码：

//fun: 打印n后面参数的值
void fun(int n, );

int main()
{
    int par1 = 128;
    int par2 = 256;
    int par3 = 512;
    fun(par1, par2, par3 );
    return 0;
}

void fun(int par1, )
{
    int* p = &par1;             //获取par1的地址
    printf("%d \n", *++p);      //打印par2的值
    printf("%d \n", *++p);      //打印par3的值
}

C默认的函数调用规范是__cdecl,也就是所有参数从右到左依次入栈，严格的fun声明应该是:

void __cdecl fun(int n, ...);

由于入栈顺序是从右向左，所以main给传递的par1,par2和par3的入栈顺序是：
push    par3
push    par2
push    par1

当然汇编代码(wintel)更可能是：
mov         eax,dword ptr [par3]
push        eax
mov         ecx,dword ptr [par2]
push        ecx
mov         edx,dword ptr [par1]
push        edx

最后再call fun,执行函数体的代码。

先压栈的参数会放在高地址，因为栈是由上往下生长的，所以par1，par2，par3在内存中的顺序将会是：
0xFE6C        par3
0xFE70         par2
0xFE74         par1

地址是假设，但距离应该是sizeof(int)的值(4个字节)。

另外，标准库里的printf一族的库函数(sprintf, fprintf)那样接受可变参数个数的函数也只有用cdecl才能够实现。假设有下面一行语句：

printf("%d %d %d \n", m, n, k);

可以看到它是通过把参数的个数和类型保存在第一个参数来实现正确寻址的。格式符%d指定了要读取的类型，而格式符的数目指定了传递参数的个数。这就是为什么printf("%d %d \n", m, n, k)可以成功执行，而printf("%d %d %d \n", m, n)会失败的原因。传递的参数多于需要处理的数目时可以忽略掉，但是少于需要处理的数目时就访问越界了。

二，

我们通常会使用C语言的varargs宏来编写支持可变参数列表的函数，在ANSI C标准里，这些宏包含在头文件里。

下面再分析一下varargs宏，增加varargs宏后的代码：

#include stdio.h>
#include stdarg.h>

void __cdecl fun(int n, );

int main()
{
    int par1 = 128;
    int par2 = 256;
    int par3 = 512;
    fun(par1, par2, par3 );
    return 0;
}

void fun(int n, )
{
    va_list ap;
    va_start(ap, n);
    printf("%d \n", va_arg(ap, int));
    printf("%d \n", va_arg(ap, int));
    va_end(ap);
}

在Microsoft为VC提供的实现中，可以看到这样的定义：

#define _ADDRESSOF(v)   ( &(v) )
#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
typedef char* va_list;
#define va_start(ap,v) ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap)      ( ap = (va_list)0 )

va_list     一个char型指针，每次单个字节寻址。
va_start    通过_INTSIZEOF计算类型的大小，并让ap获得v后面参数对象的地址
va_arg    ap指向参数列表中ap下一个参数对象，并返回ap之前指向的t类型参数对象

将va_list等宏还原后会更明白一点：

void fun(int par1, )
{
    int par2, par3;
    char*   ap;                         //va_list ap;
    ap = (char*)&par1 + 4;      //va_start(ap, par1);
    par2 = *(int*)(ap+=4 - 4); //m = va_arg(ap, int);
    par3 = *(int*)(ap+=4 - 4); //m = va_arg(ap, int);
    ap = (char*)0;                   //va_end(ap);
}

根据这个实现，va_arg的第二个参数若为char, short则会被转换为int类型，若为float则会转换为doule类型，这是因为_INTSIZEOF宏的返回值(4或8)的原因，毕竟宏用C来做泛型还是不如C++的模板来的好。

三，

根据标准库提供的va_list我们可以实现自己的能接受可变参数的列表的函数，下面以Win32API中的MessageBox作为试验。
在windows程序设计中有时候也需要输出一些调试信息，但是这个时候如果根据在控制台下的编程习惯使用printf()函数来实现将信息输出到窗口的话是比较麻烦的，这样可以选择一个最简单的Windows窗口函数MessageBox。但是MessageBox()的参数类型是字符串，所以我们需要对它做一些格式化。这就需要用到标准库的vsprintf函数(这里)。

#include stdio.h>       // vsprintf()
#include stdarg.h>      // va_list, va_start(), va_end()
#include windows.h>     // MessageBoxA()

void my_messagebox(const char* format, )
{
    char        buffer[MAX_PATH] = {0};//260个字节的缓冲
    va_list     ap;
    va_start(ap, format);
    vsprintf(buffer, format, ap);
    va_end(ap);
    ::MessageBoxA(NULL, buffer, "", MB_OK);//ANSCII版本的MessageBox()
}

johnny chan 2009-06-21 23:34 发表评论