亚洲精品中文字,国内精品久久久久久影视8 ,麻豆成人在线观看

内存�?MemPool)

Xiao.Zhu — Mon, 12 Mar 2007 02:57:00 GMT

转蝲声明�Q�本文�{自csdn博客�Q�许式伟著，链接�Q�http://blog.csdn.net/xushiweizh/archive/2006/11/22/1402967.aspx

��狼注：上次也写了一个简单的内存池，是��用STL的deque来管理的�Q�实现�v来比较简单，不过有个�~�点��是只能固定分配大小�Q�所以需要根据经验��g��先分配内存大��，然后把内存再�ơ划分�ؓ�{�大的小的内存供使用�?br />概述

内存池（MemPool�Q�技术备受推崇。我用google搜烦了下�Q�没有找到比较详�l�的原理性的文章�Q�故此补充一个。另外，补充了boost::pool�l��g与经典MemPool的差异。同时也描述了MemPool在sgi-stl/stlport中的�q�用�?br />

�l�典的内存池技�?br />
�l�典的内存池�Q�MemPool�Q�技术，是一�U�用于分配大量大��相同的��对象的技术。通过该技术可以极大加快内存分�?释放�q�程。下面我们详�l�解释其中的奥妙�?br />
�l�典的内存池只涉及两个常量：MemBlockSize、ItemSize�Q�小对象的大��，但不能小于指针的大小�Q�在32位��^��C��是不能��于4字节�Q�，以及两个指针变量MemBlockHeader、FreeNodeHeader。开始，�q�两个指针均为空�?br />
class MemPool
{
private:
    const int m_nMemBlockSize;
    const int m_nItemSize;

    struct _FreeNode {
        _FreeNode* pPrev;
        BYTE data[m_nItemSize - sizeof(_FreeNode*)];
    };

    struct _MemBlock {
        _MemBlock* pPrev;
        _FreeNode data[m_nMemBlockSize/m_nItemSize];
    };

    _MemBlock* m_pMemBlockHeader;
    _FreeNode* m_pFreeNodeHeader;

public:
   MemPool(int nItemSize, int nMemBlockSize = 2048)
       : m_nItemSize(nItemSize), m_nMemBlockSize(nMemBlockSize),
         m_pMemBlockHeader(NULL), m_pFreeNodeHeader(NULL)
   {
   }
};

其中指针变量MemBlockHeader是把所有申��L��内存块（MemBlock�Q�串成一个链表，以便通过它可以释放所有申��L��内存。FreeNodeHeader变量则是把所有自由内存结点（FreeNode�Q�串成一个链�?br />
�q? �D�话涉及两个关键概念�Q�内存块�Q�MemBlock�Q�和自由内存�l�点�Q�FreeNode�Q�。内存块大小一般固定�ؓMemBlockSize字节�Q�除�ȝ��以徏立链表的指针外）。内存块在申请之初就被划分�ؓ多个内存�l�点�Q�Node�Q�，每个Node大小为 ItemSize�Q�小对象的大��）�Q�计 MemBlockSize/ItemSize个。这MemBlockSize/ItemSize个内存结点刚开始全部是自由的，他们被串成链表。我们看�? 甌��/释放内存�q�程�Q�就很容易明白这样做的目的�?br />
甌��内存�q�程
代码如下�Q?br />void* MemPool::malloc()    // 没有参数
{
    if (m_pFreeNodeHeader == NULL)
    {
       const int nCount = m_nMemBlockSize/m_nItemSize;
        _MemBlock* pNewBlock = new _MemBlock;
        pNewBlock->data[0].pPrev = NULL;
        for (int i = 1; i < nCount; ++i)
            pNewBlock->data[i].pPrev = &pNewBlock->data[i-1];
        m_pFreeNodeHeader = &pNewBlock->data[nCount-1];
        pNewBlock->pPrev = m_pMemBlock;
        m_pMemBlock = pNewBlock;
    }
    void* pFreeNode = m_pFreeNodeHeader;
    m_pFreeNodeHeader = m_pFreeNodeHeader->pPrev;
    return pFreeNode;
}

内存甌��q�程分�ؓ两种情况�Q?br />
    * 在自由内存结炚w��表（FreeNodeList�Q�非�I��?br />      在此情况下，Alloc�q�程只是从链表中摘下一个结点的�q�程�?br />
    * 否则�Q�意味着需要一个新的内存块(MemBlock)�?br />      �q�个�q�程需要将新申��L��MemBlock切割成多个Node�Q��ƈ把它们串��h��?br />      MemPool技术的开销主要在这�?br />

释放内存�q�程
代码如下�Q?br />void MemPool::free(void* p)
{
    _FreeNode* pNode = (_FreeNode*)p;
    pNode->pPrev = m_pFreeNodeHeader;
    m_pFreeNodeHeader = pNode;
}

释放�q�程极其��单，只是把要释放的结�Ҏ(gu��)��到自由内存链表（FreeNodeList�Q�的开头即可�?br />
性能分析
MemPool技术申请内�?释放内存均极其快�Q�比AutoFreeAlloc慢）。其内存分配�q�程多数情况下复杂度为O(1)�Q�主要开销在FreeNodeList为空需要生成新的MemBlock时。内存释放过�E�复杂度为O(1)�?br />

boost::pool

boost::pool是内存池技术的变种。主要的变化如下�Q?br />
   * MemBlock改�ؓ非固定长�?MemBlockSize)�Q�而是�Q�第1�ơ申��h�� m_nItemSize*32�Q�第2�ơ申��h�� m_nItemSize*64�Q�第3�ơ申��h��m_nItemSize*128�Q�以此类推。不采用固定的MemBlockSize�Q�而采用这�U�做法预��模型（是的�Q�这是一�U�用户内存需求的预测模型�Q�其实std::vector的内存增长亦采用了该�? 型）�Q�是一个细节上的改良�?br />
    * 增加了ordered_free(void* p) 函数�?br />
     ordered_free区别于free的是�Q�free把要释放的结�Ҏ(gu��)��到自由内存链�? �Q�FreeNodeList�Q�的开��_��ordered_free则假设FreeNodeList是有序的�Q�因此会遍历FreeNodeList把要释放�? �l�点插入到合适的位置�?br />
      我们已经看到�Q�free的复杂度是O (1)�Q�非常快。但��h��意ordered_free是比较费的操作，其复杂度是O(N)。这里N是FreeNodeList的大��。对于一个频�J�释�?�? ��L��pȝ��Q�这个N很可能是个大数。这个boost描述得很清楚�Q�http: //www.boost.org/libs/pool/doc/interfaces/pool.html

注意�Q�不要认为boost提供ordered_free是多此一举。后文我们会在讨论boost::object_pool时解释这一炏V�?br />
��Z��内存池技术的通用内存分配�l��g

sgi-stl把内存池�Q�MemPool�Q�技术进行发扬光大，用它来实现其最�Ҏ(gu��)��的allocator�?br />
�? 大体的思想是，建立16个MemPool�Q?lt;=8字节的内存申��L��0号MemPool分配�Q?lt;=16字节的内存申��L��1号�? MemPool分配�Q?lt;=24字节的内存有2号MemPool分配�Q�以此类推。最后，>128字节的内存申��L��普通的malloc分配�?br />注意
以上代码属于伪代码（struct _FreeNode、_MemBlock�~�译通不�q�）�Q��ƈ且去除了出错处理�?img src ="http://m.shnenglu.com/zzh/aggbug/19616.html" width = "1" height = "1" />

Xiao.Zhu 2007-03-12 10:57 发表评论

Xiao.Zhu — Mon, 12 Mar 2007 02:47:00 GMT

看下面的例子�Q?/font>
例十七：
chars='a';
int*ptr;
ptr=(int*)&s;
*ptr=1298�Q��?br />�? 针ptr是一个int*�c�d��的指针，它指向的�c�d��是int。它指向的地址��是s的首地址。在32位程序中�Q�s占一个字节，int�c�d��占四个字节。最后一�? 语句不但改变了s所占的一个字节，�q�把和s�怏�的高地址方向的三个字节也改变了。这三个字节是干什么的�Q�只有编译程序知道，而写�E�序的�h是不太可能知�? 的。也许这三个字节里存储了非常重要的数据，也许�q�三个字节里正好是程序的一条代码，而由于你�Ҏ(gu��)��针的马虎应用�Q�这三个字节的��D��改变了！�q�会造成崩溃�? 的错误。�?br />让我们再来看一例：
例十八：
1。chara;
2。int*ptr=&a;
...
...
3。ptr++;
4�?ptr=115;
�? 例子完全可以通过�~�译�Q��ƈ能执行。但是看到没有？�W?句对指针ptr�q�行自加1�q�算后，ptr指向了和整�Ş变量a盔R��的高地址方向的一块存储区。这块存�? 区里是什么？我们不知道。有可能它是一个非帔R��要的数据�Q�甚臛_��能是一条代码。而第4句竟然往�q�片存储区里写入一个数据！�q�是严重的错误。所以在使用指针 �Ӟ��E�序员心里必��非常清楚：我的指针�I�竟指向了哪里。在用指针访问数�l�的时候，也要注意不要��出数组的低端和高端界限�Q�否则也会造成�c�M��的错误。�?br />�? 指针的强制类型�{换：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2的类�?大于sizeof(ptr1的类�?�Q�那么在使用指针 ptr1来访问ptr2所指向的存储区时是安全的。如果sizeof(ptr2的类�?��于sizeof(ptr1的类�?�Q�那么在使用指针ptr1来访问ptr2所指向的存储区时是不安全的。至于�ؓ什么，读者结合例十七来想一惻I��应该会明白的�?/font>

Xiao.Zhu 2007-03-12 10:47 发表评论

Xiao.Zhu — Mon, 12 Mar 2007 02:46:00 GMT

可以把一个指针声明成��Z��个指向函数的指针�?/font>
intfun1(char*,int);
int(*pfun1)(char*,int);
pfun1=fun1;
....
....
inta=(*pfun1)("abcdefg",7);//通过函数指针调用函数。�?br />可以把指针作为函数的形参。在函数调用语句中，可以用指针表辑ּ�来作为实参。�?br />例十三：
intfun(char*);
inta;
charstr[]="abcdefghijklmn";
a=fun(str);
...
...
intfun(char*s)
{
intnum=0;
for(inti=0;i{
num+=*s;s++;
}
returnnum;
}
�q�个例子中的函数fun�l�计一个字�W�串中各个字�W�的ASCII码��g��和。前面说了，数组的名字也是一个指针�?/font> 在函数调用中�Q�当�?span lang="EN-US">str作�ؓ实参传递给形参s后，实际是把str的��g��递给了s�Q�s所指向的地址��和str所指向的地址一��_��但是str和s各自占用各自的存储空间�?/span> 在函��C��内对s�q�行自加1�q�算�Q��ƈ不意味着同时对str�q�行了自�?�q�算�?/span>

Xiao.Zhu 2007-03-12 10:46 发表评论

Xiao.Zhu — Mon, 12 Mar 2007 02:46:00 GMT

当我们初始化一个指针或�l�一个指针赋值时�Q�赋值号的左�Ҏ(gu��)��一个指针，赋值号的右�Ҏ(gu��)��一个指针表辑ּ�。在我们前面所丄��例子中， �l�大多数情况下，指针的类型和指针表达式的�c�d��是一��L��Q�指针所指向的类型和指针表达式所指向的类型是一��L��?/span>
例十四：
1。floatf=12.3;
2。float*fptr=&f;
3。int*p;
在上面的例子中，假如我们惌��指针p指向实数f�Q�应该怎么搞？是用下面的语句吗�Q��?br />p=&f;
�? 寏V��因为指针p的类型是int*�Q�它指向的类型是int。表辑ּ�&f的结果是一个指针，指针的类型是float*,它指向的�c�d��是float。两者不一��_��直接赋值的�Ҏ(gu��)��是不行的。至��在我的MSVC++6.0上，�Ҏ(gu��)��针的赋��D��句要求赋值号两边的类型一��_��所指向的类型也一��_��其它的编译器上我没试�q�，大家可以试试。�ؓ了实现我们的目的�Q�需要进�?强制�c�d��转换"�Q��?br />p=(int*)&f;
如果有一个指�?/font> p�Q�我们需要把它的�c�d��和所指向的类型改为TYEP* 和TYPE�Q��?br />那么语法格式是：
(TYPE*)p�Q?/font>
�q�样强制�c�d��转换的结果是一个新指针�Q�该新指针的�c�d��?span lang="EN-US">TYPE*�Q�它指向的类型是TYPE�Q�它指向的地址��是原指针指向的地址。而原来的指针p的一切属性都没有被修攏V�?/span>
一个函数如果��用了指针作�ؓ形参�Q�那么在函数调用语句的实参和形参的结合过�E�中�Q�也会发生指针类型的转换。�?br />例十五：
voidfun(char*);
inta=125,b;
fun((char*)&a);
...
...
voidfun(char*s)
{
charc;
c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;
c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;
}
}
�? 意这是一�?2位程序，故int�c�d��占了四个字节�Q�char�c�d��占一个字节。函数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗�Q�在函数调用语句中，实参&a的结果是一个指针，它的�c�d��是int*�Q�它指向的类型是int。�Ş参这个指针的�c�d��是char*�Q�它指向的类型是char�? �q�样�Q�在实参和�Ş参的�l�合�q�程中，我们必须�q�行一�ơ从int*�c�d��到char*�c�d��的�{换。结合这个例子，我们可以�q�样来想象编译器�q�行转换的过�E�：�~�译器先构造一个��时指针char*temp�Q� 然后执行temp=(char*)&a�Q�最后再把temp的��g��递给s。所以最后的�l�果是：s的类�? 是char*,它指向的�c�d��是char�Q�它指向的地址��是a的首地址。�?br />我们已经知道�Q?/span> 指针的值就是指针指向的地址�Q�在32位程序中�Q�指针的值其实是一�?2位整数�?/span> 那可不可以把一个整数当作指针的值直接赋�l�指针呢�Q�就象下面的语句�Q?/font>
unsignedinta;
TYPE*ptr;//TYPE是int�Q�char或结构类型等�{�类型。�?br />...
...
a=20345686;
ptr=20345686;//我们的目的是要��指针ptr指向地址20345686�Q�十�q�制
�Q��?br />ptr=a;//我们的目的是要��指针ptr指向地址20345686�Q�十�q�制�Q��?br />�~�译一下吧。结果发现后面两条语句全是错的。那么我们的目的��׃��能达��C��吗？不，�q�有办法�Q��?br />unsignedinta;
TYPE*ptr;//TYPE是int�Q�char或结构类型等�{�类型。�?br />...
...
a=某个敎ͼ��q�个数必��M��表一个合法的地址�Q��?br />ptr=(TYPE*)a�Q?/呵呵�Q�这��可以了。�?br />严格说来�q�里�?TYPE*)和指针类型�{换中�?TYPE*)�q�不一栗��这里的(TYP
E*)的意思是把无�W�号整数a的值当作一个地址来看待。上面强调了a的值必��M��表一个合法的地址�Q�否则的话，在你使用ptr的时候，��׃��出现非法操作错误。�?br />��x��能不能反�q�来�Q�把指针指向的地址��x��针的值当作一个整数取出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来�Q�然后再把这个整数当作一个地址赋给一个指针：
例十六：
inta=123,b;
int*ptr=&a;
char*str;
b=(int)ptr;//把指针ptr的值当作一个整数取出来。�?br />str=(char*)b;//把这个整数的值当作一个地址赋给指针str。�?br />好了�Q�现在我们已�l�知道了�Q�可以把指针的值当作一个整数取出来�Q�也可以把一个整数值当作地址赋给一个指针�?/font>

Xiao.Zhu 2007-03-12 10:46 发表评论

Xiao.Zhu — Mon, 12 Mar 2007 02:45:00 GMT

可以声明一个指向结构类型对象的指针�?/font>
例十一�Q��?br />struct MyStruct
{
inta;
intb;
intc;
}
MyStruct ss={20,30,40};//声明了结构对象ss�Q��ƈ把ss的三个成员初始�?br />化�ؓ20�Q?0�?0。�?br />MyStruct *ptr=&ss;//声明了一个指向结构对象ss的指针。它的类型是
MyStruct*,它指向的�c�d��是MyStruct。�?br /> int*pstr=(int*)&ss;//声明了一个指向结构对象ss的指针。但是它的�?br />�c�d��和它指向的类型和ptr是不同的�?/font>
请问怎样通过指针ptr来访问ss的三个成员变量？
�{�案�Q��?br />ptr->a;
ptr->b;
ptr->c;
又请问怎样通过指针pstr来访问ss的三个成员变量？
�{�案�Q��?br />*pstr�Q?/讉K��了ss的成员a。�?br />*(pstr+1);//讉K��了ss的成员b。�?br />*(pstr+2)//讉K��了ss的成员c。�?br />呵呵�Q�虽然我在我的MSVC++6.0上调式过上述代码�Q�但是要知道�Q�这样��用pstr来访问结构成员是不正规的�Q��ؓ了说明�ؓ什么不正规�Q�让我们看看怎样通过指针来访问数�l�的各个单元�Q��?br />例十二：
int array[3]={35,56,37};
int*pa=array;
通过指针pa讉K��数组array的三个单元的�Ҏ(gu��)��是：
*pa;//讉K��了第0号单元�?br />*(pa+1);//讉K��了第1号单元�?br />*(pa+2);//讉K��了第2号单元�?br />从格式上看倒是与通过指针讉K��l�构成员的不正规�Ҏ(gu��)��的格式一栗��?br /> 所有的C/C++�~�译�?/span> 在排列数�l�的单元�Ӟ��L��把各个数�l�单元存攑֜��q�箋的存储区里，单元和单元之间没有空隙�?/span> 但在存放�l�构对象的各个成员时�Q�在某种�~�译环境下，可能会需要字寚w��或双字对齐或者是别的什么对齐，需要在盔R��两个成员之间加若�q�个"填充字节"�Q�这��导致各个成员之间可能会有若�q�个字节的空隙�?/span>
所以，在例十二中，即��*pstr讉K��C��l�构对象ss的第一个成员变量a�Q�也不能保证*(pstr+1)��׃��定能讉K��到结构成员b。因为成员a和成员b�? 间可能会有若�q�填充字节，说不�?(pstr+1)��正好访问到了这些填充字节呢。这也证明了指针的灵�z�L��。要是你的目的就是想看看各个�l�构成员之间到底有没有填充字节，嘿，�q�倒是个不错的�Ҏ(gu��)��。�?br />通过指针讉K��l�构成员的正��方法应该是象例十二中��用指针ptr的方法�?/font>

Xiao.Zhu 2007-03-12 10:45 发表评论

Xiao.Zhu — Mon, 12 Mar 2007 02:44:00 GMT

如果对声明数�l�的语句不太明白的话�Q�请参阅我前�D�|��间脓(chu��ng)出的文章 <<如何理解c和c++的复杂类型声�?gt;>。�?br />数组的数�l�名其实可以看作一个指针。看下例�Q��?br />例八�Q��?br /> int array[10]={0,1,2,3,4,5,6,7,8,9} ,value;
...
...
value=array[0];//也可写成�Q�value=*array;
value=array[3];//也可写成�Q�value=*(array+3);
value=array[4];//也可写成�Q�value=*(array+4);
上例中，一般而言数组名array代表数组本��n�Q�类型是int[10]�Q�但如果�?span lang="EN-US">array看做指针的话�Q�它指向数组的第0个单元，�c�d��是int*�Q�所指向的类型是数组单元的类型即int�?/span> 因此 *array�{�于0��׃��点也不奇怪了。同理，array+3是一个指向数�l�第3个单元的指针�Q�所�?(array+3)�{�于3。其它依此类推。�?br />例九(ji��)�Q��?br />例九(ji��)�Q��?br /> char*str[3]={
"Hello,thisisasample!",
"Hi,goodmorning.",
"Helloworld"
};
chars[80]�Q��?br />strcpy(s,str[0]);//也可写成strcpy(s,*str);
strcpy(s,str[1]);//也可写成strcpy(s,*(str+1));
strcpy(s,str[2]);//也可写成strcpy(s,*(str+2));
上例中， str是一个三单元的数�l�，该数�l�的每个单元都是一个指针，�q�些指�?br />针各指向一个字�W�串。把指针数组名str当作一个指针的话，它指向数�l�的�W?号单元，它的�c�d��是char**�Q�它指向的类型是char*�?/font>
*str也是一个指针，它的�c�d��是char*�Q�它所指向的类型是char�Q�它指向的地址是字�W�串"Hello,thisisasample!"的第一个字�W�的地址�Q�即'H'的地址�?/span> str+1也是一个指针，它指向数�l�的�W?号单元，它的�c�d��是char**�Q�它指向的类型是char*。�?/span>
*(str+1)也是一个指针，它的�c�d��是char*�Q�它所指向的类型是char�Q�它指向 "Hi,goodmorning."的第一个字�W?H'�Q�等�{�。�?/font>
下面�ȝ��一下数�l�的数组名的问题�?/font> 声明了一个数�l?span lang="EN-US">TYPE array[n]�Q�则数组名称array��有了两重含义：�W�一�Q�它代表整个数组�Q�它的类型是TYPE[n]�Q�第二，它是一个指针，该指针的�c�d��? TYPE*�Q�该指针指向的类型是TYPE�Q�也��是数组单元的类型，该指针指向的内存区就是数�l�第0号单元，该指针自己占有单独的内存区，注意它和数组�W? 号单元占据的内存区是不同的。该指针的值是不能修改的，即类似array++的表辑ּ�是错误的�?/span>
在不同的表达式中数组名array可以扮演不同的角艌Ӏ��?br /> 在表辑ּ�sizeof(array)中，数组名array代表数组本��n�Q�故�q�时sizeof函数��出的是整个数组的大��?/span>
在表辑ּ�*array中，array扮演的是指针�Q�因此这个表辑ּ�的结果就是数�l�第0号单元的倹{��sizeof(*array)��出的是数组单元的大��?/span>
表达�?/font> array+n�Q�其中n=0�Q?�Q?�Q?...。）中，array扮演的是指针�Q�故array+n的结果是一个指针，它的�c�d��是TYPE*�Q�它指向的类型是TYPE�Q�它指向数组�W�n号单元。故sizeof(array+n)��出的是指针�c�d��的大��。�?br /> 例十�Q?/font>
int array[10];
int(*ptr)[10];
ptr=&array;
上例中ptr是一个指针，它的�c�d��是int(*)[10]�Q�他指向的类型是int[10] �Q�我们用整个数组的首地址来初始化它。在语句ptr=&array中，array代表数组本��n。�?br />本节中提��C��函数sizeof()�Q�那么我来问一问， sizeof(指针名称)��出�?/span> �I�竟是指针自�w�类型的大小呢还是指针所指向的类型的大小�Q�答案是前者�?/span> 例如�Q?/font>
int(*ptr)[10];
则在32位程序中�Q�有�Q��?br />sizeof(int(*)[10])==4
sizeof(int[10])==40
sizeof(ptr)==4
实际上， sizeof(对象)��出的都是对象自�w�的�c�d��的大��?/span> �Q�而不是别的什�?/font>
�c�d��的大��?/font>

Xiao.Zhu 2007-03-12 10:44 发表评论

Xiao.Zhu — Mon, 12 Mar 2007 02:43:00 GMT

一个表辑ּ�的最后结果如果是一个指针，那么�q�个表达式就叫指针表式�?/font>
下面是一些指针表辑ּ�的例子：
例六�Q��?br />inta,b;
intarray[10];
int*pa;
pa=&a;//&a是一个指针表辑ּ�。�?br />int**ptr=&pa;//&pa也是一个指针表辑ּ�。�?br />*ptr=&b;//*ptr�?amp;b都是指针表达式。�?br />pa=array;
pa++;//�q�也是指针表辑ּ�。�?br />例七�Q��?br />char*arr[20];
char**parr=arr;//如果把arr看作指针的话�Q�arr也是指针表达式�?br />char*str;
str=*parr;//*parr是指针表辑ּ�
str=*(parr+1);//*(parr+1)是指针表辑ּ�
str=*(parr+2);//*(parr+2)是指针表辑ּ�

�׃��指针表达式的�l�果是一个指针，所以指针表辑ּ�也具有指针所��h��的四个要素：指针的类型，指针所指向的类型，指针指向的内存区�Q�指针自�w�占据的内存�?/font>
好了�Q?/font> 当一个指针表辑ּ�的结果指针已�l�明��地��h��了指针自�w�占据的内存的话�Q�这个指针表辑ּ��是一个左��|��否则��׃��是一个左倹{�?span lang="EN-US">
在例七中�Q?amp;a不是一个左��|��因�ؓ它还没有占据明确的内存�?ptr是一个左��|��因�ؓ*ptr�q�个指针已经占据了内存，其实*ptr��是指针pa�Q�既然pa已经在内存中有了自己的位�|�，那么*ptr当然也有了自��q��位置�?/font>

Xiao.Zhu 2007-03-12 10:43 发表评论

�W�三章．�q�算�W?amp;�?

Xiao.Zhu — Mon, 12 Mar 2007 02:42:00 GMT

�q�里 &是取地址�q�算�W�，*�?..书上叫做"间接�q�算�W?。�?br /> &a的运��结果是一个指针，指针的类型是a的类型加�?�Q�指针所指向的类型是a的类型，指针所指向的地址嘛，那就是a的地址。�?/font>
*p的运��结果就五花八门了�?/font> ��M��*p的结果是p所指向的东�?/span> �Q�这个东西有�q�些特点�Q?/span> 它的�c�d��?span lang="EN-US">p指向的类型，它所占用的地址是p所指向的地址�?/span>
例五�Q��?br /> inta=12;
intb;
int*p;
int**ptr;
p=&a;// &a的结果是一个指针，�c�d��是int*�Q�指向的�c�d��是int�Q�指向的地址是a的地址�?/span>
*p=24;//*p的结果，在这里它的类型是int�Q�它所占用的地址是p所指向的地址�Q�显�Ӟ��*p��是变量a。�?br />ptr=&p;//&p的结果是个指针，该指针的�c�d��是p的类型加�?�Q�在�q�里是int **。该指针所指向的类型是p的类型，�q�里是int*。该指针所指向的地址��是指针p自己的地址。�?br />*ptr=&b;//*ptr是个指针�Q?amp;b的结果也是个指针�Q�且�q�两个指针的�c�d��和所指向的类型是一��L��Q�所以用&b来给*ptr赋值就是毫无问题的了。�?br />**ptr=34;//*ptr的结果是ptr所指向的东西，在这里是一个指针，对这个指针再做一��?�q�算�Q�结果就是一个int�c�d��的变�?/font>

Xiao.Zhu 2007-03-12 10:42 发表评论

Xiao.Zhu — Mon, 12 Mar 2007 02:11:00 GMT

指针可以加上或减��M��个整数。指针的�q�种�q�算的意义和通常的数值的加减�q�算的意义是不一��L��。例如：
例二�Q��?br />1。chara[20];
2。int*ptr=a;
...
...
3。ptr++;
�? 上例中，指针ptr的类型是int*,它指向的�c�d��是int�Q�它被初始化为指向整形变量a。接下来的第3句中�Q�指针ptr被加�?�Q�编译器是这样处理的�Q? 它把指针ptr的值加上了sizeof(int)�Q�在32位程序中�Q�是被加上了4。由于地址是用字节做单位的�Q�故ptr所指向的地址由原来的变量a的地址向高地址方向增加�?个字节。�?br />�׃��char�c�d��的长度是一个字节，所以，原来ptr是指向数�l�a的第0号单元开始的四个字节�Q�此时指向了数组a中从�W?号单元开始的四个字节。�?br />我们可以用一个指针和一个��@环来遍历一个数�l�，看例子：
例三�Q��?br />intarray[20];
int*ptr=array;
...
//此处略去为整型数�l�赋值的代码。�?br />...
for(i=0;i<20;i++)
{
(*ptr)++;
ptr++�Q��?br />}
�q�个例子��整型数�l�中各个单元的值加1。由于每�ơ��@环都��指针ptr�?�Q�所以每�ơ��@环都能访问数�l�的下一个单元。�?br />再看例子�Q��?br />例四�Q��?br />1。chara[20];
2。int*ptr=a;
...
...
3。ptr+=5;
�? �q�个例子中，ptr被加上了5�Q�编译器是这样处理的�Q�将指针ptr的值加�?乘sizeof(int)�Q�在32位程序中��是加上�?�?=20。由于地址的单位是字节�Q�故现在的ptr所指向的地址比�v�?后的ptr所指向的地址来说�Q�向高地址方向�U�d��?0个字节。在�q�个例子中，没加5前的ptr指向数组 a的第0号单元开始的四个字节�Q�加5后，ptr已经指向了数�l�a的合法范围之外了。虽然这�U�情况在应用上会出问题，但在语法上却是可以的。这也体现出了指针的灉|��性。�?br />如果上例中，ptr是被减去5�Q�那么处理过�E�大同小异，只不�q�ptr的值是被减�?乘sizeof(int)�Q�新的ptr指向的地址��比原来的ptr所指向的地址向低地址方向�U�d��?0个字节。 �?br />�ȝ��一下，一个指针ptrold加上一个整数n后，�l�果是一个新的指针ptrnew�Q��?br />ptrnew 的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值将比ptrold的值增加了n�? sizeof(ptrold所指向的类�?个字节。就是说�Q�ptrnew所指向的内存区��比ptrold所指向的内存区向高地址方向�U�d��了n�? sizeof(ptrold所指向的类�?个字节。�?br />一个指针ptrold减去一个整数n后，�l�果是一个新的指针ptrnew�Q�ptrnew的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值将比ptrold的值减��了n乘sizeof (ptrold所指向的类�?个字节，��是��_��ptrnew所指向的内存区��比ptrold所指向的内存区向低地址方向�U�d��了n乘sizeof (ptrold所指向的类�?个字节。�?/font>

Xiao.Zhu 2007-03-12 10:11 发表评论

Xiao.Zhu — Mon, 12 Mar 2007 01:52:00 GMT

�W�一章．指针的概�?/font>
指针是一个特�D�的变量�Q�它里面存储的数��D��解释成�ؓ内存里的一个地址�?/span> 要搞清一个指针需要搞清指针的四方面的内容�Q�指针的�c�d��Q�指针所指向�?/span> �c�d��Q�指针的值或者叫指针所指向的内存区�Q�还有指针本�w�所占据的内存区。让我们分别说明�?/span>
先声明几个指针放着做例子：
例一�Q?/span>
(1)int*ptr;
(2)char*ptr;
(3)int**ptr;
(4)int(*ptr)[3];
(5)int*(*ptr)[4];
如果看不懂后几个例子的话�Q�请参阅我前�D�|��间脓(chu��ng)出的文章 << 如何理解 c �?/span> c ++ 的复杂类型声�?/span> >> �?/span>
1 。指针的�c�d��?/span>
从语法的角度看，�?/span> 只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的�c�d��?/span> �q�是指针本��n所��h��的类型。让我们看看例一中各个指针的�c�d��Q?/span>
(1)int*ptr;// 指针的类型是 int*
(2)char*ptr;// 指针的类型是 char*
(3)int**ptr;// 指针的类型是 int**
(4)int(*ptr)[3];// 指针的类型是 int(*)[3]
(5)int*(*ptr)[4];// 指针的类型是 int*(*)[4]
怎么��P��扑և�指针的类型的�Ҏ(gu��)��是不是很��单？
2 。指针所指向的类型�?/span>
当你通过指针来访问指针所指向的内存区�Ӟ��指针所指向的类型决定了�~�译器将把那片内存区里的内容当做什么来看待�?/span>
从语法上看，你只��?/span> 把指针声明语句中的指针名字和名字左边的指针声明符 * ��L��Q�剩下的��是指针所指向的类型�?/span> 例如�Q?/span>
(1)int*ptr;// 指针所指向的类型是 int
(2)char*ptr;// 指针所指向的的�c�d��?/span> char
(3)int**ptr;// 指针所指向的的�c�d��?/span> int*
(4)int(*ptr)[3];// 指针所指向的的�c�d��?/span> int()[3]
(5)int*(*ptr)[4];// 指针所指向的的�c�d��?/span> int*()[4]
在指针的��术�q�算中，指针所指向的类型有很大的作用�?/span>
指针的类�?/span> ( ��x��针本�w�的�c�d�� ) 和指针所指向的类型是两个概念。当你对 C ��来��熟�(zh��n)�时�Q�你会发玎ͼ�把与指针搅和在一��L�� " �c�d�� " �q�个概念分成 " 指针的类�?/span> " �?/span> " 指针所指向的类�?/span> " 两个概念�Q�是�_�N��指针的关键点之一。我看了不少书，发现有些写得差的书中�Q�就把指针的�q�两个概忉|��在一起了�Q�所以看起书来前后矛盾，��看��糊涂�?/span>
3 。指针的��|��或者叫指针所指向的内存区或地址�?/span>
指针的值是指针本��n存储的数��|��q�个值将被编译器当作一个地址�Q�而不是一个一般的数倹{��在 32 位程序里�Q�所有类型的指针的值都是一�?/span> 32 位整敎ͼ�因�ؓ 32 位程序里内存地址全都�?/span> 32 位长�?/span> 指针所指向的内存区��是从指针的值所代表的那个内存地址开始，长度�?/span> si zeof( 指针所指向的类�?/span> ) 的一片内存区�?/span> 以后�Q�我们说一个指针的值是 XX �Q�就相当于说该指针指向了�?/span> XX 为首地址的一片内存区域；我们说一个指针指向了某块内存区域�Q�就相当于说该指针的值是�q�块内存区域的首地址�?/span>
指针所指向的内存区和指针所指向的类型是两个完全不同的概��c��在例一中，指针所指向的类型已�l�有了，但由于指针还未初始化�Q�所以它所指向的内存区是不存在的，或者说是无意义的�?/span>
以后�Q�每遇到一个指针，都应该问问：�q�个指针的类型是什么？指针指的�c�d��是什么？该指针指向了哪里�Q?/span>
4 。指针本�w�所占据的内存区�?/span>
指针本��n占了多大的内存？你只要用函数 sizeof( 指针的类�?/span> ) ��一下就知道了�?/span> �?/span> 32 位��^台里�Q�指针本�w�占据了 4 个字节的长度�?/span>
指针本��n占据的内存这个概念在判断一个指针表辑ּ�是否是左值时很有用�?/span>

Xiao.Zhu 2007-03-12 09:52 发表评论

Xiao.Zhu — Mon, 12 Mar 2007 01:29:00 GMT

1 /*
2  *  linux/lib/string.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6
7 /*
8  * stupid library routines.. The optimized versions should generally be found
9  * as inline code in
10  *
11  * These are buggy as well..
12  */
13
14 #include
15
16 char * ___strtok = NULL;
17
18 char * strcpy(char * dest,const char *src)
19 {
20         char *tmp = dest;
21
22         while ((*dest++ = *src++) != '\0')
23                 /* nothing */;
24         return tmp;
25 }
26
27 char * strncpy(char * dest,const char *src,size_t count)
28 {
29         char *tmp = dest;
30
31         while (count-- && (*dest++ = *src++) != '\0')
32                 /* nothing */;
33
34         return tmp;
35 }
36
37 char * strcat(char * dest, const char * src)
38 {
39         char *tmp = dest;
40
41         while (*dest)
42                 dest++;
43         while ((*dest++ = *src++) != '\0')
44                 ;
45
46         return tmp;
47 }
48
49 char * strncat(char *dest, const char *src, size_t count)
50 {
51         char *tmp = dest;
52
53         if (count) {
54                 while (*dest)
55                         dest++;
56                 while ((*dest++ = *src++)) {
57                         if (--count == 0)
58                                 break;
59                 }
60         }
61
62         return tmp;
63 }
64
65 int strcmp(const char * cs,const char * ct)
66 {
67         register signed char __res;
68
69         while (1) {
70                 if ((__res = *cs - *ct++) != 0 || !*cs++)
71                         break;
72         }
73
74         return __res;
75 }
76
77 int strncmp(const char * cs,const char * ct,size_t count)
78 {
79         register signed char __res = 0;
80
81         while (count) {
82                 if ((__res = *cs - *ct++) != 0 || !*cs++)
83                         break;
84                 count--;
85         }
86
87         return __res;
88 }
89
90 char * strchr(const char * s,char c)
91 {
92         for(; *s != c; ++s)
93                 if (*s == '\0')
94                         return NULL;
95         return (char *) s;
96 }
97
98 size_t strlen(const char * s)
99 {
100         const char *sc;
101
102         for (sc = s; *sc != '\0'; ++sc)
103                 /* nothing */;
104         return sc - s;
105 }
106
107 size_t strnlen(const char * s, size_t count)
108 {
109         const char *sc;
110
111         for (sc = s; *sc != '\0' && count--; ++sc)
112                 /* nothing */;
113         return sc - s;
114 }
115
116 size_t strspn(const char *s, const char *accept)
117 {
118         const char *p;
119         const char *a;
120         size_t count = 0;
121
122         for (p = s; *p != '\0'; ++p) {
123                 for (a = accept; *a != '\0'; ++a) {
124                         if (*p == *a)
125                                 break;
126                 }
127                 if (*a == '\0')
128                         return count;
129                 ++count;
130         }
131
132         return count;
133 }
134
135 char * strpbrk(const char * cs,const char * ct)
136 {
137         const char *sc1,*sc2;
138
139         for( sc1 = cs; *sc1 != '\0'; ++sc1) {
140                 for( sc2 = ct; *sc2 != '\0'; ++sc2) {
141                         if (*sc1 == *sc2)
142                                 return (char *) sc1;
143                 }
144         }
145         return NULL;
146 }
147
148 char * strtok(char * s,const char * ct)
149 {
150         char *sbegin, *send;
151
152         sbegin  = s ? s : ___strtok;
153         if (!sbegin) {
154                 return NULL;
155         }
156         sbegin += strspn(sbegin,ct);
157         if (*sbegin == '\0') {
158                 ___strtok = NULL;
159                 return( NULL );
160         }
161         send = strpbrk( sbegin, ct);
162         if (send && *send != '\0')
163                 *send++ = '\0';
164         ___strtok = send;
165         return (sbegin);
166 }
167
168 void * memset(void * s,char c,size_t count)
169 {
170         char *xs = (char *) s;
171
172         while (count--)
173                 *xs++ = c;
174
175         return s;
176 }
177
178 char * bcopy(const char * src, char * dest, int count)
179 {
180         char *tmp = dest;
181
182         while (count--)
183                 *tmp++ = *src++;
184
185         return dest;
186 }
187
188 void * memcpy(void * dest,const void *src,size_t count)
189 {
190         char *tmp = (char *) dest, *s = (char *) src;
191
192         while (count--)
193                 *tmp++ = *s++;
194
195         return dest;
196 }
197
198 void * memmove(void * dest,const void *src,size_t count)
199 {
200         char *tmp, *s;
201
202         if (dest <= src) {
203                 tmp = (char *) dest;
204                 s = (char *) src;
205                 while (count--)
206                         *tmp++ = *s++;
207                 }
208         else {
209                 tmp = (char *) dest + count;
210                 s = (char *) src + count;
211                 while (count--)
212                         *--tmp = *--s;
213                 }
214
215         return dest;
216 }
217
218 int memcmp(const void * cs,const void * ct,size_t count)
219 {
220         const unsigned char *su1, *su2;
221         signed char res = 0;
222
223         for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
224                 if ((res = *su1 - *su2) != 0)
225                         break;
226         return res;
227 }
228
229 /*
230  * find the first occurrence of byte 'c', or 1 past the area if none
231  */
232 void * memscan(void * addr, unsigned char c, size_t size)
233 {
234         unsigned char * p = (unsigned char *) addr;
235
236         while (size) {
237                 if (*p == c)
238                         return (void *) p;
239                 p++;
240                 size--;
241         }
242         return (void *) p;
243 }

Xiao.Zhu 2007-03-12 09:29 发表评论