国产精品v日韩精品v欧美精品网站,久久午夜激情,久久偷看各类wc女厕嘘嘘偷窃

侃一侃vc的std::string

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

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

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

我的�q�_��是XP+VC9.0�Q�运行结果是32�Q�不知道��Z��么要那么多，于是在源代码里捣鼓了一番，�怹�之后�l�于有了一点眉目，下面是我的一些�ȝ��?br />

一�Q�结构布局
string的原型是

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

它是basic_string一个typedef�Q�首先来看basic_string的类层次�l�构�Q?br />
_Container_base_secure
       /\
       |
_String_base
       /\
       |
_String_val
       /\
       |
basic_string

_Container_base_secure里有一个_Iterator_base�c�d��的指针成员_Myfirstiter�Q�得�?个字节，_String_base没有数据成员�Q�_String_val里有一个_Alval�c�d��Q�一个allocator�Q�的成员_Alty�Q�没有数据成员，只占�?个字节，加上padding�Q�也��是4个字节，basic_string�?个数据成员，一个union�?6个字节，两个跟长度相关的整型变量�?个字节。所有类都不含虚函数�Q�布局如下�Q?br />

_Container_base_secure
    _Myfirstiter�Q�_Iterator_base*  (4 bytes)

_String_base (nop)

_String_val
      _Alty�Q�_Alval  (1 byte +3 bytes padding)

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

�q�个是basic_string的union:

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

通过�q�个union可以看出vc的std::string在字�W�串长度较小的时候会使用一个栈上缓冲区�Q�_Bxty::_Buf�Q�来保存字符串内容，如果字符串长度超�q�了某个范围则会使用allocator分配动态内�?_Bxty::_Ptr)�Q�_BUF_SIZE控制着�q�个范围��|��_Buf�~�冲区始�l�是16个字节大��。可以看出，vc的std::string没有使用通用Copy-On-Write技术，因�ؓ它没有reference count成员。那么vc采用的这个技术对于字�W�串的��用效率在实际使用中表现如何呢�Q?br />
下面是一�D�|��试拷贝不同字�W�串长度的代�?

#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; // 一百万��?br />
    // 预先分配好内�?br />    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版全默认参数�Q�结果如下：

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

在字�W�串(包含0�l�尾字符)��于16个字节的时候消耗的旉��都很低而且几乎一�?94ms)�Q�而一旦超�q�了16个字节消耗时间则�q�速增加，变成�?22ms�Q�近5倍）。可以看出，如果使用长度较小的字�W�串�Q�在涉及大量拯��处理的时候，vc�q�个技巧的效率�q�是挺高的�?br />

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

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

速度增长很��^均，�?6字节以下的时候用时比vc多，但是��过16字节后效率比vc高（�l�节没去研究�Q��?br />

二，虚析构函�?br />
basic_string和它的基�c�_Container_base_secure的析构函数都不是virutual function�Q�这在��承的时候会有副作用�Q�先看下面这�D�代码：

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

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

没有虚函数所以析构函数无法动态绑定，上面的代码运行到delete时将直接调用std::string的析构函敎ͼ�而不会去找mystring的析构函数。如果~mystring涉及到资源释攄��话，那么无疑上面的代码将��D��泄漏�?br />
�q�有一点值得一提的��是对std::string或包含std::string的对象实施ZeroMemory

虽然大多数合格的C++�E�序员都知道不应该对非POD对象实施ZeroMomory�Q�但是在工程实际中确实有�q�样的代码，而且他们�q�行的很正常(vc++�?�Q�这是�ؓ什么呢�Q�我试图做一个简单解释�?br />
如上所�q�ͼ�std::string的��承体�p�里没有virtual function�Q�对象布局里也��没有vptr�Q�而且整个�l�承体系都采用的是单�l�承�Q�bptr又省了（参考Lippman�?lt;Inside C++ Object Model>�Q�，所以std::string对象的布局全是它的自��n的数据成员，_Container_base_secure的_Myfirstiter是指针成员，本��n在初始化时就需要置�Ӟ��_String_val的_Alval成员是个allocator�Q�只有函��C��包含数据�Q�调用时也就不必传this指针�Q�所以给它置零不会有副作用，basic_string指针本��n的三个成员分别是�~�冲区，字符串长度和预留长度�Q�初始化时将它们�|�零也是没有副作用的。所以对std::string�q�行ZeroMemory操作的代码依然运行的很正常�?br />

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

有趣的条件运��符

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

一�Q�缘�?br />
�q�_��都是把条件运��符当作��化if/else代码行数的另一�U��Ş式，今天偶然写下了下面这砣代码，��是让第二个和第三个表达式的��h��不同�c�d��Q�看看sizeof的结果：

#include <iostream>

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

�l�果�? Type size: 8

二，�l�节

一�?a >条�g操作�W?/a>是下面这��L��形式:

exp1 ? exp2 : exp3

表达式exp1��L��会被求倹{��exp2和exp3是否被执行依赖于exp1的��|��如果exp1为真则exp2会被求��|��否则exp3被求倹{�?br />

Side Effect:

在执行exp2或者exp3之前�Q�exp1的所有side effect必须全部求值或者更新完成，因�ؓ条�g操作�W�的�W�一个操作数求��g��后就是一�?a >sequence point。如果exp2和exp3都有side effect�Q�那么只有一个会被求倹{�?br />

�q�回�c�d��Q?br />
条�g操作�W�的�q�回�c�d��取决于exp2和exp3�c�d��Q�编译器会检查exp2�Q�可能是一个class type�Q�能否�{换�ؓexp3或者exp3能否转换为exp2�Q�如果两个都不满��I��~�译器就会抛��Z��个错误�?br />

三，实践

只要exp2或expr3能�{换�ؓ�Ҏ(gu��)��的类型，那么条�g操作�W�就可以通过�~�译器，如果它们之间没有能够转换的规则，自然�q�不了编译器�q�一养I��如下面这行代�?

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

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

��Z��利用C++�l�我们提供的强类型支持，我们应该在实践中让exp2和exp3的类型保持一致�?br />
另外�Q?a >BOOST_FOREACH里面用到了条件操作符的这个技巧来萃取容器表达式类型，同时避免对表辑ּ�求��|��以此辑ֈ�对rvalue的完��支持，其中的代码如下：

// �c�d��包装�?/span>

template< class T > struct type2type {};

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

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

// ��表辑ּ�的类型�{换�ؓtype2type< expression>�Q��ƈ避免对 expression求�?/span>
#define ENCODED_TYPEOF( expression )         ( true ? any_type() : encode_type( expression ) )

ENCODED_TYPEOF(expression)会被展开�?(true ? any_type() : encode_type(expression))�Q�exp2的类型�ؓany_type�Q�exp3的类型�ؓtype2type�Q�两个表辑ּ�的类型要一��_��type2type又不能�{换�ؓany_type�Q�所以只有给any_type定义一个�{换操作符�Q�让any_type能够转换为type2type�?br />
最后我们得到ENCODE_TYPEOF(expression)的类型�ؓtype2type< expression>�Q��ƈ且没有对 expression求倹{�?br />

参�?

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

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

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

一�Q?br /> 当我们的�E�序调用函数的时候，�pȝ��会首先将函数的参数按照从双��左的��序压入函数的栈中。如果底层的C语言实现让函数参数在内存中连�l�存储，那么我们只需要知道当前参数的地址�Q�就可以依次讉K��参数列表中的其他参数�?br />
�q�里��Z��举例方便�Q�假设传递的3个都是int�c�d��的参数。代码：

//fun: 打印n后面参数的�?/span>
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的�?/span>
    printf("%d \n", *++p);      //打印par3的�?/span>
}

C默认的函数调用规范是__cdecl,也就是所有参��C��叛_��左依�ơ入栈，严格的fun声明应该�?

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

�׃��入栈��序是从叛_��左，所以main�l�传递的par1,par2和par3的入栈顺序是�Q?br /> push    par3
push    par2
push    par1

当然汇编代码(wintel)更可能是�Q?br /> mov         eax,dword ptr [par3]
push        eax
mov         ecx,dword ptr [par2]
push        ecx
mov         edx,dword ptr [par1]
push        edx

最后再call fun,执行函数体的代码�?br />
先压栈的参数会放在高地址�Q�因为栈是由上往下生长的�Q�所以par1�Q�par2�Q�par3在内存中的顺序将会是�Q?br /> 0xFE6C        par3
0xFE70         par2
0xFE74         par1

地址是假设，但距��d��该是sizeof(int)的�?4个字�?�?br />
另外�Q�标准库里的printf一族的库函�?sprintf, fprintf)那样接受可变参数个数的函��C��只有用cdecl才能够实现。假设有下面一行语句：

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

可以看到它是通过把参数的个数和类型保存在�W�一个参数来实现正确��d��的。格式符%d指定了要��d��的类型，而格式符的数目指定了传递参数的个数。这��是��Z��么printf("%d %d \n", m, n, k)可以成功执行�Q�而printf("%d %d %d \n", m, n)会失败的原因。传递的参数多于需要处理的数目时可以忽略掉�Q�但是少于需要处理的数目时就讉K��界了�?br />

二，

我们通常会��用C语言的varargs宏来�~�写支持可变参数列表的函敎ͼ�在ANSI C标准里，�q�些宏包含在头文仉��?br />
下面再分析一下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提供的实��C��Q�可以看到这��L��定义�Q?br />

#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型指针，每次单个字节��d��?
va_start    通过_INTSIZEOF计算�c�d��的大��，�q�让ap获得v后面参数对象的地址
va_arg    ap指向参数列表中ap下一个参数对象，�q�返回ap之前指向的t�c�d��参数对象

��va_list�{�宏�q�原后会更明白一点：

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);
}

�Ҏ(gu��)��q�个实现�Q�va_arg的第二个参数若�ؓchar, short则会被�{换�ؓint�c�d��Q�若为float则会转换为doule�c�d��Q�这是因为_INTSIZEOF宏的�q�回�?4�?)的原因，毕竟宏用C来做泛型�q�是不如C++的模板来的好�?br />

三，

�Ҏ(gu��)��标准库提供的va_list我们可以实现自己的能接受可变参数的列表的函数�Q�下面以Win32API中的MessageBox作�ؓ试验�?br /> 在windows�E�序设计中有时候也需要输��Z��些调试信息，但是�q�个时候如果根据在控制��C��的编�E�习惯��用printf()函数来实现将信息输出到窗口的话是比较�ȝ��的，�q�样可以选择一个最��单的Windows�H�口函数MessageBox。但是MessageBox()的参数类型是字符�Ԍ��所以我们需�? 对它做一些格式化。这��需要用到标准库的vsprintf函数(�q�里)�?br />

#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 发表评论

国产精品v日韩精品v欧美精品网站,久久午夜激情,久久偷看各类wc女厕嘘嘘偷窃

侃一侃vc的std::string

有趣的条件运���符

有趣的条件运��符