亚洲国产精品久久66,久久久久久久97,麻豆精品久久久久久久99蜜桃

Hsssssss — Tue, 07 Jun 2011 08:38:00 GMT

解释堆和栈的区别

一、预备知�?#8212;�E�序的内存分�?/p>

一个由c/C++�~�译的程序占用的内存分�ؓ以下几个部分
1、栈区（stack�Q?#8212; ��q��译器自动分配释放 �Q�存攑և�数的参数��|��局部变量的值等。其操作方式�c�M��于数据结构中的栈�?br />2、堆区（heap�Q?— 一般由�E�序员分配释放，若程序员不释放，�E�序�l�束时可能由OS回收。注意它与数据结构中的堆是两回事�Q�分配方式倒是�c�M��于链表，呵呵�?br />3、全局区（静态区�Q�（static�Q?#8212;�Q�全局变量和静态变量的存储是放在一块的�Q�初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在盔R��的另一块区域�?- �E�序�l�束后有�pȝ��释放
4、文字常量区 —帔R��字符串就是放在这里的�?�E�序�l�束后由�pȝ��释放
5、程序代码区—存放函数体的二进制代码�?br />

二、例子程�?
�q�是一个前辈写的，非常详细
//main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化�?
main()
{
int b; �?
char s[] = "abc"; �?
char *p2; �?
char *p3 = "123456"; 123456\0在常量区�Q�p3在栈上�?
static int c =0�Q?全局�Q�静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
分配得来�?0�?0字节的区域就在堆区�?
strcpy(p1, "123456"); 123456\0攑֜�帔R��区，�~�译器可能会��它与p3所指向�?123456"优化成一个地斏V�?
}

二、堆和栈的理论知�?

2.1甌��方式
stack:
��q��l�自动分配�?例如�Q�声明在函数中一个局部变�?int b; �pȝ��自动在栈中�ؓb开辟空�?

heap:
需要程序员自己甌��Q��ƈ指明大小�Q�在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new�q�算�W?
如p2 = (char *)malloc(10);
但是注意p1、p2本��n是在栈中的�?

2.2
甌��后系�l�的响应
栈：只要栈的剩余�I�间大于所甌��I�间�Q�系�l�将为程序提供内存，否则��报异常提示栈溢出�?
堆：首先应该知道操作�pȝ��有一个记录空闲内存地址的链表，当系�l�收到程序的甌��Ӟ�� 会遍历该链表�Q�寻扄��一个空间大于所甌��I�间的堆�l�点�Q�然后将该结点从�I�闲�l�点链表中删除，�q�将该结点的�I�间分配�l�程序，另外�Q�对于大多数�pȝ��Q�会在这块内存空间中的首地址处记录本�ơ分配的大小�Q?/p>

�q�样�Q�代码中的delete语句才能正确的释放本内存�I�间。另外，�׃��扑ֈ�的堆�l�点的大��不一定正好等于申��L��大小�Q�系�l�会自动的将多余的那部分重新攑օ��I�闲链表中�?

2.3甌��大小的限�?
栈：在Windows�?栈是向低地址扩展的数据结构，是一块连�l�的内存的区域。这句话的意思是栈顶的地址

和栈的最大容量是�pȝ��预先规定好的�Q�在WINDOWS下，栈的大小�?M�Q�也有的说是1M�Q��M��是一个编译时��q��定的常数�Q�，如果甌��的空间超�q�栈的剩余空间时�Q�将提示overflow。因此，能从栈获得的�I�间较小�?
堆：堆是向高地址扩展的数据结构，是不�q�箋的内存区域。这是由于系�l�是用链表来存储的空闲内存地址的，自然是不�q�箋的，而链表的遍历方向是由低地址向高地址。堆的大��受限于计算机系�l�中有效的虚拟内存。由此可见，堆获得的�I�间比较灉|��Q�也比较大�?

2.4甌��效率的比较：
栈由�pȝ��自动分配�Q�速度较快。但�E�序员是无法控制的�?
堆是由new分配的内存，一般速度比较慢，而且�Ҏ��产生内存��片,不过用�v来最方便.
另外�Q�在WINDOWS下，最好的方式是用VirtualAlloc分配内存�Q�他不是在堆�Q�也不是在栈是直接在�q�程的地址�I�间中保留一快内存，虽然用�v来最不方�ѝ��但是速度快，也最灉|��?

2.5堆和栈中的存储内�?
栈：在函数调用时�Q�第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句�Q�的地址�Q�然后是函数的各个参敎ͼ�在大多数的C�~�译器中�Q�参数是由右往左入栈的�Q�然后是函数中的局部变量。注意静态变量是不入栈的�?
当本�ơ函数调用结束后�Q�局部变量先出栈�Q�然后是参数�Q�最后栈��指针指向最开始存的地址�Q�也��是��d��C��的下一条指令，�E�序��p��点��l�运行�?
堆：一般是在堆的头部用一个字节存攑֠�的大��。堆中的具体内容有程序员安排�?

2.6存取效率的比�?

char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在�q�行时刻赋值的�Q?
而bbbbbbbbbbb是在�~�译时就��定的；
但是�Q�在以后的存取中�Q�在栈上的数�l�比指针所指向的字�W�串(例如�?快�?
比如�Q?
#include
void main()
{
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇�~�代�?
10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
�W�一�U�在��d��时直接就把字�W�串中的元素��d��寄存器cl中，而第二种则要先把指针��D��到edx中，在根据edx��d��字符�Q�显然慢了�?

堆和栈的区别及内存泄�? -

堆和栈是两个不同的概��c��在学微机原理时没有感觉刎ͼ�因�ؓ书上只提��C��堆栈�Q�数据结构上也提到过栈。但是，始终不明白什么是堆，什么是栈。后来无意翻看了C++�Q�才知道�Q�只是知道，不是明白�Q�更�U�C��上懂�Q�它们的区别�?/p>

��单的来讲堆（heap�Q�上分配的内存，�pȝ��不释放，而且是动态分配的。栈�Q�stack�Q�上分配的内存系�l�会自动释放�Q�它是静态分配的�?/p>

由malloc或new分配的内存都是从heap上分配的内存�Q�从heap上分配的内存必须有程序员自己释放�Q�用free来释放，否则�q�块内存会一直被占用而得不到释放�Q�就出现�?#8220;内存泄露�Q�Memory Leak�Q?#8221;。这样会造成�pȝ��的可分配内存的越来越��，��D��pȝ��崩溃�?/p>

C/C++�?#8220;跨国语言”�Q�在��M��q�_��上都可以使用。所以，Memory Leak在每个系�l�上都会出现。避免方法就是在写完malloc后，紧跟着��在下一行写free。然后在两行代码中间加其他的代码。哈哈，梁肇新的成对�~�码�Q�这样会很好的解冟�?/p>

本文来自CSDN博客�Q��{载请标明出处�Q�http://blog.csdn.net/hanlin1985/archive/2008/10/10/3048673.aspx

Hsssssss 2011-06-07 16:38 发表评论

wchar_t

Hsssssss — Sat, 04 Jun 2011 09:00:00 GMT

关于wchar_t

在C++标准中，wchar_t是宽字符�c�d��Q�每个wchar_t�c�d��?个字节，16位宽。汉字的表示��p��用到wchar_t 。char�Q�我们都知道�Q�占一个字节，8位宽�?/p>

标准C++中的wprintf()函数以及iostream�c�d��中的�c�d��对象能提供wchar_t宽字�W�类型的相关操作�?/p>

locale loc( "chs" );//定义“区域讄��”��Z��文方�?br />wcout.imbue( loc );//载入中文字符输入方式
wchar_t str[]=L"中国";//定义宽字�W�数�l�，注意L是大�?br />wcout<wprintf(str);

system("pause");

wchar_t 转换为char 的代码如下：

有如下的wchar_t和char变量

wchar_t w_cn = '�?;
char c_cn[2] = {'0'} ;

char *C2W(wchar_t w_cn , char c_cn[2])

{

//following code convert wchar to char
c_cn[0] = w_cn >> 8 ;
c_cn[1] = w_cn ;
c_cn[2] = '\0';

return c_cn ;

}

其中需要注意的是一�?6位的wchar_t需要用两个8位的char来存储之。我们可以发现另外一个问题，wchar_t的高位字节应该存储在char数组的低位字节�?/p>

wchar_t *�c�d�� 转�ؓchar *�c�d��

CString strName("listen");
char *pcstr = (char *)new char[2 * strName.GetLength()+1] ;

WideCharToMultiByte(   CP_ACP,
0,
strName,     //   要�{换的wchar_t*
-1,
pcstr,   //   接收char*的缓冲区指针
2 * strName.GetLength()+1,         //   pcstr的缓冲区的大��?nbsp;
NULL,
NULL   );

关于system�Q?command"�Q?/p>

system("command")是执行一个dos命��o。system("pause")��是执行Dos命��opause�Q�等待用戯��入�?
system("pause") 与getchar()区别

system("pause") 是调用WINDOWS CONSOLE APP下的命��o PAUSE的�?
system("const char*")��是调用WINDOWS CONSOLE APP下的命��o�?
比如system("exit");
system("ping 192.168.0.1")�{�等

而getchar()只是C标准库里�{�待一个字�W�的函数�Q�两者区别很大�?/p>

/*---------------------------------------------------*/
如何使system("pause") 不弹�?#8220;按�Q意键�l�箋”�q�几个字呢？
用system("pause>nul") ��可以了

wchar_t*,wchar_t,wchat_t数组,char,char*,char数组,std::string,std::wstring,CString

#include
// 使用CString必须使用MFC�Q��ƈ且不可包�?lt;windows.h>
#define _AFXDLL
#include
using namespace std;
//----------------------------------------------------------------------------------
//��?单字节char* 转换�?宽字�?wchar*
inline wchar_t* AnsiToUnicode( const char* szStr )
{
int nLen = MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szStr, -1, NULL, 0 );
if (nLen == 0)
{
   return NULL;
}
wchar_t* pResult = new wchar_t[nLen];
MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szStr, -1, pResult, nLen );
return pResult;
}
//----------------------------------------------------------------------------------
// ��?宽字节wchar_t* 转换单字节char*
inline char* UnicodeToAnsi( const wchar_t* szStr )
{
int nLen = WideCharToMultiByte( CP_ACP, 0, szStr, -1, NULL, 0, NULL, NULL );
if (nLen == 0)
{
   return NULL;
}
char* pResult = new char[nLen];
WideCharToMultiByte( CP_ACP, 0, szStr, -1, pResult, nLen, NULL, NULL );
return pResult;
}
//----------------------------------------------------------------------------------
// ��单字符 string 转换为宽字符 wstring
inline void Ascii2WideString( const std::string& szStr, std::wstring& wszStr )
{
int nLength = MultiByteToWideChar( CP_ACP, 0, szStr.c_str(), -1, NULL, NULL );
wszStr.resize(nLength);
LPWSTR lpwszStr = new wchar_t[nLength];
MultiByteToWideChar( CP_ACP, 0, szStr.c_str(), -1, lpwszStr, nLength );
wszStr = lpwszStr;
delete [] lpwszStr;
}
//----------------------------------------------------------------------------------
int _tmain(int argc, _TCHAR* argv[])
{
char*   pChar = "我喜�Ƣchar";
wchar_t* pWideChar = L"我讨厌wchar_t";
wchar_t   tagWideCharList[100] ;
char   ch = 'A';
char   tagChar[100] = {NULL};
CString   cStr;
std::string str;

// 注：讄��语言环境以便输出WideChar
setlocale(LC_ALL,"chs");

// 注： char* 转换 wchar_t*
// 注： wchar_t 未重�?<< �Q�所以不可��?cout << 输出
pWideChar = AnsiToUnicode( pChar );
// 注：printf("%ls") �?wprintf(L"%s") 一�?br />printf( "%ls\n", pWideChar );

// 注：wchar_t* 转换 wchar_t[]
wcscpy ( tagWideCharList, pWideChar );
wprintf( L"%s\n", tagWideCharList );

// 注：wchar_t[] 转换 wchar_t*
pWideChar = tagWideCharList;
wprintf( L"%s\n", pWideChar );

// 注：char 转换 string
str.insert( str.begin(), ch );
cout << str << endl;

// 注：wchar_t* 转换 string
pWideChar = new wchar_t[str.length()];
swprintf( pWideChar, L"%s", str.c_str());
wprintf( L"%s\n", pWideChar );

// 注：string 转换 char*
pChar = const_cast(str.c_str());
cout << pChar << endl;

// 注：char* 转换 string
str = std::string(pChar);
// 注： cout �?<< 重蝲了string, 若printf 的话必须 printf("%s", str.c_str());
// 而不�?print( "%s", str ); 因�ؓ str 是个 string �c?br />cout << str << endl;

// 注：string 转换 char[]
str = "无聊啊无�?;
strcpy( tagChar, str.c_str() );
printf( "%s\n", tagChar );

// 注：string 转换 CString;
cStr = str.c_str();

// 注：CString 转换 string
str = string(cStr.GetBuffer(cStr.GetLength()));

// 注：char* 转换 CString
cStr = pChar;

// 注：CString 转换 char*
pChar = cStr.GetBuffer( cStr.GetLength() );

// 注：CString 转换 char[]
strncpy( tagChar, (LPCTSTR)CString, sizeof(tagChar));

// 注：CString 转换 wchar_t*
pWideChar = cStr.AllocSysString();
printf( "%ls\n", pWideChar );
}

WideCharToMultiByte()函数

　　函数功能�Q�该函数映射一个unicode字符串到一个多字节字符丌Ӏ?/p>

　　函数原型�Q�int WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPWSTR lpWideCharStr, int cchWideChar, LPCSTR lpMultiByteStr, int cchMultiByte, LPCSTR lpDefaultChar, PBOOL pfUsedDefaultChar );

　　参数�Q?/p>

　　CodePage�Q�指定执行�{换的代码��，�q�个参数可以为系�l�已安装或有效的��M��代码��|��l�定的倹{��你也可以指定其��Z��面的��L��一��|��

　　CP_ACP�Q�ANSI代码��；CP_MACCP�Q�Macintosh代码��；CP_OEMCP�Q�OEM代码��；

　　CP_SYMBOL�Q�符号代码页�Q?2�Q�；CP_THREAD_ACP�Q�当前线索ANSI代码��；

　　CP_UTF7�Q��用UTF-7转换�Q�CP_UTF8�Q��用UTF-8转换�?/p>

　　dwFlags�Q�一�l�位标记用以指出是否未�{换成预作或宽字符�Q�若�l�合形式存在�Q�，是否使用象�Ş文字替代控制字符�Q�以及如何处理无效字�W�。你可以指定下面是标记常量的�l�合�Q�含义如下：

　　MB_PRECOMPOSED�Q�通常使用预作字符——��是��_��׃��个基本字�W�和一个非�I�字�W�组成的字符只有一个单一的字�W�倹{��这是缺省的转换选择。不能与

　　MB_COMPOSITE��g��起��用�?/p>

　　MB_COMPOSITE�Q�通常使用�l�合字符——��是��_��׃��个基本字�W�和一个非�I�字�W�组成的字符分别有不同的字符倹{��这是缺省的转换选择。不能与MB_PRECOMPOSED��g��起��用�?/p>

　　MB_ERR_INVALID_CHARS�Q�如果函数遇到无效的输入字符�Q�它��运行失败，且GetLastErro�q�回ERROR_NO_UNICODE_TRANSLATION倹{�?/p>

　　MB_USEGLYPHCHARS�Q��用象形文字替代控制字�W��?/p>

　　�l�合字符�׃��个基��字符和一个非�I�字�W�构成，每一个都有不同的字符倹{��每个预作字�W�都有单一的字�W�值给基础/非空字符的组成。在字符è中，e��是基础字符�Q�而重音符标记��是非空字符�?/p>

　　函数的缺省动作是转换成预作的形式。如果预作的形式不存在，函数��尝试�{换成�l�合形式�?/p>

　　标记MB_PRECOMPOSED和MB_COMPOSITE是互斥的�Q�而标记MB_USEGLYPHCHARS和MB_ERR_INVALID_CHARS则不��其它标记如何都可以讄��?/p>

　　lpWideCharStr�Q�指向将被�{换的unicode字符丌Ӏ?/p>

　　cchWideChar�Q�指定由参数lpWideCharStr指向的缓冲区的字�W�个数。如果这个��gؓ-1�Q�字�W�串��被讑֮��Z��NULL为结束符的字�W�串�Q��ƈ且自动计��长度�?/p>

　　lpMultiByteStr�Q�指向接收被转换字符串的�~�冲区�?/p>

　　cchMultiByte�Q�指定由参数lpMultiByteStr指向的缓冲区最大��|��用字节来计量�Q�。若此��gؓ�Ӟ��函数�q�回lpMultiByteStr指向的目标缓冲区所必需的字节数�Q�在�q�种情况下，lpMultiByteStr参数通常为NULL�?/p>

　　lpDefaultChar和pfUsedDefaultChar�Q�只有当WideCharToMultiByte函数遇到一个宽字节字符�Q�而该字符在uCodePage参数标识的代码页中�ƈ没有它的表示法时�Q�WideCharToMultiByte函数才��用这两个参数。如果宽字节字符不能被�{换，该函��C��使用lpDefaultChar参数指向的字�W�。如果该参数是NULL�Q�这是大多数情况下的参数��|��Q�那么该函数使用�pȝ��的默认字�W�。该默认字符通常是个问号。这对于文�g名来说是危险的，因�ؓ问号是个通配�W�。pfUsedDefaultChar参数指向一个布��变量，如果Unicode字符串中臛_��有一个字�W�不能�{换成�{��h多字节字�W�，那么函数��将该变量置为TRUE。如果所有字�W�均被成功地转换�Q�那么该函数��将该变量置为FALSE。当函数�q�回以便��查宽字节字符串是否被成功地�{换后�Q�可以测试该变量�?/p>

　　�q�回��|��如果函数�q�行成功�Q��ƈ且cchMultiByte不�ؓ�Ӟ��q�回值是�?lpMultiByteStr指向的缓冲区中写入的字节敎ͼ�如果函数�q�行成功�Q��ƈ且cchMultiByte为零�Q�返回值是接收到待转换字符串的�~�冲区所必需的字节数。如果函数运行失败，�q�回��gؓ零。若惌��得更多错误信息，误��用GetLastError函数。它可以�q�回下面所列错误代码：

　　ERROR_INSUFFICIENT_BJFFER�Q�ERROR_INVALID_FLAGS�Q?/p>

　　ERROR_INVALID_PARAMETER�Q�ERROR_NO_UNICODE_TRANSLATION�?/p>

　　注意�Q�指针lpMultiByteStr和lpWideCharStr必须不一栗��如果一��P��函数��失败，GetLastError��返回ERROR_INVALID_PARAMETER的倹{�?/p>

ANSI和UNICODE�~�码

二者都是字�W�代码的一�U�表�C��Ş�?/p>

ANSI�~�码�?x88~0xFF范围�?个字节来表示1个字�W��?/p>

Unicode�~�码是国际组�l�指定的可以容纳世界上所有文字和服的字符的字�W�编码方案。用数字0~0x10FFFF来映��这些字�W��?/p>

我的理解�Q�说白了�Q�ANSI�~�码是单字节�Q�Unicode�~�码是宽字符�?/p>

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/chocolateconanlan/archive/2009/04/09/4058868.aspx

Hsssssss 2011-06-04 17:00 发表评论