一本色道久久综合狠狠躁的推荐,在线日韩成人,国产亚洲成av人在线观看导航

linux 文�g操作之close

MrRightLeft — Thu, 12 Jul 2012 08:13:00 GMT

#include <iostream>
#include <fcntl.h>
using namespace std;

int main()
{
    int fd = open("demo.txt", O_RDWR, 0);
    close(fd);
    int fd1 = open("demo1.txt", O_RDWR, 0);
    char *szMsg = "hello";
    int size = write(fd, szMsg, strlen(szMsg)+1);
    if (-1 == size)
    {
         cerr << "error!" << endl;
    }
    close(fd1);
    return 0;
}

猜一下上面程序的执行�l�果�?br />在write�Ӟ��fd和fd1的值是一��L��Q�write fd�Ӟ��实际��是write fd1�?br />��Z��避免自己在程序中误操作，可以在close(fd)之后�Q�加上fd = -1;

MrRightLeft 2012-07-12 16:13 发表评论

64位网�l�字节序与主机字节序转换

MrRightLeft — Wed, 20 Jun 2012 08:50:00 GMT

64位网�l�字节序与主机字节序转换

unsigned long long ntohll(unsigned long long val)
{
    if (__BYTE_ORDER == __LITTLE_ENDIAN)
    {
        return (((unsigned long long )htonl((int)((val << 32) >> 32))) << 32) | (unsigned int)htonl((int)(val >> 32));
    }
    else if (__BYTE_ORDER == __BIG_ENDIAN)
    {
        return val;
    }
}

unsigned long long htonll(unsigned long long val)
{
    if (__BYTE_ORDER == __LITTLE_ENDIAN)
    {
        return (((unsigned long long )htonl((int)((val << 32) >> 32))) << 32) | (unsigned int)htonl((int)(val >> 32));
    }
    else if (__BYTE_ORDER == __BIG_ENDIAN)
    {
        return val;
    }
}

MrRightLeft 2012-06-20 16:50 发表评论

如何定义变长的TLV�l�构体？

MrRightLeft — Thu, 14 Jun 2012 07:46:00 GMT

如何定义变长的TLV�l�构体？

TLV是一�U�常用的用于通信的结构体格式。T表示tag�Q�L表示length�Q�V表示value。其中T和L是固定大��的�Q�V是可变大��，L表示的是V的长度。通常用于�l�构化网�l�通信中的数据��。如0x3 3 'aa\0'�Q?x3 5 'aaaa\0',其中0x3表示tag的��|��3 or 5表示的是后面的字�W�串的长度。由于V是可变长度的�Q�所以在定义TLV�l�构�Ӟ��需要将V定义成�ؓ可变大小。可定义如下�Q?br />

struct TLV
{
    uint8_t tag;
    uint16_t len;
    char value[0];
}__attribute__((packed));

注意value分配的是0大小�Q�最后一个成员�ؓ可变长的数组�Q�对于TLV�Q�Type-Length-Value�Q��Ş式的�l�构�Q�或者其他需要变长度的结构体�Q�用�q�种方式定义最好。��用�v来非常方便，创徏�Ӟ��malloc一�D늻�构体大小加上可变长数据长度的�I�间�l�它�Q�可变长部分可按数组的方式访问，释放�Ӟ��直接把整个结构体free掉就可以了。__attribute__(packed)用来强制不对struct TLV�q�行4字节寚w��Q�目的是��Z��获取真实的TLV的空间��用情��c�?br />

int main()
{
    char *szMsg = "aaaaaaaaa";
    cout << sizeof(TLV) << endl; //the size of TLV
    uint16_t len = strlen(szMsg) + 1;
    struct TLV *pTLV;
    pTLV = (struct TLV*)malloc(sizeof(struct TLV) + sizeof(char)*len);
    pTLV->tag = 0x2;
    pTLV->len = len;
    memcpy(pTLV->value, szMsg, len);
    cout << pTLV->value << endl;
free(pTLV);
pTLV = NULL;
    return 0;
}

�q�里有关于设�|�变长TLV的详�l�说明：http://www.douban.com/note/213324857/
�q�里有一个问题，如何实现嵌套TLV�l�构呢？大家有什么好的思�\吗？�Ƣ迎交流
��单实��C��一下嵌套TLV�Q�不知道有没有问题�?br />

#include
using namespace std;

struct TLVNODE
{
    uint8_t tag;
    uint16_t len;
    char value[0];
}__attribute__ ((packed));

struct TLV
{
    int hei;
    uint8_t tag;
    uint16_t len;
    struct TLVNODE value[0];
} __attribute__ ((packed));

int main()
{
    //char *szMsg = "aaaaaaaaaaa";
    cout << sizeof(TLV) << endl;
    //uint16_t len = strlen(szMsg) + 1;

    char *szNodeMsg = "bbbbbbbbbb";
    uint16_t nodelen = strlen(szNodeMsg) + 1;
    struct TLVNODE *pNode = (struct TLVNODE *) malloc(sizeof(struct TLVNODE) + sizeof(char)*nodelen);
    pNode->tag = 0x3;
    pNode->len = nodelen;
    memcpy(pNode->value, szNodeMsg, nodelen);

    struct TLV *pTlv;
    uint16_t nodeSize = sizeof(struct TLVNODE) + sizeof(char)*nodelen;
    pTlv = (struct TLV*)malloc(sizeof(struct TLV) + nodeSize);
    pTlv->tag = 0x2;
    pTlv->len = nodeSize;
//    pTlv->value[0] = (struct TLVNODE)*pNode;
    memcpy(pTlv->value, pNode, nodeSize);
    free(pNode);
    pNode = NULL;
    cout << sizeof(*pTlv) << endl;
    /*for (int i = 0; i < len; ++i)
    {
        pTlv->value[i] = szMsg[i];
    }*/

    /*memcpy(pTlv->value, szMsg, len);*/
    //cout << pTlv->value << endl;
    free(pTlv);
    pTlv = NULL;
    return 0;
}

MrRightLeft 2012-06-14 15:46 发表评论

MrRightLeft — Tue, 10 Apr 2012 15:49:00 GMT

c++中const变量真的不可以修改吗�Q?br />

在学c++的时候，看到的大部分的书�c�对const关键字的介绍都是:const关键字修饰的变量的值是不可被修改的。但是事实真是如此吗�Q�今天做了一个小的实验，发现const变量是可以被修改的。c++代码如下:

1 #include <iostream>
2 using namespace std;
3
4 int main()
5 {
6     const int a = 3;
7     int* p = const_cast<int*>(&a);
8     *p = 4;
9     cout << "value of p: " << *p << endl;
10     cout << "value of a: " << a << endl;
11     cout << "address of p: " << p << endl;
12     cout << "address of a: " << &a << endl;
13
14     return 0;
15 }

上面代码�W?行将a的地址赋值给指针p�Q�然后第8行修改p所指向的地址中的��|��q�行�l�果如下�Q?br />

�q�行�l�果

value of p: 4

value of a: 3

address of p: 0x7fbffff7fc

address of a: 0x7fbffff7fc

如上所�C�结果，指针p所指向的地址和变量a的地址相同�Q�但是p所指地址中的值已�l�发生改变。但是�ؓ何变量a对应的地址中的值已�l�由3变�ؓ4�Q�但是a的值确�?呢？
暂时把这个问题搁��。再来看一下如下的c++代码�Q?br />

1 #include <iostream>
2 using namespace std;
3 const int a = 3;
4 int main()
5 {
6     //const int a = 3;
7     int* p = const_cast<int*>(&a);
8     *p = 4;
9     cout << "value of p: " << *p << endl;
10     cout << "value of a: " << a << endl;
11     cout << "address of p: " << p << endl;
12     cout << "address of a: " << &a << endl;
13
14     return 0;
15 }

如上代码g++�~�译通过�Q�在�q�行时报错如下：

输出�l�果

Segmentation fault (core dumped)

由此可见�Q�在c++中全局const变量和局部const变量的编译器处理的方法是不一��L��。查阅资料得知，全局const变量是不分配内存地址的，它编译器攄��在符可��中作为编译期帔R��Q�全局const变量攑֜�只读数据�D�中�Q�受到只��L��据段的权限保护，当你修改一个只��L��据段中的内容�Ӟ��会得��C��个运行时错误。而局部const变量是放在堆栈之中，因�ؓ在内存中有地址�Q�通过修改地址中的值可以达��C��改const所指内存中值的目的�?br />

MrRightLeft 2012-04-10 23:49 发表评论

声明��序�Q�静态作用域�Q�动态作用域

MrRightLeft — Sat, 18 Jun 2011 09:37:00 GMT

��Z��说明c++的声明顺序所��D��的作用域问题�Q�考虑如下代码

1 #include<iostream>
2 //#include <map>
3 //#include <string>
4 using namespace std;
5
6 int a;
7 void first()
8 {
9     a = 1;
10 }
11
12 void second()
13 {
14     int a = 7;
15     first();
16     cout << "second:" << a << endl;
17 }
18
19
20 int main()
21 {
22     a = 2;
23     int num;
24     cin >> num;
25     if (num > 0)
26     {
27         second();
28     }
29     else
30     {
31         first();
32     }
33     cout << a << endl;
34     return 0;
35 }
36

猜想一下上面的代码输出的结果是什么？main函数中输出的�l�果�?。不��Z��输入的num值是正数�q�是负数�l�果都是1。�ؓ什么会�q�样呢？�q�是因�ؓc++采用的是静态作用域规则。第9行代码是关键所在。对于c++�q�种静态语�a�而言�Q�第9行代码实际修改的是全局变量a的倹{��所以该�E�序的最�l�结果会�?。那么动态作用域规则的语�a�会输��Z��么样的结果呢�Q�那��p��Ҏ(gu��)��所输入的num来决定了�?br />
c++声明变量的作用就是引�q�名字符��P��表明该变量的作用域，而定义则是给变量分配内存�Q��ƈ且绑定值的�q�程。对于调用子函数的过�E�，��Z��扑ֈ�子函��C��的变量的声明作用域，�~�译器采用了静态链接的�Ҏ(gu��)��。对于程序的执行��程�Q�编译器会维护一个栈�Q�栈中会存储与相应调用函数对应的帧。编译器通过栈和帧数据结构来�l�护�E�序执行所调用的函数层�ơ流�E�。要扑ֈ�一个子函数中的变量声明域实际上��是在栈中相应��中寻找该变量的声明。寻找�v�Ҏ(gu��)��当前�z�d��帧，而当前活动��又通过静态链接（相当于指针）与它的父帧相兌��。但是考虑上面的程序，当输入num大于0�Ӟ��应该是先调用second�Q�然后调用first�Q�而second中对变量a重新�q�行了声明，如果栈中�l�护的层�ơ是函数调用的层�ơ，则此时first中修改的变量a应该是second中声明的变量a才是�Q�那么结果输出应该是2�Q�但是事实�ƈ非如此。所以我认�ؓ栈中的静态链接所链接的不是函数调用的层次�Q�而是声明的层�ơ。考虑上面的程序，全局变量a和函数first的声明是在同一层次的，则如果要��L��a中变量的声明�Q�应该首先查找a所在的那个模块所对应的��Q�姑且认为是全局帧吧�Q�看成有一个全局范围的函��C��之对应）�Q�则�q�时扑ֈ�的a的声明应该就是全局变量a。所以如果按照这�U�分析的话，那么�E�序的结果就�?了�?br />
以上只是我的猜想�Q�由于最�q�要忙于考试�Q�没有时间查阅更多资料，且编译原理那块已�l�几乎忘得差不多了。如有错误请各位指正�?br />

MrRightLeft 2011-06-18 17:37 发表评论

准备研究一下redis

MrRightLeft — Mon, 13 Jun 2011 16:36:00 GMT

1.先从redis最初版本开始逐步研究
2.�׃��最�q�准备期末考试�Q�所以每天晚�?2:00-24:00学习2个小�?img src ="http://m.shnenglu.com/aa19870406/aggbug/148615.html" width = "1" height = "1" />

MrRightLeft 2011-06-14 00:36 发表评论

01背包问题

MrRightLeft — Mon, 06 Jun 2011 16:55:00 GMT

  1 #include <iostream>
  2 #include <vector>
  3 #include <algorithm>
  4 #define max(a,b) ((a)>(b))?(a):(b)
  5 using namespace std;
  6 //写出来之后，��试把每一个for循环用for_each来替换。或者将公用的for��程用函数替�?/span>
  7 struct PrintResult
  8 {
  9     void operator()(int i)
10     {
11         cout << i << " ";
12     }
13 }printResult;
14
15 struct PrintVecResult
16 {
17     void operator()(vector<int> vec)
18     {
19         for_each(vec.begin(), vec.end(), printResult);
20         cout << endl;
21     }
22 }printVecResult;
23
24 int knapsack(vector<int> &vecWeight, vector<int> &vecValue, int capacity)
25 {
26     int num = vecWeight.size();
27     vector<vector<int> > f(num, vector<int>(capacity, 0));
28     vector<int> result(num, 0);
29
30     int j = 0;
31     int i = 0;
32     for (i = 1; i <= num; ++i)
33     {
34         for (j = 1; j <= capacity; ++j)
35         {
36             if (j >= vecWeight[i])
37             {
38                 f[i][j] = max(f[i-1][j], f[i-1][j-vecWeight[i]] + vecValue[i]);
39             }
40             else
41             {
42                 f[i][j] = f[i-1][j];
43             }
44         }
45     }
46     //打印f数组�?/span>
47     for_each(f.begin(), f.end(), printVecResult);
48
49     //打印背包所能容�U�的最大�h(hu��n)�?/span>
50     cout << f[num][capacity] << endl;
51
52     //打印产生最大�h(hu��n)值的背包中物品的�~�号
53
54     for (j = capacity, i = num; i >= 1; --i)
55     {
56         //result[i] = f[i][j] > f[i-1][j] ? 1 : 0;
57         if (f[i][j] > f[i-1][j])
58         {
59             result[i] = 1;
60             j = j - vecWeight[i];
61         }
62         else
63         {
64             result[i] = 0;
65         }
66     }
67
68     for (i = 1; i <= num; ++i)
69     {
70         if (1 == result[i])
71         {
72             cout << i << " ";
73         }
74     }
75     return  f[num][capacity] ;
76 }
77
78
79 int main()
80 {
81     int num = 0;
82     int capacity = 0;
83     cin >> num;
84     cin >> capacity;
85
86     vector<int> weight;
87     vector<int> value;
88     weight.push_back(0);
89     value.push_back(0);
90
91     for (int i = 1; i <= num; ++i)
92     {
93         int tempWeight = 0;
94         int tempValue = 0;
95         cin >> tempWeight >> tempValue;
96         weight.push_back(tempWeight);
97         value.push_back(tempValue);
98     }
99
100     knapsack(weight, value, capacity);
101
102     return 0;
103 }

MrRightLeft 2011-06-07 00:55 发表评论

计数排序

MrRightLeft — Sat, 04 Jun 2011 15:50:00 GMT

计数排序实现�Q�以学生�q�龄对学生信息进行排序�?br />

1 #include <iostream>
2 #include <vector>
3 #include <string>
4 #include <algorithm>
5 using namespace std;
6
7 typedef struct StudentInfo
8 {
9     unsigned int age;
10     string name;
11     string major;
12 }StudentInfo;
13
14 struct StudentCount
15 {
16     void operator()(StudentInfo stuInfo)
17     {
18         cout << stuInfo.name << " " << stuInfo.age << stuInfo.major << endl;
19     }
20 }student;
21
22 void Countsort(vector<StudentInfo> &vec, unsigned int nMaxAge)
23 {
24     unsigned int* nCount = (unsigned int*)malloc(sizeof(unsigned int)*nMaxAge);
25     //vector nCount(nMaxAge, 0);
26     memset(nCount, 0, sizeof(unsigned int)*nMaxAge); //assign 0 to the array nCount
27     vector<StudentInfo>::const_iterator iter = vec.begin();
28
29     //count the number of each age
30     for (; iter != vec.end(); ++iter) //用for_each试一�?/span>
31     {
32         ++nCount[iter->age];
33     }
34
35     //��定有多��个数据在当前元素的前面
36     for (int i = 1; i < nMaxAge; ++i)
37     {
38         nCount[i] += nCount[i-1];
39     }
40
41     vector<StudentInfo> StudentSorted;
42     StudentSorted.reserve(vec.size()); //使用reserve预分配空��_��q�些�I�间是否有初始值呢�Q?/span>
43     StudentSorted.resize(vec.size());
44     for (int i = 0; i < vec.size(); ++ i)
45     {
46         int index = --nCount[vec[i].age];
47          StudentSorted[index] = vec[i];
48     }
49
50     //��StudentSorted数据复制到vec中�?/span>
51     vec.swap(StudentSorted);
52     //for_each(vec.begin(), vec.end(), student);
53     free(nCount);
54     nCount = NULL;
55 }
56 int main()
57 {
58     vector<StudentInfo> vec;
59     //初始化vec中的数据
60     for (int i = 0; i < 20; ++i)
61     {
62         StudentInfo stuInfo = {i%10, "qinlei", "CS"};
63         vec.push_back(stuInfo);
64     }
65
66     //开始排�?/span>
67     Countsort(vec, 20);
68     //打印排序后的�l�果
69     for_each(vec.begin(), vec.end(), student);
70     return 0;
71 }

MrRightLeft 2011-06-04 23:50 发表评论

c++对象内存布局

MrRightLeft — Wed, 01 Jun 2011 11:34:00 GMT

一直不明白c++中类中的函数和成员变量在实例化对象后在内存中�I�竟是个什么样的布局。一度以��Z��个对象的内存布局应该包括函数体和成员变量�Q�后来才知道对象的内存布局是不包括函数体的。也��是说实例化一个类后，该对象占用的内存�I�间大小实际上是它的成员变量在内存中所占用�I�间大小�Q�注意，含有静态成员变量和虚函数的�c�d��象例外）。以下分析以下c++�c�d��象在内存中的布局�Q��ƈ且探讨在�l�定一个类的成员变量的�c�d��和数量时�Q�如何��得类实例化后对象所占用的内存空间最��（考虑变量在内存中寚w��Q��?br /> 先给��Z��个类�Q�如下：

1 class A
2 {
3 public:
4     A()
5     {
6         cout << "A" << endl;
7     }
8     virtual ~A()
9     {
10         cout << "~A" << endl;
11     }
12     virtual void printA()
13     {
14         cout << "printA" << endl;
15     }
16 private:
17
18     int a;
19     char c;
20     char e;
21     double b;
22     static double d;
23 };
24
25 int main()
26 {
27
28     A a;
29     cout << sizeof(a) << endl; //输出�?4
30     return 0;
31 }

以上代码输出是：24。也��是说对象a占用内存�I�间大小�?4字节�Q�这�?4字节是怎么得来的呢�Q�我们注意到在类A中存在虚函数�Q�而只有类中有虚函数存在，则可以知道，在每个类对象占用内存�I�间的首部都会有一个虚函数表，�q�个虚函数表可以看成是一个指针数�l�，在对象a中虚函数表中��d��?��，因�ؓ�c�A中存在两个虚函数�Q�每个虚函数都在虚函数表中有一个项对应。现在我们知道虚函数表是2个指针的内存大小�Q�所以是2*4=8字节。然后a,c,e��d��占用4+1+1=6字节�Q�由于需要进行内存对齐，所以实际上它占用的大小�?字节�Q�即�c�d��象中的内存按照占用内存空间最大的变量来对齐，static变量不考虑在内�Q�。然后是b占用8字节�Q�static变量d不占用空��_��l�g��对象a占用�I�间大小�?�Q�虚函数表）+8�Q�a,c,e)+8(b)=24字节。具体可以在vs下调试，查看a的地址�?br />
�׃��要考虑到内存对齐，所以。。今天有事，以后待箋

MrRightLeft 2011-06-01 19:34 发表评论

开源云计算技术系列（五）�Q�崛��L��黑马Sector/Sphere 实战��?(�?

MrRightLeft — Mon, 30 May 2011 14:46:00 GMT

http://www.iteye.com/articles/359

MrRightLeft 2011-05-30 22:46 发表评论

STL之iterator_traits

MrRightLeft — Mon, 30 May 2011 04:01:00 GMT

1.泛型�~�程�Q�编译时�l�定。对应OO的多态（�q�行时绑�?�?br />2.数据�l�构和算法的分离
3.STL左闭叛_��区间
4.http://www.cnblogs.com/jeedispeed/articles/1192614.html

MrRightLeft 2011-05-30 12:01 发表评论

减少�~�译依赖

MrRightLeft — Fri, 27 May 2011 13:43:00 GMT

1.handle class
PImpl手法�Q�隐藏实现细节。��用指针代替变量定义体�?br />
2.interface class
使用abstract class,�U�虚函数�Q�pure function)�Q�多态机制。用父类的接口调用具体子�c�d��象的实现�?br />
3.头文件中只能有声明体�Q�实现部分放到另一文�g中。实��C��声明分开-接口与实现分��R�?br />

MrRightLeft 2011-05-27 21:43 发表评论

MrRightLeft — Tue, 03 May 2011 02:50:00 GMT

[文章] 有关char指针的文章一��?/strong>

作�?/strong>�Q�未�?span class=Apple-converted-space> 来源�Q�月光��Y件站 加入旉���Q?005-2-28　月光软�g�?/p>

[文章] 有关char指针的文章一��（转自:http://www.moon-soft.com/doc/9040.htm)

先看以下代码:
char *p;
p="abc";
你认为是对的�?

�{�案�Q�语法上是对的，但不提倡这�U�写法�?span class=Apple-converted-space>

误区1�Q�没有给p分配内存�I�间��p��|��怎么会是对的呢？
正解�Q�不��h�W�一眼将�q�里的p="abc"看成�?p="abc"�Q�然后就做出了以上的论断。这是比较笨�W�的错误咯：�Q?span class=Apple-converted-space>
看清楚就好啦�Q�其实赋�l�p的是"abc"的地址。再��_��*p="abc"也不对呀�Q�字�W�串可不能这么赋倹{�?span class=Apple-converted-space>

误区2�Q�这"abcd"哪来的地址,怎么能直接赋�l�p�?
正解�Q�先自己试试吧。在2K/XP + VC下运行这�D�代码，是不会出错的�Q�说明这�D�代码�ƈ无问题。晕吧？猜想的话呢，��是"abcd"不知道被攑֜�了什么地方，然后弄来了一个地址�Q�给了p�?span class=Apple-converted-space>

�q�到底是怎么回事呢？

要知道，�q�两个语句和char *p="abc"是完全一��L��Q�所以其中的道理也一栗��?span class=Apple-converted-space>
char *p="abc"曄��q�h��了不��h呀。问问你�Q�p到底是什么类型的�Q�char *�Q�错�Q�是const char *�Q?span class=Apple-converted-space>
也就是说�Q�它所指向的内�Ҏ(gu��)��不可改变的。不�q�要补充的是�Q�a的指向是可以改变的�?span class=Apple-converted-space>
所以�ؓ了不再引赯��会，char *p="abc�q�种写法是不提倡的�?span class=Apple-converted-space>
既然char *p="abcd"被徏议写成const char *p="abcd"�Q�那么char *p; p="abcd";也应该写成const char *p; p="abcd";

讲来讲去�Q�最后来得看看汇�~�代码。看完就明白是怎么回事了。（我才发现汇编代码原来�q�么爽看�Q�VC下，没开�~�译器优化）�Q?span class=Apple-converted-space>
我们重点先看const char *p="abc"和char p[]="abc"有什么不同（都放在main()中声明）�Q?span class=Apple-converted-space>

PHP源码:

            
void main()
            
{
            
  const char *p="abc";
            
}
            

            
3:        const char *p="abc";
            
00401028   mov         dword ptr [ebp-4],offset string "abc" (0041f01c)
            

            
void main()
            
{
            
  char p[]="abc";
            
}
            

            
3:        char p[]="abc";
            
00401028   mov         eax,[string "abc" (0041f01c)]
            
0040102D   mov         dword ptr [ebp-4],eax

看出差别了吗�Q�上一�D�ASM用offset�?abc"的地址�Q�然后赋�l�[ebp-4]�Q�也��是p�Q�下同）�?span class=Apple-converted-space>
而下一�D�ASM却�{了一个弯�Q�先�?abc"的地址转到寄存器eax�Q�然后再转赋�l�p�?span class=Apple-converted-space>

有疑问了�Q��ؓ什么不和上面的一��P��直接用offset�Q�VC是很聪明的（废话�Q�M$的东西呀�Q�，不用offset�Q�恐怕就是用不了了�?span class=Apple-converted-space>
offset是一条伪指��o�Q�在�~�译的时候就已经把偏�U�量��好了。offset是无法执行间接寻址的计��的�?span class=Apple-converted-space>

说明了什么？

const char *p="abc"中的"abc"�Q�在�~�译期间��已�l�处理好�Q�要了一块内存，存�v来了�Q�在把地址赋给p的时候，��可以直接用offset计算�?span class=Apple-converted-space>
而char p[]="abc"中的"abc"�Q�是在运行期间动态分配内存给"abc"�Q�然后再��出地址�Q�赋�l�p。hehe�Q�这同时也说明了数组和指针的�{��h(hu��n)性�?span class=Apple-converted-space>

我们再做一�ơ实验，�q�一�ơ我们把char p[]="abc"攑֜�main()外，�q�在main()内用一个指针再指向p看看�?span class=Apple-converted-space>

PHP源码:

            
char p[]="abc";
            

            
void main()
            
{
            
  char *t=p;
            
}
            

            
5:      char *t=p;
            
00401028   mov         dword ptr [ebp-4],offset p (00421adc)

�q�回p[]的声明放在main()外，变成了全局变量。结果main()内的t取p的指针的时候，直接用offset可以计算出来�?span class=Apple-converted-space>

据小矛_��所��_��字面��|��const�Q�static�Q�inline�Q�全局变量都是攑֜�静态数据区的。（但我感觉��g��不是如此�Q�只是全局变量和字�W�串在编译时��处理好攑֜�一��P��

不难发现�Q�p[]被声明成全局变量后，��可以直接用offset计算地址�Q�说明静态数据区是编译时��已�l�处理好的�?br>再对照const char *p="abc"的ASM�Q�我们马上想刎ͼ�"abc"��是被C/C++存在静态数据区中的�Q�它的地址��是"abc"在静态数据区的地址�Q?span class=Apple-converted-space>

弄清了这个，有些问题也就可以惛_��通了。下面这�U�用法，看来不能说是错误的了�Q�因�?abc"是在静态数据区的，生存期可以说是整个程序：

PHP源码:

            
#include "stdio.h"
            

            
const char *fun()
            
{
            
  const char *p="abc";
            
  return p;
            
}
            

            
void main()
            
{
            
  const char *t=fun();
            
  printf ("%s",t);
            
}

看ASM�Q?span class=Apple-converted-space>

PHP源码:

            
5:      const char *p="abc";
            
00401038   mov         dword ptr [ebp-4],offset string "%d" (0042001c)

一样也是��用offset计算地址�?span class=Apple-converted-space>

C/C++�l�字�W�串的待遇真是太好了。�ؓ了一个字�W�串�Q�几乎可以打破所有的指针规则。晕～～～～�Q�完�Q?span class=Apple-converted-space>

附：�W�一�ơ写�q�么长的文章�Q�写得挺晕的。本来我的C/C++也不是很�U�熟的，ASM也是一知半解，今天在CSDN上�ؓ�q�个问题郁闷了半天，和几个�h讨论了一下，最后就写了�q�么一��文章。希望大家赏脸看看～～～有错一定要指正啊！最后特别感谢小矛_��Q�想飞的菜鸟�Q�骄傲的矛_��Q�菜菜，都是他咯�Q�，�q�有��阿哥（��是Kingzeus咯）的帮忙～～～～～～谢谢咯～～～～～～

__________________
��菜�?-> 菜菜的老虎

骄傲的石头回复：

堆几盘积木，心情好些了，所以再重新写一遍�?span class=Apple-converted-space>
关于字符串的�q�个问题�Q�我一直在心里困惑着。所以呢�Q�昨天就看了一下�?span class=Apple-converted-space>
以前回答别�h的时候，��L��很简单的回答�Q�字�W�串��是const char *指针�Q�指向它的入口地址。现在想来真是惭愧，虽然�q�个事实好象已经为大家所接受�Q�甚��x��有�h探讨�q�这个问题！所以我�怿�我的发现对大家大多数是有好处的�?span class=Apple-converted-space>
首先��L��以下代码

PHP源码:

            
#include 
            
#include 
            

            
using namespace std;
            

            
int main()
            
{
            
    const char *p = 0;
            
    char *p2 = p;
            
    return 0;
            
}

以上代码有问题吗�Q?如果你说没有�Q�请你试一下。很明显�Q�这是有问题的。const是�ؓ了保证不变性，而你把他变成non const�Q�肯定有错误或者警告，要么��p��用const_cast转换�?span class=Apple-converted-space>
所以上面的代码不能通过�~�译�?span class=Apple-converted-space>

那么�q�就很明昄��在lee的post里出��C��问题�Q�当然我以前也一直是�q�么认�ؓ�Q�甚臛_��多�h都是�q�么认�ؓ。难道这是编译器对字�W�串的特�D�处理吗�Q?�q�是其他的原因？

于是我想看看�I�竟。就动用了RTTI�Q�我飞快的键入了以下代码�?span class=Apple-converted-space>

PHP源码:

            
#include 
            
#include 
            

            
using namespace std;
            

            
int main()
            
{
            
   cout << typeid("abc").name() << endl;
            
   return 0;
            
}

你说�l�果是什么？
是char [4]�Q�而不是const char *;
好，�q�个�l�果解决了我心中的疑点，原来是这��P��q�可以很��单的解释char *p = "abc"�q�个问题�?数组是一个char *const 指针�Q�当然可以赋�l�char *指针而不会媄响其帔R��性。所以这是完全正��的赋倹{�?span class=Apple-converted-space>
其实�q�想��h��也很�q�_��Q�指针是没有分配�I�间的地址而已�Q�而数�l�是一�U�容器，占用�q�箋的储存空间。想惛_��W�串��p��知道它是一个数�l�！而不是指针！真正意义上的指针只能是地址�Q�而它在分配了�q�箋的空间后可以作�ؓ数组来��用，�q�是�׃��他们的共性而决定的�?span class=Apple-converted-space>

哈哈�Q�心情愉快，所以也接着看了下lee上面所做的探讨。字�W�串是放在静态储存区没错�Q�毫无疑问。至于位�|�~ 偶不惛_��_��lee在上面分析了很多。所以我只对它进行了一下简单的��试�?span class=Apple-converted-space>
我手头上只有dev c++ �?vc70�~�译器，所以就只用他们�q�行了测试。（打开了全部优化）

PHP源码:

            
#include 
            
#include 
            

            
using namespace std;
            

            
int main()
            
{
            
    char *p = "abc"
            
    char *p2 = "abc";
            
    p[1] = 'k';
            
    p2[1] = 'j'
            
    cout << p1 << endl;
            
    cout << p2 << endl;
            
    return 0;
            
}

�l�果呢？在dev c++下报错，原因我想可能是因为在dev c++在对静态储存区�q�行了保护。而vc70下，通过�Q��ƈ且两个输出是不同的。所以偶�ȝ��vc70产生的msil码，原来vc70每次处理字符串都在静态区分配了空��_��而且�q�两�?abc"是连�l�分配的�Q�这里就没有出现Solmyr说的那种情况。我想一般比较好的编译器也应该这么说。至于vc60,偶没有测试，但是可能Solmyr说的情况会出现吧。但�q�样是不好的�Q�相信这样会出现很多微妙的情��c�?span class=Apple-converted-space>
所以，引用字符串的最��x��式是const char *指针�Q�但char *指针是完全没错的。于情于理，也说的过��d�� ?span class=Apple-converted-space>

如果你还要问�Q�那用指针接受数�l�呢�Q?呵呵�Q�你该仔�l�看看前面了。相信这会给你帮助�?/font>

__________________
不可一日无酒无肉无女�h

MrRightLeft 2011-05-03 10:50 发表评论

�c�M��成员变量和成员函数在内存中的地址

MrRightLeft — Fri, 25 Mar 2011 11:57:00 GMT

#include
using namespace std;

class Test
{
public:
int a;
int b;
void print();
void s();
void ss();
void fs();
};
void Test::print()
{
//cout << "hello" << endl;
}

void Test::s()
{

}

void Test::ss()
{

}
void Test::fs()
{

}

void f()
{
int s = 3;
cout << "&s" << &s << endl;
cout << "f" << endl;
}

class B:Test
{

};

int main()
{
Test t;
cout << sizeof(t) << endl;
cout << &t.a << endl;
cout << &t.b << endl;
Test tt;
cout << &tt.a << endl;
cout << &tt.b << endl;
typedef void (Test::*p)(void);
////Test t;
////t.print();
p fun = &Test::print;
printf("%p\n",fun);
fun = &Test::s;
printf("%p\n",fun);

fun = &Test::ss;
printf("%p\n",fun);
fun = &Test::fs;
printf("%p\n",fun);
f();
cout << "--------" << endl;
B b;
cout << sizeof(b) << endl;
////((Test::*print)fun)();
//Test *p4;
//fun(p4);
// Test t;
// (t.*fun)();
// Test d;
// (d.*fun)();
}

�cȝ��成员函数不是在类实例化的时候蝲入内存的。应该是�~�译链接的时候就在程序文件中��定了相对地址。然后程序蝲入的时候，所有的函数都蝲入到内存的代码区。所以实例化对象的时候，只是甌��了对象的成员变量的地址�Q�成员函数对于所有的�c�d��象来��_��应该只有一份，在代码区��q��。而且�cȝ��成员变量和成员函��C��是存攑֜�一��P��地址不是�q�箋的，是分开存放的）
Test�c�M��的a,b变量地址是连�l�的�Q�每个占4字节。但是s(),ss(),fs()不是和a,b�q�箋的，而且�Q�这些函��C��_��好像也�ƈ不是严格�q�箋的，改一下函数名�Q�地址有可能会变化

MrRightLeft 2011-03-25 19:57 发表评论

Singleton的设�?-�l�典

MrRightLeft — Wed, 09 Mar 2011 04:36:00 GMT

转自�Q?a >http://www.techmango.com/blog/article/DotNet/Thread_Safe_Singleton_Instance.htm
许多同志都会采用一个double check的方式来创徏一个Singleton�Q?/p>

public class Singleton
{
    protected Singleton() { }
    private static volatile Singleton instance = null;
    /// Lazy方式创徏唯一实例的过�E?br>    public static Singleton Instance()
    {
        if (instance == null)         // 外层if
            lock (typeof(Singleton))      // 多线�E�中�׃�n资源同步
                if (instance == null) // 内层if
                    instance = new Singleton();
        return instance;
    }
}

�q�应该是比较�l�典的线�E�安全的Singleton创徏方式�Q�但是还是一个更加简单也很Cool的线�E�安全的Singleton�Q?/p>

class Singleton
{
private Singleton() { }
public static readonly Singleton Instance = new Singleton();
}

　　它省��M��上面�C�Z��中那个laze构造过�E�，�׃��Instance是类的公共静态成员，因此相当于它会在�cȝ��一�ơ被用到的时候被构造，同样的原因也��可以省��L��它放在静态构造函数里的过�E��?/p>

�q�里实例构造函数被��d��定义为私有的�Q�所以客��L��序和子类无法额外构造新的实例，所有的讉K��通过公共静态成员I(y��)nstance获得唯一实例的引用，�W�合Singleton的设计意图�?/p>

MrRightLeft 2011-03-09 12:36 发表评论

c++学习�?--volatile和线�E�安全的singleton模式

MrRightLeft — Wed, 09 Mar 2011 03:47:00 GMT

参考：http://www.cnblogs.com/rocketfan/archive/2009/12/05/1617759.html
volatile�Q?br>1.volatile的作用：
(1) the content of a volatile variable is “unstable” (can change by means unknown to the compiler),

(2) all writes to volatile data are “observable” so they must be executed religiously, and

(3) all operations on volatile data are executed in the sequence in which they appear in the source code.
1.被声明�ؓvolatile的变量其内容是不�E�_��?unstable),它的值有可能��q��译器所不能知晓的情冉|��改变�?br>2.所有对声明为volatile的变量的写操作都是可见的�Q�必��M��格执行be executed religiously�?br>3.所有对声明为volatile的变量的操作�Q�读写）都必��M��格按照源代码的顺序执行�?br>volatile��保每次直接从内存读取变量的倹{��java中的volatile是跨�U�程保证上述三个条�g的，而C++只是单一�U�程内保证�?br>但是即��是JAVA能够跨越�U�程保证�Q�仍然是不够的因为volatile和非volatile操作之间的顺序仍然是未定义的�Q�有可能产生问题�Q�考虑下面的代码：

volatile int vi;

void bar(void) {
vi = 1;
foo();
vi = 0;
}

我们一般会认�ؓvi会在调用foo之前讄��?,调用完后会被�|��ؓ0。然而编译器不会对你保证�q�一点，它会很高兴的��你的foo()�U�M��Q�比如跑到vi = 1前面�Q�只要它知道在foo()里不会涉及到其它的volatile操作。所以安全的�Ҏ(gu��)��是用栅栏memory barrier例如“asm volatile (”" ::: “memory”)加到foo的前面和后面来保证严格的执行��序�?span style="COLOR: red">内存屏障保证代码执行时严格按照源代码的的��序�?br>

MrRightLeft 2011-03-09 11:47 发表评论

main函数之前�q�了��马�Q?谁调用了我的main

MrRightLeft — Tue, 08 Mar 2011 15:34:00 GMT

(转蝲�?a >http://topic.csdn.net/u/20101013/16/e5f2fcbb-528f-4b1a-b85c-aaa8aa9ab3b6.html�Q?br>main函数之前--真正的函数执行入口或开�?/p>

一�U�解�?/p>

实际上，在可执行文�g被加载之后，控制权立即交�l�由�~�译器插入的Start函数�Q�它?y��u)��对后面�q�些全局变量�q�行准备�Q?br>　　　_osver 操作�pȝ��的构件编�?br> _winmajor　操作�pȝ��的主版本�?br> _winminor　操作�pȝ��的次版本�?br> _winver　操作�pȝ��完全版本�?br> __argc　命��o行参��C��?br>　 __argv　指向参数字符串的指针数组
_environ　指向环境变量字符串的指针数组
Start函数初始化堆�q�调用main函数�Q�mian函数�q�回之后,Start函数调用Exit函数�l�束该进�E�．
启动函数Start的源代码在：
　　　crt0.c Microsoft Visual C++
c0w.asm Borladn C++

另一�U�解�?/p>

Some of the stuff that has to happen before main():
set up initial stack pointer
initialize static and global data
zero out uninitialized data
run global constructors

Some of this comes with the runtime library's crt0.o file or its __start() function. Some of it you need to do yourself.
Crt0 is a synonym for the C runtime library.
Depending on the system you're using the follwing may be incomplete, but it should give you an idea. Using newlib-1.9.0/libgloss/m68k/crt0.S as an outline, the steps are:
1. Set stack pointer to value of __STACK if set
2. Set the initial value of the frame pointer
3. Clear .bss (where all the values that start at zero go)
4. Call indirect of hardware_init_hook if set to initialize hardware
5. Call indirect of software_init_hook if set to initialize software
6. Add __do_global_dtors and __FINI_SECTION__ to the atexit function so destructors and other cleanup functions are called when the program exits by either returning from main, or calling exit
7. setup the paramters for argc, argv, argp and call main
8. call exit if main returns

�W�三�U�解释：囫囵C语言�Q�三�Q�：谁调用了我的 main�Q?br>　　　　
　　　　现在最重要的是要跟得上潮流�Q�所以套用比较时髦的话，谁动了我的奶酪。谁调用了我�?main�Q�不�q�作��机工作者，我劝大家�q�是不要赶时髦，今天Java热，明天 .net ��行�Q�什么时髦就学什么。我的意思是先花几年把基本功学好�Q�等你赶旉��的时候也好事半功倍。废话不多说了�?br>　　　　
　　　　我们都听说过一句话�Q?#8220;main是C语言的入�?#8221;。我至今不明白�ؓ什么这么说。就好像如果有�h��_��“挣钱是��?#8221;�Q�肯定无数砖头拍�q�来。这句话应该�?#8220;挣钱是��妞的一个条�Ӟ��只不�q�这个条件特别重�?#8221;。那么上面那句话应该�?“main是C语言中一个符��P��只不�q�这个符��h��较特别�?#8221;
　　　　
　　　　我们看下面的例子�Q?br>　　　　
　　　　/* file name test00.c */
　　　　
　　　　int main(int argc, char* argv)
　　　　{
　　　　 return 0;
　　　　}
　　　　
　　　　�~�译链接它：
　　　　cc test00.c -o test.exe
　　　　会生�?test.exe
　　　　
　　　　但是我们加上�q�个选项�Q?-nostdlib (不链接标准库)
　　　　cc test00.c -nostdlib -o test.exe
　　　　链接器会报错�Q?br>　　　　undefined symbol: __start
　　　　
　　　　也就是说�Q?br>　　　　1. �~�译器缺省是�?__start �W�号�Q�而不�?main
　　　　2. __start �q�个�W�号是程序的起始�?br>　　　　3. main 是被标准库调用的一个符�?br>　　　　
　　　　再来思考一个问题：
　　　　我们写程序，比如一个模块，通常要有 initialize �?de-initialize�Q�但是我们写 C �E�序的时候�ؓ什么有些模块没有这两个�q�程么呢�Q�比如我们程序从 main 开始就可以 malloc�Q�free�Q�但是我们在 main 里面却没有初始化堆。再比如�?main 里面可以直接 printf�Q�可是我们�ƈ没有打开标准输出文�g啊�?不知道什么是 stdin�Q�stdout�Q�stderr 以及 printf �?stdout 关系的群众请先看�?C 语言中文件的概念)�?br>　　　　
　　　　有�h��_��q�些东西不需要初始化。如果�?zh��n)�真得�q�么惻I��h��不要再往下看了，我个��机软�g不适合�(zh��n)��?br>　　　　
　　　　聪明的�h民群众会惻I��一定是�?main 之前�q�了些什么。�ɘq�些函数可以直接调用而不用初始化。通常�Q�我们会在编译器的环境中扑ֈ�一个名字类��g�� crt0.o 的文�Ӟ��q�个文�g中包含了我们刚才所说的 __start �W�号。（crt 大概�?C Runtime 的羃写，请大家帮助确认一下。）
　　　　
　　　　那么真正�?crt0.s 是什么样子呢�Q�下面我们给出部分伪代码�Q?br>　　　　
　　　　///////////////////////////////////////////////////////
　　　　section .text:
　　　　__start:
　　　　
　　　　 :
　　　　 init stack;
　　　　 init heap;
　　　　 open stdin;
　　　　 open stdout;
　　　　 open stderr;
　　　　 :
　　　　 push argv;
　　　　 push argc;
　　　　 call _main; (调用 main)
　　　　 :
　　　　 destory heap;
　　　　 close stdin;
　　　　 close stdout;
　　　　 close stderr;
　　　　 :
　　　　 call __exit;
　　　　////////////////////////////////////////////////////
　　　　
　　　　实际上可能还有很多初始化工作�Q�因为都是和操作�pȝ��相关的，�W�者就不一一列出了�?br>　　　　
　　　　注意�Q?br>　　　　1. 不同的编译器�Q�不一定缺省得�W�号都是 __start�?br>　　　　2. 汇编里面�?_main ��是 C 语言里面�?main�Q�是因�ؓ汇编器和C�~�译器对�W�号的命名有差异�Q�通常是差一个下划线'_'�Q��?br>　　　　3. 目前操作�pȝ��l�构有两个主要的分支�Q�微内核和宏内核。微内核的优�Ҏ(gu��)��Q�结构清晎ͼ��单，内核�l��g较少�Q�便于维护；�~�点是，�q�程间通信较多�Q�程序频�J�进出内核，效率较低。宏内核正好相反。我说这个是什么目的是�Q�没办法保证每个�l��g都在用户�I�间�Q�标准库函数�Q�中初始化，有些�l��g��实可能不要初始化，操作�pȝ��在创��E�的时候在内核�I�间做的。这依赖于操作系�l�的具体实现�Q�比如堆�Q�宏内核�l�构可能在内核初始化�Q�微内核�l�构在用��L��_��即��同样是微内核�Q�这个东东也可能会被拿到内核�I�间初始化�?br>　　　　
　　　　随着 CPU 技术的发展�Q�存储量的迅速扩展，代码复杂�E�度的增加，微内核被��来��多的采用。你会�ؓ�?10% 的效率��代码复杂度增加么�Q�要知道每隔 18 个月 CPU 的速度��׃��M��番。所以我对程序员的要求是�Q�我首先不要你的代码效率高，我首先要你的代码能让 80% 的�h�q�速看懂�ƈ可以�l�护�?/p>

�ȝ��Q?/p>

main函数执行之前�Q�主要就是初始化�pȝ��相关资源�Q?/p>

1.讄��栈指�?/p>

2.初始化static静态和global全局变量�Q�即data�D늚�内容

3.��未初始化部分的赋初��|��数值型short�Q�int�Q�long�{��ؓ0�Q�bool为FALSE�Q�指针�ؓNULL�Q�等�{�，�?bss�D늚�内容

4.�q�行全局构造器�Q�估计是C++中构造函��C��cȝ��?/p>

5.��main函数的参敎ͼ�argc�Q�argv�{�传递给main函数�Q�然后才真正�q�行main函数

MrRightLeft 2011-03-08 23:34 发表评论