解释堆和栈的区别

一、预备知识—程序的内存分配

一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）—   由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap） —   一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放
4、文字常量区  —常量字符串就是放在这里的。 程序结束后由系统释放
5、程序代码区—存放函数体的二进制代码。

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

二、堆和栈的理论知识

2.1申请方式
stack:
由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间

heap:
需要程序员自己申请，并指明大小，在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new运算符
如p2 = (char *)malloc(10);
但是注意p1、p2本身是在栈中的。

2.2
申请后系统的响应
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时， 会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，

这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址

和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

2.4申请效率的比较：
栈由系统自动分配，速度较快。但程序员是无法控制的。
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

2.5堆和栈中的存储内容
栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

2.6存取效率的比较

char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的；
而bbbbbbbbbbb是在编译时就确定的；
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：
#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
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。

堆和栈的区别及内存泄露- -
                                      

    堆和栈是两个不同的概念。在学微机原理时没有感觉到，因为书上只提到了堆栈；数据结构上也提到过栈。但是，始终不明白什么是堆，什么是栈。后来无意翻看了C++，才知道（只是知道，不是明白，更称不上懂）它们的区别。

    简单的来讲堆（heap）上分配的内存，系统不释放，而且是动态分配的。栈（stack）上分配的内存系统会自动释放，它是静态分配的。

    由malloc或new分配的内存都是从heap上分配的内存，从heap上分配的内存必须有程序员自己释放，用free来释放，否则这块内存会一直被占用而得不到释放，就出现了“内存泄露（Memory Leak）”。这样会造成系统的可分配内存的越来越少，导致系统崩溃。

    C/C++是“跨国语言”，在任何平台上都可以使用。所以，Memory Leak在每个系统上都会出现。避免方法就是在写完malloc后，紧跟着就在下一行写free。然后在两行代码中间加其他的代码。哈哈，梁肇新的成对编码，这样会很好的解决。

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

关于wchar_t

在C++标准中，wchar_t是宽字符类型，每个wchar_t类型占2个字节，16位宽。汉字的表示就要用到wchar_t 。char，我们都知道，占一个字节，8位宽。

标准C++中的wprintf()函数以及iostream类库中的类和对象能提供wchar_t宽字符类型的相关操作。

locale loc( "chs" );//定义“区域设置”为中文方式
wcout.imbue( loc );//载入中文字符输入方式
wchar_t str[]=L"中国";//定义宽字符数组，注意L是大写
wcout<<str<<endl;//显示宽字符数组，下同
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 ;

}

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

wchar_t *类型 转为char *类型

 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的缓冲区的大小  
  NULL,  
  NULL   );

关于system（"command"）

system("command")是执行一个dos命令。system("pause")就是执行Dos命令pause，等待用户输入。
system("pause") 与getchar()区别

system("pause") 是调用WINDOWS CONSOLE APP下的命令 PAUSE的。
system("const char*")就是调用WINDOWS CONSOLE APP下的命令。
比如system("exit");
system("ping 192.168.0.1")等等

而getchar()只是C标准库里等待一个字符的函数，两者区别很大。

/*---------------------------------------------------*/
如何使system("pause") 不弹出“按任意键继续”这几个字呢？
用system("pause>nul")  就可以了

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

#include <string>
// 使用CString必须使用MFC，并且不可包含<windows.h>
#define _AFXDLL
#include <afx.h>
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 未重载 << ，所以不可使用 cout << 输出
pWideChar = AnsiToUnicode( pChar );
// 注：printf("%ls") 和 wprintf(L"%s") 一致
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<char*>(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 类
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()函数

　　函数功能：该函数映射一个unicode字符串到一个多字节字符串。

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

　　参数：

　　CodePage：指定执行转换的代码页，这个参数可以为系统已安装或有效的任何代码页所给定的值。你也可以指定其为下面的任意一值：

　　CP_ACP：ANSI代码页；CP_MACCP：Macintosh代码页；CP_OEMCP：OEM代码页；

　　CP_SYMBOL：符号代码页（42）；CP_THREAD_ACP：当前线索ANSI代码页；

　　CP_UTF7：使用UTF-7转换；CP_UTF8：使用UTF-8转换。

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

　　MB_PRECOMPOSED：通常使用预作字符——就是说，由一个基本字符和一个非空字符组成的字符只有一个单一的字符值。这是缺省的转换选择。不能与

　　MB_COMPOSITE值一起使用。

　　MB_COMPOSITE：通常使用组合字符——就是说，由一个基本字符和一个非空字符组成的字符分别有不同的字符值。这是缺省的转换选择。不能与MB_PRECOMPOSED值一起使用。

　　MB_ERR_INVALID_CHARS：如果函数遇到无效的输入字符，它将运行失败，且GetLastErro返回ERROR_NO_UNICODE_TRANSLATION值。

　　MB_USEGLYPHCHARS：使用象形文字替代控制字符。

　　组合字符由一个基础字符和一个非空字符构成，每一个都有不同的字符值。每个预作字符都有单一的字符值给基础/非空字符的组成。在字符è中，e就是基础字符，而重音符标记就是非空字符。

　　函数的缺省动作是转换成预作的形式。如果预作的形式不存在，函数将尝试转换成组合形式。

　　标记MB_PRECOMPOSED和MB_COMPOSITE是互斥的，而标记MB_USEGLYPHCHARS和MB_ERR_INVALID_CHARS则不管其它标记如何都可以设置。

　　lpWideCharStr：指向将被转换的unicode字符串。

　　cchWideChar：指定由参数lpWideCharStr指向的缓冲区的字符个数。如果这个值为-1，字符串将被设定为以NULL为结束符的字符串，并且自动计算长度。

　　lpMultiByteStr：指向接收被转换字符串的缓冲区。

　　cchMultiByte：指定由参数lpMultiByteStr指向的缓冲区最大值（用字节来计量）。若此值为零，函数返回lpMultiByteStr指向的目标缓冲区所必需的字节数，在这种情况下，lpMultiByteStr参数通常为NULL。

　　lpDefaultChar和pfUsedDefaultChar：只有当WideCharToMultiByte函数遇到一个宽字节字符，而该字符在uCodePage参数标识的代码页中并没有它的表示法时，WideCharToMultiByte函数才使用这两个参数。如果宽字节字符不能被转换，该函数便使用lpDefaultChar参数指向的字符。如果该参数是NULL（这是大多数情况下的参数值），那么该函数使用系统的默认字符。该默认字符通常是个问号。这对于文件名来说是危险的，因为问号是个通配符。pfUsedDefaultChar参数指向一个布尔变量，如果Unicode字符串中至少有一个字符不能转换成等价多字节字符，那么函数就将该变量置为TRUE。如果所有字符均被成功地转换，那么该函数就将该变量置为FALSE。当函数返回以便检查宽字节字符串是否被成功地转换后，可以测试该变量。

　　返回值：如果函数运行成功，并且cchMultiByte不为零，返回值是由 lpMultiByteStr指向的缓冲区中写入的字节数；如果函数运行成功，并且cchMultiByte为零，返回值是接收到待转换字符串的缓冲区所必需的字节数。如果函数运行失败，返回值为零。若想获得更多错误信息，请调用GetLastError函数。它可以返回下面所列错误代码：

　　ERROR_INSUFFICIENT_BJFFER；ERROR_INVALID_FLAGS；

　　ERROR_INVALID_PARAMETER；ERROR_NO_UNICODE_TRANSLATION。

　　注意：指针lpMultiByteStr和lpWideCharStr必须不一样。如果一样，函数将失败，GetLastError将返回ERROR_INVALID_PARAMETER的值。

ANSI和UNICODE编码

二者都是字符代码的一种表示形式

ANSI编码用0x88~0xFF范围的2个字节来表示1个字符。

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

我的理解：说白了，ANSI编码是单字节，Unicode编码是宽字符。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/chocolateconanlan/archive/2009/04/09/4058868.aspx