欧美一区二区视频免费观看,国产一区在线播放,欧美另类极品videosbest最新版本

sheng — Tue, 06 Nov 2018 08:59:00 GMT

#include
#include

#include
using namespace std;
int utf8togb2312(const char *sourcebuf,size_t sourcelen,char *destbuf,size_t destlen) {

iconv_t cd;

if( (cd = iconv_open("gb2312","utf-8")) ==0 )

      return -1;

memset(destbuf,0,destlen);

const char **source = &sourcebuf;

char **dest = &destbuf;
if(-1 == iconv(cd,source,&sourcelen,dest,&destlen))

     return -1;

iconv_close(cd);

return 0;

}
int gb2312toutf8(const char *sourcebuf,size_t sourcelen,char *destbuf,size_t destlen) {

iconv_t cd;   if( (cd = iconv_open("utf-8","gb2312")) ==0 )

return -1;   memset(destbuf,0,destlen);

const char **source = &sourcebuf;

char **dest = &destbuf;
  if(-1 == iconv(cd,source,&sourcelen,dest,&destlen))

return -1;

sheng 2018-11-06 16:59 发表评论

sheng — Fri, 26 Aug 2016 08:46:00 GMT

摘要: 转蝲自http://blog.csdn.net/u010984552/article/details/51887108��Z��么需要线�E�池目前的大多数�|�络服务器，包括Web服务器、Email服务器以�?qi��ng)数据库服务器等都具有一个共同点�Q�就是单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短�?nbsp;�?�l�多�U�程�Ҏ(gu��)��中我们采用的服务器模型则是一旦接受到��h��之后�Q�即创徏一个新的线�E�，��p��U�程执行�?.. 阅读全文

sheng 2016-08-26 16:46 发表评论

sheng — Wed, 17 Aug 2016 06:21:00 GMT

摘自http://blog.csdn.net/hackbuteer1/article/details/7722667

�?各种计算��Z��pȝ��构中�Q�对于字节、字�{�的存储机制有所不同�Q�因而引发了计算�?通信�?域中一个很重要的问题，即通信双方交流的信息单元（比特、字节、字、双字等�{�）应该以什么样的顺序进行传送。如果不达成一致的规则�Q�通信双方��无法进行正 ��的�~?译码从而导致通信��p�|。目前在各种体系的计��机中通常采用的字节存储机制主要有两种�Q�Big-Endian和Little-Endian�Q�下面先从字节序说�v�?br />一、什么是字节�?br />字节序，��֐�思义字节的顺序，再多说两句就是大于一个字节类型的数据在内存中的存��N��?一个字节的数据当然��无需谈顺序的问题�?�?/span>其实大部分�h在实际的开发中都很��会(x��)直接和字节序打交道。唯有在跨��^��C��?qi��ng)网�l�程序中字节序才是一个应该被考虑的问题�?br />
在所有的介绍字节序的文章中都�?x��)提到�?节序分�ؓ(f��)两类�Q�Big-Endian和Little-Endian�Q�引用标准的Big-Endian和Little-Endian的定义如下：(x��)
a) Little-Endian��是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端�?br />b) Big-Endian��是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端�?br />c) �|�络字节序：(x��)TCP/IP各层协议��字节序定义为Big-Endian�Q�因此TCP/IP协议中��用的字节序通常�U�C��为网�l�字节序�?br />
1.1 什么是�?低地址�?br />首先我们要知道C�E�序映像中内存的�I�间布局情况�Q�在《C�?家编�E�》中或者《Unix环境高��~�程》中有关于内存空间布局情况的说明，大致如下图：(x��)
----------------------- 最高内存地址 0xffffffff
栈底
�?br />栈顶
-----------------------

NULL (�I�洞)
-----------------------
�?br />-----------------------
未初�?化的数据
----------------------- �l�称数据�D?br />初始化的数据
-----------------------
�?文段(代码�D?
----------------------- 最低内存地址 0x00000000
由图可以看出�Q�再内存分布中，栈是向下增长的，而堆是向上增长的�?/span>
以上图�ؓ(f��)例如果我们在�?上分配一个unsigned char buf[4]�Q�那么这个数�l�变量在栈上是如何布局的呢�Q�看下图�Q?br />栈底 �Q�高地址�Q?/span>
----------
buf[3]
buf[2]
buf[1]
buf[0]
----------
栈顶 �Q�低地址�Q?/strong>
其实�Q�我们可以自己在�~�译器里面创��Z��个数�l�，然后分别输出数组�U�每个元素的地址�Q�来验证一下�?br />1.2 什么是�?低字�?br />现在我们弄清了高/低地址�Q�接着考虑�?低字�?/span>。有些文章中�U�C��位字节�ؓ(f��)最低有效位�Q�高位字节�ؓ(f��)最高有效位。如果我们有一�?2位无�W�号整型0x12345678�Q�那么高位是什么，低位又是什么呢�Q?其实很简单�?span style="color: #ff0000;">在十�q�制中我们都说靠左边的是高位�Q�靠双��的是低位�Q�在其他�q�制也是如此。就�?0x12345678来说�Q�从高位��C��位的字节依次�?x12�?x34�?x56�?x78�?/strong>
�?低地址端和�?低字节都弄清了。我们再来回��?一下Big-Endian和Little-Endian的定义，�q�用囄��说明两种字节序：(x��)
以unsigned int value = 0x12345678��Z��Q�分别看看在两种字节序下其存储情况，我们可以用unsigned char buf[4]来表�C�value�Q?br />Big-Endian: 低地址存放高位�Q�如下图�Q?br />栈底 �Q�高地址�Q?br />---------------
buf[3] (0x78) -- 低位
buf[2] (0x56)
buf[1] (0x34)
buf[0] (0x12) -- 高位
---------------
栈顶 �Q�低地址�Q?br />
Little-Endian: 低地址存放低位�Q�如下图�Q?br />栈底 �Q�高地址�Q?br />---------------
buf[3] (0x12) -- 高位
buf[2] (0x34)
buf[1] (0x56)
buf[0] (0x78) -- 低位
--------------
�?��?�Q�低地址�Q?br />
二、各�U�Endian
2.1 Big-Endian
计算��Z��pȝ��构中一�U�描�q�多字节存储��序的术语，在这�U�机制中最重要字节�Q�MSB�Q�存攑֜�最低端的地址上。采用这�U�机制的处理器有IBM3700�p�d��、PDP-10、Mortolora微处理器�p�d��和绝大多数的RISC处理器�?br />+----------+
| 0x34 |<-- 0x00000021
+----------+
| 0x12 |<-- 0x00000020
+----------+
�?1�Q�双字节�?x1234以Big-Endian的方式存在�v始地址0x00000020�?br />
在Big-Endian中，对于bit序列中的序号�~�排方式如下�Q�以双字节数0x8B8A��Z��Q�：(x��)
bit 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+-----------------------------------------+
val | 1 0 0 0 1 0 1 1 | 1 0 0 0 1 0 1 0 |
+----------------------------------------+
�?2�Q�Big-Endian的bit序列�~�码方式
2.2 Little-Endian
计算��Z��pȝ��构中一�U�描�q�多字节存储��序的术语，在这�U�机制中最不重要字节（LSB�Q�存攑֜�最低端的地址上。采用这�U�机制的处理器有PDP-11、VAX�?strong>Intel�p�d��微处理器和一些网�l�通信讑֤�。该术语除了描述多字节存储顺序外�q�常常用来描�q�C��个字节中各个比特的排放次序�?br />
+----------+
| 0x12 |<-- 0x00000021
+----------+
| 0x34 |<-- 0x00000020
+----------+

�?�Q�双字节�?x1234以Little-Endian的方式存在�v始地址0x00000020�?br />　�?Little-Endian中，对于bit序列中的序号�~�排和Big-Endian刚好相反�Q�其方式如下�Q�以双字节数0x8B8A��Z��Q�：(x��)
bit 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+-----------------------------------------+
val | 1 0 0 0 1 0 1 1 | 1 0 0 0 1 0 1 0 |
+-----------------------------------------+
�?4�Q�Little-Endian的bit序列�~�码方式
注意�Q�通常我们说的��L��序（Host Order�Q�就是遵循Little-Endian规则。所以当两台��L��之间要通过TCP/IP协议�q�行通信的时候就需要调用相应的函数�q�行��L��?�Q�Little-Endian�Q�和�|�络序（Big-Endian�Q�的转换�?br />采用 Little-endian模式的CPU�Ҏ(gu��)��作数的存放方式是从低字节到高字节�Q�而Big-endian模式�Ҏ(gu��)��作数的存放方式是从高字节��C��字节�?32bit宽的�?x12345678在Little-endian模式CPU内存中的存放方式�Q�假设从地址0x4000开始存放）为：(x��)
                                          内存地址     0x4000    0x4001    0x4002    0x4003
                                          存放内容    0x78      0x56    0x34       0x12
而在Big- endian模式CPU内存中的存放方式则�ؓ(f��)�Q?br />                                          内存地址    0x4000    0x4001    0x4002    0x4003
                                          存放内容    0x12         0x34        0x56       0x78
具体的区别如下：(x��)

三、Big-Endian和Little-Endian优缺�?/strong>
Big-Endian优点�Q�靠首先提取高位字节�Q�你��L��可以��q��看在偏移位置�?的字节来��定�q�个数字�?正数�q�是负数。你不必知道�q�个数值有多长�Q�或者你也不必过一些字节来看这个数值是否含有符号位。这个数值是以它们被打印出来的顺序存攄��Q�所以从二进制到十进制的函数特别有效。因而，对于不同要求的机器，在设计存取方式时��׃��(x��)不同�?br />
Little-Endian优点�Q�提取一个，两个�Q�四个或者更长字节数据的汇编指��o(h��)以与其他所有格式相同的方式�q�行�Q�首先在偏移地址�?的地�Ҏ(gu��)��取最低位的字节，因�ؓ(f��)地址偏移和字节数是一对一的关�p�，多重�_�ֺ�的数学函数就相对地容易写了�?br />
如果你增加数字的��|��你可能在左边增加数字�Q�高位非指数函数需要更多的数字�Q��?因此�Q?�l�常需要增加两位数字�ƈ�U�d��存储器里所有Big-endian��序的数字，把所有数向右�U�，�q�会(x��)增加计算机的工作量。不�q�，使用Little- Endian的存储器中不重要的字节可以存在它原来的位�|�，新的数可以存在它的右边的高位地址里。这��意味着计算��Z��的某些计��可以变得更加简单和快速�?br />四、请写一个C函数�Q�若处理器是Big_endian的，则返�?�Q�若是Little_endian的，则返�?�?br />

[cpp] view plain copy

int checkCPU(void)
{
union
{
int a;
char b;
}c;
c.a = 1;
return (c.b == 1);
}

剖析�Q�由于联合体union的存��N��序是所有成员都从低地址开始存放，利用该特性就可以��L��地获得了CPU对内存采用Little- endian�q�是Big-endian模式��d��?br />说明�Q?br />1 在c中，联合体（��q��体）的数据成员都是从低地址开始存放�?br />2 若是��端模式�Q�由低地址到高地址c.a存放�?x01 00 00 00�Q�c.b被赋��gؓ(f��)0x01�Q?br /> ————————————————————————————
地址 0x00000000 0x00000001 0x00000002 0x00000003
c.a 01 00 00 00
c.b 01 00
————————————————————————————
3 若是大端模式�Q�由低地址到高地址c.a存放�?x00 00 00 01�Q�c.b被赋��gؓ(f��)0x0�Q?br /> ————————————————————————————
地址 0x00000000 0x00000001 0x00000002 0x00000003
c.a 00 00 00 01
c.b 00 00
————————————————————————————
4 �Ҏ(gu��)��c.b的值的情况��可以判断cpu的模式了�?br />
举例�Q�一�?6�q�制数是 0x11 22 33�Q�其存放的位�|�是
地址0x3000 中存�?1
地址0x3001 中存�?2
地址0x3002 中存�?3
�q��v来就写成地址0x3000-0x3002中存放了数据0x112233
而这�U�存攑֒�表示方式�Q�正好符合大端�?/span>
另外一个比较好理解的写法如下：(x��)
[cpp] view plain copy
bool checkCPU()     // 如果是大端模式，�q�回�?nbsp;
{
    short int test = 0x1234;

    if( *((char *)&test) == 0x12)     // 低地址存放高字节数�?nbsp;
        return true;
    else
        return false;
}

int main(void)
{
    if( !checkCPU())
        cout<<"Little endian"<
    else
        cout<<"Big endian"<

    return 0;
}
或者下面两�U�写法也是可以的
[cpp] view plain copy
int main(void)
{
    short int a = 0x1234;
    char *p = (char *)&a;

    if( *p == 0x34)
        cout<<"Little endian"<
    else
        cout<<"Big endian"<

    return 0;
}

int main(void)
{
    short int a = 0x1234;
    char x0 , x1;

    x0 = ((char *)&a)[0];
    x1 = ((char *)&a)[1];

    if( x0 == 0x34)
        cout<<"Little endian"<
    else
        cout<<"Big endian"<

    return 0;
}

sheng 2016-08-17 14:21 发表评论

转蝲 C++ 虚函数表解析

sheng — Thu, 30 Jun 2016 07:36:00 GMT
     摘要: C++ 虚函数表解析陈皓http://blog.csdn.net/haoel  前言 C++中的虚函数的作用主要是实��C��多态的机制。关于多态，��而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子�cȝ��成员函数。这�U�技术可以让父类的指针有“多种形�?#8221;�Q�这是一�U�泛型技术。所谓泛型技术，说白了就是试图��用不�?..  阅读全文

sheng 2016-06-30 15:36 发表评论

叛_��法则----复杂指针解析

sheng — Thu, 14 Apr 2016 05:49:00 GMT

首先看看如下一个声明：(x��)

int* ( *( *fun )( int* ) )[10];

�q�是一个会(x��)让初学者感到头晕目眩、感到恐惧的函数指针声明。在熟练掌握C/C++的声明语法之前，不学�?f��n)一定的规则�Q�想理解好这�c�d��杂声明是比较困难的�?/span>

C/C++所有复杂的声明�l�构�Q�都是由各种声明嵌套构成的。如何解��d��杂指针声明？叛_��法则是一个很著名、很有效的方法。不�q�，叛_��法则其实�q�不�?/span>C/C++标准里面的内容，它是�?/span>C/C++标准的声明规定中归纳出来的方法�?/span>C/C++标准的声明规则，是用来解军_��何创建声明的�Q�而右左法则是用来解决如何辩识一个声明的�Q�从嵌套的角度看�Q�两者可以说是一个相反的�q�程。右左法则的英文原文是这栯��的：(x��)

The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.

�q�段英文的翻译如下：(x��)

叛_��法则�Q�首先从最里面的圆括号看�v�Q�然后往右看�Q�再往左看。每当遇到圆括号�Ӟ��应该掉转阅��L��向。一旦解析完圆括号里面所有的东西�Q�就跛_��圆括受��重复这个过�E�直到整个声明解析完毕�?/span>

    �W�者要对这个法则进行一个小��的修正�Q�应该是从未定义的标识符开始阅读，而不是从括号读�v�Q�之所以是未定义的标识�W�，是因��Z��个声明里面可能有多个标识�W�，但未定义的标识符只会(x��)有一个�?/span>

    现在通过一些例子来讨论叛_��法则的应用，先从最��单的开始，逐步加深�Q?/span>

int (*func)(int *p);

首先扑ֈ�那个未定义的标识�W�，��是func�Q�它的外面有一对圆括号�Q�而且左边是一�?/span>*��P��q�说�?/span>func是一个指针，然后跛_��q�个圆括��P��先看双��Q�也是一个圆括号�Q�这说明(*func)是一个函敎ͼ��?/span>func是一个指向这�c�d��数的指针�Q�就是一个函数指针，�q�类函数��h��int*�c�d��的�Ş参，�q�回值类型是int�?/span>

int (*func)(int *p, int (*f)(int*));

func被一�Ҏ(gu��)��号包含，且左�Ҏ(gu��)��一�?/span>*��P��说明func是一个指针，跛_��括号�Q�右边也有个括号�Q�那�?/span>func是一个指向函数的指针�Q�这�c�d��数具�?/span>int *�?/span>int (*)(int*)�q�样的�Ş参，�q�回��gؓ(f��)int�c�d��。再来看一�?/span>func的�Ş�?/span>int (*f)(int*)�Q�类似前面的解释�Q?/span>f也是一个函数指针，指向的函数具�?/span>int*�c�d��的�Ş参，�q�回��gؓ(f��)int�?/span>

int (*func[5])(int *p);

func双��是一�?/span>[]�q�算�W�，说明func是一个具�?/span>5个元素的数组�Q?/span>func的左�Ҏ(gu��)��一�?/span>*�Q�说�?/span>func的元素是指针�Q�要注意�q�里�?/span>*不是修饰func的，而是修饰func[5]的，原因�?/span>[]�q�算�W�优先��?/span>*高，func先跟[]�l�合�Q�因�?/span>*修饰的是func[5]。蟩��个括��P��看右边，也是一对圆括号�Q�说�?/span>func数组的元素是函数�c�d��的指针，它所指向的函数具�?/span>int*�c�d��的�Ş参，�q�回值类型�ؓ(f��)int�?/span>

int (*(*func)[5])(int *p);

func被一个圆括号包含�Q�左边又有一�?/span>*�Q�那�?/span>func是一个指针，跛_��括号�Q�右�Ҏ(gu��)��一�?/span>[]�q�算�W�号�Q�说�?/span>func是一个指向数�l�的指针�Q�现在往左看�Q�左�Ҏ(gu��)��一�?/span>*��P��说明�q�个数组的元素是指针�Q�再跛_��括号�Q�右边又有一个括��P��说明�q�个数组的元素是指向函数的指针。�ȝ��一下，��是�Q?/span>func是一个指向数�l�的指针�Q�这个数�l�的元素是函数指针，�q�些指针指向��h��int*形参�Q�返回��gؓ(f��)int�c�d��的函数�?/span>

int (*(*func)(int *p))[5];

func是一个函数指针，�q�类函数��h��int*�c�d��的�Ş参，�q�回值是指向数组的指针，所指向的数�l�的元素是具�?/span>5�?/span>int元素的数�l��?/span>

要注意有些复杂指针声明是非法的，例如�Q?/span>

int func(void) [5];

func是一个返回��gؓ(f��)��h��5�?/span>int元素的数�l�的函数。但C语言的函数返回��g��能�ؓ(f��)数组�Q�这是因为如果允许函数返回��gؓ(f��)数组�Q�那么接收这个数�l�的内容的东西，也必��L��一个数�l�，�?/span>C/C++语言的数�l�名是一个不可修改的左��|��它不能直接被另一个数�l�的内容修改�Q�因此函数返回��g��能�ؓ(f��)数组�?/span>

int func[5](void);

func是一个具�?/span>5个元素的数组�Q�这个数�l�的元素都是函数。这也是非法的，因�ؓ(f��)数组的元素必��L��对象�Q�但函数不是对象�Q�不能作为数�l�的元素�?/span>

实际�~�程当中�Q�需要声明一个复杂指针时�Q�如果把整个声明写成上面所�C��些�Ş式，��对可读性带来一定的损害�Q�应该用typedef来对声明逐层分解�Q�增强可�?/span>性�?/span>

typedef是一�U�声明，但它声明的不是变量，也没有创建新�c�d��Q�而是某种�c�d��的别名�?span style="margin: 0px; padding: 0px;">typedef有很大的用途，对一个复杂声明进行分解以增强可读性是其作用之一�?/span>例如对于声明�Q?/span>

int (*(*func)(int *p))[5];

可以�q�样分解�Q?/span>

typedef  int (*PARA)[5];
typedef PARA (*func)(int *);

�q�样��容易看得多了�?/span>

typedef的另一个作用，是作为基于对象编�E�的高层抽象手段。在ADT中，它可以用来在C/C++和现实世界的物�g间徏立关联，��这些物件抽象成C/C++的类型系�l�。在设计ADT的时候，我们常常声明某个指针的别名，例如�Q?/span>

typedef struct node * list;

�?/span>ADT的角度看�Q�这个声明是再自然不�q�的事情�Q�可以用list来定义一个列表。但�?/span>C/C++语法的角度来看，它其实是不符�?/span>C/C++声明语法的逻辑的，它暴力地��指针声明符从指针声明器中分��d��来，�q�会(x��)造成一些异于�h们阅��M��(f��n)惯的现象�Q�考虑下面代码�Q?/span>

const struct node *p1;
typedef struct node *list;
const list p2;

p1�c�d��?/span>const struct node*�Q�那�?/span>p2呢？如果你以为就是把list��?#8220;代入”p2�Q�然后得�?/span>p2�c�d��也是const struct node*的结果，��大错特错了�?/span>p2的类型其实是struct node * const p2�Q�那�?/span>const限定的是p2�Q�不�?/span>node。造成�q�一奇异现象的原因是指针声明器被分割�Q�标准中规定�Q?/span>

6.7.5.1 Pointer declarators

Semantics

If in the declaration ‘‘T D1’’, D1 has the form

* type-qualifier-listopt D

and the type specified for ident in the declaration ‘‘T D’’ is

‘‘derived-declarator-type-list T’’

then the type specified for ident is

‘‘derived-declarator-type-list type-qualifier-list pointer to T’’

For each type qualifier in the list, ident is a so-qualified pointer.

指针的声明器由指针声明符*、可选的�c�d��限定�?/span>type-qualifier-listopt和标识符D�l�成�Q�这三者在逻辑上是一个整体，构成一个完整的指针声明器。这也是多个变量同列定义时指针声明符必须紧跟标识�W�的原因�Q�例如：(x��)

int *p, q, *k;

p�?/span>k都是指针�Q�但q不是�Q�这是因�?/span>*p�?/span>*k是一个整体指针声明器�Q�以表示声明的是一个指针。编译器�?x��)把指针声明�W�左边的�c�d��包括光��定词作�ؓ(f��)指针指向的实体的�c�d��Q�右边的限定词限定被声明的标识符。但现在typedef struct node *list��生生把*从整个指针声明器中分��d��来，�~�译器找不到*�Q�会(x��)认�ؓ(f��)const list p2中的const是限�?/span>p2的，正因如此�Q?/span>p2的类型是node * const而不�?/span>const node*�?/span>

虽然typedef struct node* list不符合声明语法的逻辑�Q�但��Z��typedef�?/span>ADT中的重要作用以及(qi��ng)信息隐藏的要求，我们应该让用戯��样��?/span>list A�Q�而不�?/span>list *A�Q�因此在ADT的设计中仍应使用上述typedef语法�Q�但需要注意其带来的不利媄响�?/span>

sheng 2016-04-14 13:49 发表评论

sheng — Thu, 14 Apr 2016 03:14:00 GMT
C99中，�l�构中的最后一个元素允许是未知大小的数�l�，�q�就叫做柔性数�l�成员，但结构中的柔性数�l�成员前面必��至��一个其他成员。柔性数�l�成员允许结构中包含一个大��可变的数组。sizeof�q�回的这�U�结构大��不包括柔性数�l�的内存。包含柔性数�l�成员的�l�构用malloc ()函数�q�行内存的动态分配，�q�且分配的内存应该大于结构的大小�Q�以适应柔性数�l�的预期大小。�?nbsp;
C语言大全�Q?#8220;柔性数�l�成�?#8221;

【柔性数�l�结构成�?/span>
　　C99中，�l�构中的最后一个元素允许是未知大小的数�l�，�q�就叫做柔性数�l�成员，但结构中的柔性数�l�成员前面必��至��一个其他成员。柔性数�l�成员允许结构中包含一个大��可变的数组。sizeof�q�回的这�U�结构大��不包括柔性数�l�的内存。包含柔性数�l�成员的�l�构用malloc ()函数�q�行内存的动态分配，�q�且分配的内存应该大于结构的大小�Q�以适应柔性数�l�的预期大小。�?nbsp;
C语言大全�Q?#8220;柔性数�l�成�?#8221;

看看 C99 标准�?灉|��数组成员�Q?/span>

�l�构体变长的妙用——0个元素的数组
有时我们需要��生一个结构体�Q�实��C��一�U�可变长度的�l�构。如何来实现呢？
看这个结构体的定义：(x��)
typedef struct st_type
{
int nCnt;
int item[0];
}type_a;
�Q�有些编译器�?x��)报错无法编译可以改成�?x��)�Q?/span>
typedef struct st_type
{
int nCnt;
int item[];
}type_a;
�q�样我们��可以定义一个可变长的结构，用sizeof(type_a)得到的只�?�Q�就是sizeof(nCnt)=sizeof(int)�?/span>

�?个元素的数组没有占用�I�间�Q�而后我们可以�q�行变长操作了�?/span>
C语言版：(x��)
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
C++语言�?
type_a *p = (type_a*)new char[sizeof(type_a)+100*sizeof(int)];
�q�样我们��׃�生了一个长�?00的type_a�c�d��的东西用p->item[n]��p��单地讉K��可变长元素，原理十分��?/span>

�Q�分配了比sizeof(type_a)多的内存后int item[];��有了其意义了，它指向的是int nCnt;后面的内容，是没

有内存需要的�Q�而在分配时多分配的内存就可以由其来操控，是个十分好用的技巧�?/span>
而释攑֐��L(f��ng)��单：(x��)
C语言版：(x��)
free(p);
C++语言版：(x��)
delete []p;
其实�q�个叫灵�z�L��l�成�?fleible array member)C89不支持这�U�东西，C99把它作�ؓ(f��)一�U�特例加入了标准。但

是，C99所支持的是incomplete type�Q�而不是zero array�Q��Ş同int item[0];�q�种形式是非法的�Q�C99支持�?/span>

形式是�Ş同int item[];只不�q�有些编译器把int item[0];作�ؓ(f��)非标准扩展来支持�Q�而且在C99发布之前已经�?/span>

了这�U�非标准扩展了，C99发布之后�Q�有些编译器把两者合而�ؓ(f��)一�?/span>
下面是C99中的相关内容�Q?/span>
6.7.2.1 Structure and union specifiers

As a special case, the last element of a structure with more than one named member may have

an incomplete array type; this is called a flexible array member. With two exceptions, the

flexible array member is ignored. First, the size of the structure shall be equal to the offset

of the last element of an otherwise identical structure that replaces the flexible array member

with an array of unspecified length.106) Second, when a . (or ->) operator has a left operand

that is (a pointer to) a structure with a flexible array member and the right operand names that

member, it behaves as if that member were replaced with the longest array (with the same element

type) that would not make the structure larger than the object being accessed; the offset of the

array shall remain that of the flexible array member, even if this would differ from that of the

replacement array. If this array would have no elements, it behaves as if it had one element but

the behavior is undefined if any attempt is made to access that element or to generate a pointer

one past it.
例如在VC++6里��用两者之一都能通过�~�译�q�且完成操作�Q�而会(x��)产生warning C4200: nonstandard extension

used : zero-sized array in struct/union的警告消息�?/span>
而在DEVCPP里两者同样可以��用，�q�且不会(x��)有警告消息�?/span>

sheng 2016-04-14 11:14 发表评论

值得推荐的C/C++框架和库

sheng — Thu, 14 Apr 2016 02:03:00 GMT
     摘要: 值得推荐的C/C++框架和库【本文系外部转脓(chu��ng)�Q�原文地址�Q�http://coolshell.info/c/c++/2014/12/13/c-open-project.htm】留作存档下�ơ造轮子前先看看现有的轮子吧值得学习(f��n)的C语言开源项�? 1. Webbench Webbench是一个在linux下��用的非常��单的�|�站压测工具。它使用fork()模拟多个客户端同时访问我们设定的URL�Q�测�?..  阅读全文

sheng 2016-04-14 10:03 发表评论

sheng — Thu, 14 Apr 2016 01:10:00 GMT
     摘要: Eric S. Raymond目录1. 谁该阅读�q�篇文章2. 我�ؓ(f��)什么写�q�篇文章3.寚w��要求4.填充5.�l�构体对齐及(qi��ng)填充6.�l�构体重排序7.难以处理的标量的情况8.可读性和�~�存局部�?.其他��装的技�?0.工具11.证明�?qi��ng)例�?2.版本履历 1. 谁该阅读�q�篇文章本文是关于削减C语言�E�序内存占用�I�间的一��Ҏ(gu��)��?#8212;—��Z��?..  阅读全文

sheng 2016-04-14 09:10 发表评论

从实现装饰者模式中思考C++指针和引用的选择(�?

sheng — Fri, 05 Apr 2013 03:27:00 GMT

从实现装饰者模式中思考C++指针和引用的选择

最�q�在看设计模式的内容�Q�偶焉��手痒��写了一�?#8220;装饰�?#8221;模式的一个实例。该实例来源�?/span>风雪涟漪的博客，我对它做了简化。作��Z��个经典的设计模式�Q�本�w��ƈ没有太多要说的内宏V��但是在我尝试��?/span>C++��d��现这个模式的实例的时候，出现了一些看似无关紧要但是却引�h深思的问题�?/span>

首先�Q�我想简单介�l�一下这个实例的含义。实例的目的是希望通过装饰器类对已有的蛋糕�c�进行装饰补充，于是按照装饰者模式的设计�l�构�Q�有�c�M��?/span>1的设计结构�?/span>

�?/span>1 装饰者模�?/span>

蛋糕�c�d��装饰器类都��承于一个公��q��基类�Q�该基类声明了一些公共接口。这里简单的使用getName来返回当前蛋�p�的名称�Q�而装饰器�c�d��以对该蛋�p�的名称�q�行修改补充。具体的蛋糕�c�都有自��q��名称�Q�比�?/span>CheeseCake�q�回的是“奶��a(b��)蛋糕”。如果��用了装饰器类对该�c�进行装饰的话，�q�回的名字就发生了的变化�Q�比�?#8220;装饰了花�?/strong>奶��a(b��)蛋糕”�Q�这正是装饰器类的功能。实现这个功能的关键在于装饰器公共基�c?/span>Decorator�Q�它包含了一�?/span>Cake�c�d��的成�?/span>cake。在定义装饰器的时候我们可以传递给装饰器一个已�l�徏立好的蛋�p�对象，比如CheeseCake对象。由�?/span>CheeseCake�?/span>Cake的子�c�，因此该对象可以被cake成员记录下来。由于具体的装饰器��承于装饰器基�c?/span>Decorator�Q�因此保护乘�?/span>cake可以被看刎ͼ�又因��饰器本��n也是�l�承�?/span>Cake的，因此也拥�?/span>getName的接口，�q�样在装饰器�c�d��?/span>getName调用cake�?/span>getName接口�q�添加额外的操作��p��完成装饰的目的。另外，装饰器本�w�也�?/span>Cake的子�c�，因此装饰后的装饰器类对象同时也是一个具体的蛋糕对象�Q�它可以被再�ơ装饎ͼ��q�样装饰器类反映在我们脑��里的情境就是一个原本的蛋糕对象外边包裹了一层层装饰器对象�?/span>

以上的说明如果还不够清楚的话�Q�下边展�C�具体的实现代码。这里就需要考虑cake成员的类型问题，一般��用指针类型可能更�W�合C++的编�E�习(f��n)惯。因��Z��用对象不仅消耗空��_(d��)��q�在每次构造对象的时候进行对象的复制�Q�这都不是我们愿意看到的。当�Ӟ��使用引用或许更合理，因�ؓ(f��)按照�q�_��的经验，很多使用C++指针的地斚w��可以用引用代替，有�h甚至��多��用引用少使用指针�Q�当然我也承�?/span>C++引用也有很多好处~�Q?/span>。不�q�，当你��d��本文或许你就不大�q�么认�ؓ(f��)了。首先，我们�?/span>Cake*pCake实现�q�个装饰器类内的成员�Q�先具体了解一下这个代码的具体内容�?/span>

�?Ctrl+C 复制代码
#pragma once #include <iostream> using namespace std; //Cake公共基类�Q�提供装饰者和被装饰物的统一接口 class Cake { public: virtual string getName()const=0; }; //一个具体的蛋糕 class CheeseCake:public Cake { public: virtual string getName()const { return string("奶��a(b��)蛋糕"); } }; //一个装饰者基�c? class Decorator:public Cake { protected: Cake *pCake; public: Decorator(Cake*pc):pCake(pc){} }; //一个具体的装饰�? class FlowerDecorator:public Decorator { public: FlowerDecorator(Cake*pc):Decorator(pc){} virtual string getName()const { string decName="装饰�q�花�?; decName+=pCake->getName(); return decName; } }; int main() { cout<< FlowerDecorator( &FlowerDecorator( &CheeseCake() )) .getName().c_str() <<endl; return 0; }
�?Ctrl+C 复制代码

从代码中不难看出�E�序的输出结构应该是“装饰�q�花的装饰过��q��奶��a(b��)蛋糕”�Q�事实也的确如此�Q�从装饰器的使用格式来看FlowerDecorator(&FlowerDecorator(&CheeseCake()))倒也不至于十分麻烦。但是刚才讨��Q�如果能使用引用代替�?x��)许会(x��)�?#8220;舒服”�Q�至��不用传递参��C��前还要��?/span>&获取一下地址�?/span>~

既然如此�Q�我们把成员修改为引用格式的�Q?/span>

#pragma once
#include
using namespace std;
//Cake公共基类�Q�提供装饰者和被装饰物的统一接口
class Cake
{
public:
    virtual string getName()const=0;
};

//一个具体的蛋糕
class CheeseCake:public Cake
{
public:
    virtual string getName()const
    {
        return string("奶��a(b��)蛋糕");
    }
};

//一个装饰者基�c?/span>
class Decorator:public Cake
{
protected:
    Cake &pCake;
public:
    Decorator(Cake&pc):pCake(pc){}
};

//一个具体的装饰�?/span>
class FlowerDecorator:public Decorator
{
public:
    FlowerDecorator(Cake&pc):Decorator(pc){}
    virtual string getName()const
    {
        string decName="装饰�q�花�?/span>";
        decName+=pCake.getName();
        return decName;
    }
};
int main()
{
    cout<<
        FlowerDecorator(
            FlowerDecorator(
                CheeseCake()
        ))
        .getName().c_str()
        <    return 0;
}

修改后的代码看�v来的��更“��眼�?#8221;。因��用的时候我们不用再写那个看着别扭的取地址�q�算�W�了�Q�然后我们满怀�ƣ喜的执行了�E�序�Q�输出结果�ؓ(f��)�Q?#8220;装饰�q�花的奶油蛋�p?#8221;�Q�你我的�W�一反应八成是觉得忘了多修饰一�ơ了�Q�但是我们认真的��查代码，发现的确一切都是符合逻辑�?#8230;…

上边做了�q�么多铺垫就是�ؓ(f��)了引��个奇怪的问题�Q�我其实也被该问题困惑了很久。稍有编�E�经验的人都�?x��)跟�t�调试这些构造函数的执行�q�程�Q�结果发�?/span>FlowerDecorator只被执行了一�ơ，因此��输��Z��?#8220;装饰�q�花�?#8221;不��为奇。但是你我肯定好奇�ؓ(f��)什么会(x��)��输��Z��ơ呢�Q?/span>

再次再次的检查代码、调试、跟�t�，或许你会(x��)像发现新大陆一样发��C��一个隐藏的问题�Q�第二次构�?/span>FlowerDecorator时调用的是复制构造函敎ͼ�而不是定义好的构造函敎ͼ�虽然子类FlowerDecorator�?/span>Cake的子�c�，但是�~�译器会(x��)自动最�?j��ng)_��配函数参数类型）�Q�由于复制构造函数值原模原��L(f��ng)��拯��Z��个对象，所以只能完成一�ơ装饰器装饰。非常完��的解释�Q�因此我们可以自己重写复制构造函数来完成我们的装饰功能，�q�里先忽略原本的对象复制功能了。编译器为我们生成的复制构造函数应该是�Q?/span>

FlowerDecorator(const FlowerDecorator&pc):Decorator(pc.pCake){}

而我们应该将参数看作一�?/span>Cake对象�q�行装饰�Q�因此修改�ؓ(f��)�Q?/span>

FlowerDecorator(const FlowerDecorator&pc):Decorator(const_cast(pc)){}

同样�Q�由于构造函数初始化了基�c�，所以基�cȝ��复制构造也需要重写：(x��)

Decorator(const Decorator&pc):pCake(const_cast(pc)){}

即��传递的参数�?/span>FlowerDecorator对象�?/span>Cake�?/span>Decorator不是一个类型，但是�~�译器或�?d��ng)R��认的匚w��l�承层次最�q�的�c�d��Q�然后我们按照这栯��求重写了代码�Q�执行了�E�序�Q�在期待�l�果的那一�ȝ��到的�?#8220;装饰�q�花的奶油蛋�p?#8221;……或许此时的你都会(x��)感到灰心�Q�但是你�q�是依然的坚强的按下�?/span>F5单步跟踪�Q�结果你发现拯��构造函数�ƈ没有被调用！��N��以上的假��N��错了吗？我可以确定的告诉读者，我们以上的假��N��是正��的�?/span>

最�l�我也是没有办法�Q�去StackOverFlow上求助，�l�合回答者的讨论�Q�我�l�于把问题的原因锁定�?#8212;—�~�译器优化！我觉得用一个最��单的例子来说明这个问题再合适不�q�了�Q?/span>

class A
{
public:
    A(int)
    {
        cout<<"构造\n";
    }
    A(const A&)
    {
        cout<<"拯��\n";
    }
};

int main()
{
    A(0);
    cout<<"------------------------\n";
    A(A(0));
    cout<<"------------------------\n";
    A(A(A(0)));
    cout<<"------------------------\n";
    A(A(A(A(0))));
    cout<<"------------------------\n";
    A(A(A(A(A(0)))));
    cout<<"------------------------\n";
    return 0;
}

�q�个��单的例子�l�果或许大家都很明白�Q�但是你亲自��试一下就可能要怀疑自��q��判断能力了，�E�序输出�Q?/span>

是不是有点世界观被颠覆的感觉�Q�需要声明一下，�q�个�?/span>Visual Studio 2010下的��试�l�果�Q�因��个程序的输出的确和编译器相关�Q��ؓ(f��)了确认我�?/span>gcc-4.4.3��试了该�D�代码，输出�l�果为：(x��)

看来�Q�还�?/span>gcc优化的比较彻底。因此我们可以得出结论，�c�M��q�种无名对象的构造（有名的是按照规矩来的�Q�，调用多少�ơ构造函数要看编译器�?#8220;脾气”了。到�q�里�Q�不知道你对引用参数的感觉如何？

讨论到这�Q�或许有��和本来要讨论的话题离得太�q�了。其实�ƈ不是�Q�佛(j��ng)家说�Q?#8220;今日之果皆来自昨日之�?#8221;�Q�一切的一切都是由于我们��用了本以为毫无�?zh��n)��늚�引用��D��的！如果使用指针��׃��可能发生和拷贝构造函数冲�H�的问题�Q�也不会(x��)��D��~�译器优化的问题�Q�回视本文刚开始�D的例子和该文的主题，或许我们应该清楚有时候的��要好好区分一下指针和引用的差别了�Q�当然本文也是从一个实�늚�例子中去发现和挖掘这一炏V�?br />

sheng 2013-04-05 11:27 发表评论

DLL中传递STL参数�Q�vector对象作�ؓ(f��)dll参数传递等问题(�?

sheng — Fri, 01 Mar 2013 05:58:00 GMT

STL跨��^台调用会(x��)出现很多异常�Q�你可以试试.
STL使用模板生成�Q�当我们使用模板的时候，每一个EXE�Q�和DLL都在�~�译器��生了自己的代码，��D��模板所使用的静态成员不同步�Q�所以出现数据传递的各种问题�Q�下面是详细解释�?/strong>

原因分析�Q?br style="margin: 0px; padding: 0px; " />一句话-----如果��M��STL�c�M��用了静态变量（无论是直接还是间接��用）�Q�那么就不要再写��执行单元讉K��它的代码�?nbsp;除非你能够确定两个动态库使用的都是同��L(f��ng)��STL实现�Q�比如都使用VC同一版本的STL�Q�编译选项也一栗��强烈徏议，不要在动态库接口中传递STL容器�Q�！

STL不一定不能在DLL间传递，但你必须��d��搞懂它的内部实现�Q��ƈ懂得��Z��?x��)出问题�?br style="margin: 0px; padding: 0px; " />微��Y的解释：(x��)
http://support.microsoft.com/default.aspx?scid=kb%3ben-us%3b172396
微��Y�l�的解决办法�Q?br style="margin: 0px; padding: 0px; " />http://support.microsoft.com/default.aspx?scid=kb%3ben-us%3b168958

1、微软的解释�Q?br style="margin: 0px; padding: 0px; " />大部分C++标准库里提供的类直接或间接地使用了静态变量。由于这些类是通过模板扩展而来的，因此每个可执行映像（通常�?dll�?exe文�g�Q�就�?x��)存在一份只属于自己的、给定类的静态数据成员。当一个需要访问这些静态成员的�c�L��法执行时�Q�它使用的是“�q�个�Ҏ(gu��)��的代码当前所在的那䆾可执行映�?#8221;里的静态成员变量。由于两份可执行映像各自的静态数据成员�ƈ未同步，�q�个行�ؓ(f��)��可能导致访问违例，或者数据看��h��g��丢失或被破坏了�?br style="margin: 0px; padding: 0px; " />
可能不太好懂�Q�我举个例子�Q�假如类A有个静态变量m_s�Q�那么当1.exe使用�?.dll中提供的某个A对象�Ӟ��׃��模板扩展机制�Q?.exe�?.dll中会(x��)分别存在自己的一份类静态变量A.m_s�?br style="margin: 0px; padding: 0px; " />�q�样�Q�假�?.exe中从2.dll中取得了一个的�c�A的实例对象a�Q�那么当�?.exe中直接访问a(ch��n).m_s�Ӟ��其实讉K��的是 1.exe中的对应拯��Q�正��情况应该是讉K��?.dll中的a.m_s�Q�。这样就可能��D��非法讉K��、应当改变的数据没有改变、不应改变的数据被错误地更改�{�异常情形�?br style="margin: 0px; padding: 0px; " />
原文�Q?br style="margin: 0px; padding: 0px; " />Most classes in the Standard C++ Libraries use static data members directly or indirectly. Since these classes are generated through template instantiation, each executable image (usually with DLL or EXE file name extensions) will contain its own copy of the static data member for a given class. When a method of the class that requires the static data member is executed, it uses the static data member in the executable image in which the method code resides. Since the static data members in the executable images are not in sync, this action could result in an access violation or data may appear to be lost or corrupted.

1、保证资源的分配/删除操作对等�q�处于同一个执行单元；
   比如�Q�可以把�q�些操作�Q�包括构�?析构函数、某些容器自动扩容{�q�个需要特别注意}时的内存再分配等�Q�隐藏到接口函数里面。换句话��_(d��)��(x��)��量不要直接从dll中输出stl对象�Q�如果一定要输出�Q�给它加上一层包装，然后输出�q�个包装接口而不是原始接口�?br style="margin: 0px; padding: 0px; " />
2、保证所有的执行单元使用同样版本的STL�q�行库�?br style="margin: 0px; padding: 0px; " />   比如�Q�全部��用release库或debug库，否则两个执行单元扩展出来的STL�cȝ��内存布局��可能会(x��)不一栗��?br style="margin: 0px; padding: 0px; " />
只要��C��关键��是�Q?span style="margin: 0px; padding: 0px; ">如果��M��STL�c�M��用了静态变量（无论是直接还是间接��用）�Q�那么就不要再写��执行单元讉K��它的代码�?br style="margin: 0px; padding: 0px; " />
解决�Ҏ(gu��)��Q?br style="margin: 0px; padding: 0px; " />1. 一个可以考虑的方�?br style="margin: 0px; padding: 0px; " />比如有两个动态库L1和L2�Q�L2需要修改L1中的一个map�Q�那么我在L1中设�|�如下接�?br style="margin: 0px; padding: 0px; " />int modify_map(int key, int new_value);
如果需要指�?#8220;某一个map”�Q�则可以考虑实现一�U�类��g��句柄的方式，比如可以传递一个DWORD
不过�q�个DWORD攄��是一个地址

那么modify_map��可以这样实玎ͼ�(x��)
int modify_map(DWORD map_handle, int key, int new_value)
{
    std::map& themap = *(std::map*)map_handle;
    themap[key] = new_value;
}

map_handle的��g��首先由L1“告诉”L2:
DWORD get_map_handle();

L2可以�q�样调用:
DWORD h = get_map_handle();
modify_map(h, 1, 2);

2. 加入一个额外的层，��可以解决问题。所以，你需要将你的Map包装在dll内部�Q�而不是让它出现在接口当中。动态库的接口越��单越好，不好��M��太过复杂的东东是至理名言�Q�）

在动态连接库开发中要特别注意内存的分配与释��N��题，�E�不注意�Q�极可能造成内存泄漏�Q�从而访问出错。例如在某DLL中存在这样一�D�代码：(x��)

extent "C" __declspec(dllexport)
void ExtractFileName( const std::string& path //!< Input path and filename.
, std::string& fname //!< Extracted filename with extension.
)
{
std::string::size_type startPos = path.find_last_of('\\');
fname.assign(path.begin() startPos 1, path.end() );
}

在DLL中��用STL对象std::string�Q��ƈ且在其中改变std::string的内容，卛_��生了内存的重分配问题,若在EXE中调用该函数�?x��)出现内存访问问题�?span style="margin: 0px; padding: 0px; color: #ff3333; ">主要是：(x��)因�ؓ(f��)DLL和EXE的内存分配方式不同，DLL中的分配的内存不能在EXE中正��释放掉�?br style="margin: 0px; padding: 0px; " />
解决�q�一问题的途径如下�Q?br style="margin: 0px; padding: 0px; " />一般情况下�Q�构建DLL必须遵��@谁分配就��p��释放�?/span>原则�Q�例如COM的解��x��案（利用引用计数�Q�，对象的创建（QueryInterface�Q�与释放均在COM�l��g内部完成。在�U�C 环境下，可以很容易的实现�c�M��Ҏ(gu��)��?/p>

在应用STL的情况下�Q�很难��用上�q�方案来解决�Q�因此必��d��辟蹊径，途径有二�Q?br style="margin: 0px; padding: 0px; " />1、自己写内存分配器替代STL中的默认分配器�?br style="margin: 0px; padding: 0px; " />2、��用STLport替代�pȝ��的标准库�?br style="margin: 0px; padding: 0px; " />
其实�Q�上�q�问题在VC7�?qi��ng)以后版本中�Q�已得到解决�Q�注意DLL工程和调用的工程一定要使用多线�E�DLL库，��׃��?x��)发生内存访问问题�?/p>

一个很奇怪的问题�Q�DLL中��用std::string作�ؓ(f��)参数�l�果出错
STL
�q�段旉��,在工�E�中��一些功能封装成动态库,需要��用动态库接口的时�?使用�?span style="margin: 0px; padding: 0px; ">STL的一些类型作为参�?

比方string,vector,list.但是在��用接口的时�?
class exportClass
{
   bool dll_funcation(string &str);
};
复制代码
//上面�q�个�c�d��是一个�Ş式，具体内容不写出来�?�q�个�c�被导出

当我在��用这个库的时�?�q�样写代�?
string str="":
exportClass tmp;
tmp.dll_function(str);
复制代码
�q�个函数能成功调�?但是在函数里面会(x��)�l�这个数�l�附�?如果字符串太�?��׃��(x��)出错.函数调用能成�?但是一旦str资源需要释攄��时�?资源��׃��能释放了,提示释放了错误的内存�I�间.

一点一点取掉这个函数的代码.最后就剩下

str="qadasdasdasdsafsafas";

�q�是出错�?

如果�Ҏ(gu��)��很短的字�W�串,��׃��?x��)出错�?
在这个时�?只能��试认�ؓ(f��)是字�W�串的空间太��?br style="margin: 0px; padding: 0px; " />
最�l�我修改成这�?错误消失�?希望错误真的是这个引��L(f��ng)��
string str="":

str.resize(1000);

exportClass tmp;

tmp.dll_function(str);

今天写程序的时候要�l�一个模块的dll传递一个参敎ͼ��׃��参数数量是可变的�Q�因此设计成了vector�c�d��Q�但调试�q�程中发现在exe中的参数传递到dll中的函数后，vector变成�I�的�Q�改成传引用�c�d��后，vector竟然变得很大�Q��ƈ且是无意义的参数�?/p>
对于�q�个问题�Q�两�U�办法：(x��)
1.传递vector指针
2.传递const vector�?/p>
�I�其原因�Q?/p>
是因为vector在exe和dll之间传递的时候，�׃��在dll内可能对vector插入数据�Q�而这�D�内存是在dll里面分配的，exe无法知道如何释放内存�Q�从而导致问题。而改成const�c�d��后，�~�译器便知道dll里不�?x��)改变vector�Q�从而不�?x��)出错�?/p>
或者可以说�q�是"cross-DLL problem."�Q�This problem crops up when an object is created using new in one dynamically linked library (DLL) but is deleted in a different DLL�Q�的一�U�吧�?/p>
对于STL�Q�在DLL中��用的时候，往往存在�q�些问题�Q�在�|�络上搜集了下，�q�些都是要��^时��用STL的时候注意的�?/p>
***************************************************************************************************************
引用http://www.hellocpp.net/Articles/Article/714.aspx
当template 遭遇到dynamic link 时�? 很多时候却是一场恶�?
现在来说说一部分我已�l�碰到过的问�? 问题主要集中在内存分配上.
1>
      拿STL来说, 自己写模板的时�?很难免就用到stl. stl的代码都在头文�g�? 那么表示着内存分配的代�?只有包含了它的cpp �~�译的时候才�?x��)被军_��是��用什么样的内存分配代�? 考虑一�? 当你声明了一个vector<> . �q�把�q�个vector<>交给一�?dll里的代码来用. 用完�? 在你的程序里被释放了.    那么如果�?在dll里往vector里insert了一些东�? 那么�q�个时候insert 发生的内存分配的代码是属于dll�? 你不知道�q�个dll的内存分配是什�? 是分配在哪里�? 而这个时�?释放那促的动作却不在dll�?....同时. 你甚��x��法保证编译dll的那个家伙��用的stl版本和你是完全一��L(f��ng)��..>
      如此说来, �E�序crash掉是天经��C��?...
      对策: 千万别别把你的stl 容器,模板容器�?dll 间传来传�?. ��C��string也是....
2>
     你在dll的某个类里声明了一个vector之类的容�? 而没有显式的写这个类的构造和析构函数. 那么问题又来�?
     你这个类肯定有操作这vector的函�? 那么�q�些函数�?x��)让vecoter<>生成代码. �q�些代码在这个dll里都是一致的. 但是别忘�?你没有写析构函数...... 如果�q�个时�? 别�h在外面声明了一个这��L(f��ng)��c?然后调用�q�个�cȝ��函数操作了这个vector( 当然使用者�ƈ不知道什么时候操作了vector) . 它用完了�q�个�c�M��? �c�被释放掉了. �~�译器很负责的�ؓ(f��)它生成了一份析构函数的代码...... 听好�?�q�䆾代码�q�不是在 dll�?... . 事情于是又和1>里的一样了.... crash ......(可能�q�会(x��)伴随着�q��.....)
     对策: 记得dll里每个类,哪怕式构造析构函数式�I�的. 也要写到cpp里去. 什么都不写也式很糟�p�的.....同时,更要把�Q何和内存操作有关的函数写�?.cpp �?..
3>
    以上两个问题��g��都是比较�Ҏ(gu��)��?----只要把代码都写到cpp里去, 不要用stl容器传来传去��可以了.
   那么�W�三个问题就要麻烦的�?
   如果你自己写了一个模�? �q�个模板用了stl 容器..........
   �q�个时候你该怎么办呢?
　昄��你无法把和内存分配相关的函数都写�?cpp里去 . template的代码都必须攑ֈ�header file�?....
   对策: 解决�q�个问题的基本做法是做一个stl 内存分配�?, 强制把这个模杉K��和内存分配相关的攑ֈ�一�?cpp里去.�q�个时候编译这个cpp��׃��(x��)把内存分配代码固定在一个地�? 要么是dll. 要么是exe�?..
模板+动态链接库的��用问题还很多. 要千万留心这个陷阱遍地的东西�?/p>
***************************************************************************************************************************
微��Y关于�q�类问题的解释：(x��)
You may experience an access violation when you access an STL object through a pointer or reference in a different DLL or EXE
http://support.microsoft.com/default.aspx?scid=KB;en-us;q172396
How to export an instantiation of a Standard Template Library (STL) class and a class that contains a data member that is an STL object
http://support.microsoft.com/default.aspx?scid=KB;en-us;q168958

�ȝ��Q?/p>
字符串参数用char*�Q�Vector用char**�Q?/p>
动态内存要牢记谁申误��释放的原则�?/div>

sheng 2013-03-01 13:58 发表评论