程序博客网 > 看天下杂志知乎

32 位模式下 C/C++ 程序到底可以用多少内存

来源：互联网 发布：看天下杂志知乎 编辑：程序博客网 时间：2024/05/01 20:33

此文版权属于作者所有，任何人、媒体或者网站转载、借用都必须征得作者本人同意！

32位的程序寻址空间是 4G，因此能用的内存应该有 4G，除掉一些系统等使用的乱七八糟的东西，3G内存应该没有问题吧，这些只是猜测，写个程序测一下，结果如下：
测试结论：
1.       栈内存最大可用 768k左右；
2.       堆内存最大可用 1.586G左右。
结果令人沮丧，才 1.6 G!!!
 
测试环境：Windows7 2G、IBMSL300、VC9
附录测试程序等
测试程序只考虑 windows，首先，说明一下相关知识：
内存可以来自两个地方，在栈空间上分配的内存（栈内存）和在堆空间分配的内存（堆内存）。
栈内存，通过 alloca来申请。
堆内存，通过 malloc、new、VirtualAlloc来申请。
测试程序如下：
/* $Id$ */
/**
* \file memory_test.cpp
*
* \brief大内存申请测试
*
* \version $Rev$
* \author  
* \date     2010年04月06日:09:24
*
* \note修改历史：<br>
* <table>
*     <tr><th>日期</th><th>修改人</th><th>内容</th></tr>
*     <tr><td>2010-4-6</td><td></td><td>创建初稿</td>
*     </tr>
* </table>
*/
#include<stdio.h>
#include<malloc.h>
#include<windows.h>
#include<excpt.h>
// alloca: Allocates memory on the stack
staticbool alloca_test(size_ts)
{
  __try{
      alloca(s); printf("    √1 alloca(%u)通过\n",s);
   }__except(GetExceptionCode() == STATUS_STACK_OVERFLOW ){
      printf("    ×1 alloca(%u)失败，内存溢出\n",s);
      _resetstkoflw();
      return false;
   }
  __try{
      alloca(s); printf("    √2 alloca(%u)通过\n",s);
   }__except(GetExceptionCode() == STATUS_STACK_OVERFLOW ){
      printf("    ×2 alloca(%u)失败，内存溢出\n",s);
      _resetstkoflw();
      return false;
   }
  return true;
}
// malloc: Allocates memory blocks.
staticbool malloc_test(size_ts)
{
  void* buf = malloc(s);
  if (buf)
      printf("    √malloc(%u)通过\n",s);
  else
      printf("    ×malloc(%u)失败\n",s);
  free(buf);
  return buf != 0;
}
// malloc: Allocates memory blocks.
staticbool malloc_test2(size_ts)
{
  void* buf1 = malloc(s);
  void* buf2 = malloc(s);
  if (buf1)
      printf("    √buf1 malloc(%u)通过\n",s);
  else
      printf("    ×buf1 malloc(%u)失败\n",s);
  if (buf2)
      printf("    √buf2 malloc(%u)通过\n",s);
  else
      printf("    ×buf2 malloc(%u)失败\n",s);
  free(buf1);
  free(buf2);
  return buf1 != 0 &&buf2 != 0;
}
staticbool new_test(size_ts)
{
  try
   {
      char* buf = new char[s];
      delete[] buf;
      printf("    √new char[%u]成功\n",s);
      return true;
   }catch(...){
      printf("    ×new char[%u]失败\n",s);
      return false;
   }
}
boolVirtualAlloc_test(size_ts)
{
  LPVOID buf =VirtualAlloc(NULL,s, MEM_COMMIT,PAGE_READWRITE);
  VirtualFree(buf, 0,MEM_RELEASE);
  if (buf)
      printf("    √VirtualAlloc(NULL, %u, ..)成功\n",s);
  else
      printf("    ×VirtualAlloc(NULL, %u, ..)失败\n",s);
  return buf != 0;
}
boolVirtualAlloc_test2(size_ts)
{
  LPVOID buf1 =VirtualAlloc(NULL,s, MEM_COMMIT,PAGE_READWRITE);
  LPVOID buf2 =VirtualAlloc(NULL,s, MEM_COMMIT,PAGE_READWRITE);
  VirtualFree(buf1, 0,MEM_RELEASE);
  VirtualFree(buf2, 0,MEM_RELEASE);
  if (buf1)
      printf("    √1 VirtualAlloc(NULL, %u, ..)成功\n",s);
  else
      printf("    ×1 VirtualAlloc(NULL, %u, ..)失败\n",s);
  if (buf2)
      printf("    √2 VirtualAlloc(NULL, %u, ..)成功\n",s);
  else
      printf("    ×2 VirtualAlloc(NULL, %u, ..)失败\n",s);
  return buf1 != 0 &&buf2 != 0;
}
constsize_t SIZE_K = (((size_t)1) << 10);
constsize_t SIZE_M = (SIZE_K << 10);
constsize_t SIZE_G = (SIZE_M << 10);
//把大小转换为xxxK、xxxM、xxxG 之类的描述，非线程安全！
staticchar const*consti2a(size_t s)
{
  static char buf[24];
  if (s < SIZE_M) {
      sprintf(buf,"%uK", s/SIZE_K);
   }else if (s <SIZE_G) {
      sprintf(buf,"%.3fM", (double)s/SIZE_M);
   }else {
      sprintf(buf,"%.3fG", (double)s/SIZE_G);
   }
  return buf;
}
intmain(int, char**)
{
  size_t sizes[] =
   {
      SIZE_K                // 1K
       , 128*SIZE_K         // 128K
       , 256*SIZE_K         // 256K
       , 512*SIZE_K         // 512K
       , 768*SIZE_K         // 768K
       ,SIZE_M              // 1M
       , 512*SIZE_M         // 512M
       , 640*SIZE_M         // 640M
       , 768*SIZE_M         // 768M
       ,SIZE_G              // 1G
       ,SIZE_G + 100*SIZE_M// 1.1G
       ,SIZE_G + 200*SIZE_M// 1.2G
       ,SIZE_G + 300*SIZE_M// 1.3G
       ,SIZE_G + 400*SIZE_M// 1.4G
       ,SIZE_G + 500*SIZE_M// 1.5G
       ,SIZE_G + 600*SIZE_M// 1.6G
       ,SIZE_G + 700*SIZE_M// 1.7G
       ,SIZE_G + 800*SIZE_M// 1.8G
       ,SIZE_G + 900*SIZE_M// 1.9G
   };
  printf("大内存申请测试\n");
  bool res = true;
  for (size_t i = 0, c = sizeof(sizes)/sizeof(sizes[0]);i != c && res; ++i)
   {
      size_t s = sizes[i];
      printf(" 测试申请%s 内存\n",i2a(s));
      res = false;
      res = alloca_test(s) ||res;
      res = malloc_test(s) ||res;
      res = new_test(s) ||res;
      res = VirtualAlloc_test(s) ||res;
      if (s >= 1024*1024*512)
       {
          res = malloc_test2(s) ||res;
          res = VirtualAlloc_test2(s) ||res;
       }
   }
  return 0;
}
运行结果如下：
大内存申请测试
 测试申请 1K内存
   √ 1 alloca(1024)通过
   √ 2 alloca(1024)通过
   √ malloc(1024)通过
   √ new char[1024]成功
   √ VirtualAlloc(NULL, 1024, ..)成功
 测试申请 128K内存
   √ 1 alloca(131072)通过
   √ 2 alloca(131072)通过
   √ malloc(131072)通过
   √ new char[131072]成功
   √ VirtualAlloc(NULL, 131072, ..)成功
 测试申请 256K内存
   √ 1 alloca(262144)通过
   √ 2 alloca(262144)通过
   √ malloc(262144)通过
   √ new char[262144]成功
   √ VirtualAlloc(NULL, 262144, ..)成功
 测试申请 512K内存
   √ 1 alloca(524288)通过
   × 2 alloca(524288)失败，内存溢出
   √ malloc(524288)通过
   √ new char[524288]成功
   √ VirtualAlloc(NULL, 524288, ..)成功
 测试申请 768K内存
   √ 1 alloca(786432)通过
   × 2 alloca(786432)失败，内存溢出
   √ malloc(786432)通过
   √ new char[786432]成功
   √ VirtualAlloc(NULL, 786432, ..)成功
 测试申请 1.000M内存
   × 1 alloca(1048576)失败，内存溢出
   √ malloc(1048576)通过
   √ new char[1048576]成功
   √ VirtualAlloc(NULL, 1048576, ..)成功
 测试申请 512.000M内存
   × 1 alloca(536870912)失败，内存溢出
   √ malloc(536870912)通过
   √ new char[536870912]成功
   √ VirtualAlloc(NULL, 536870912, ..)成功
   √ buf1 malloc(536870912)通过
   √ buf2 malloc(536870912)通过
   √ 1 VirtualAlloc(NULL, 536870912, ..)成功
   √ 2 VirtualAlloc(NULL, 536870912, ..)成功
 测试申请 640.000M内存
   × 1 alloca(671088640)失败，内存溢出
   √ malloc(671088640)通过
   √ new char[671088640]成功
   √ VirtualAlloc(NULL, 671088640, ..)成功
   √ buf1 malloc(671088640)通过
   √ buf2 malloc(671088640)通过
   √ 1 VirtualAlloc(NULL, 671088640, ..)成功
   √ 2 VirtualAlloc(NULL, 671088640, ..)成功
 测试申请 768.000M内存
   × 1 alloca(805306368)失败，内存溢出
   √ malloc(805306368)通过
   √ new char[805306368]成功
   √ VirtualAlloc(NULL, 805306368, ..)成功
   √ buf1 malloc(805306368)通过
   √ buf2 malloc(805306368)通过
   √ 1 VirtualAlloc(NULL, 805306368, ..)成功
   √ 2 VirtualAlloc(NULL, 805306368, ..)成功
 测试申请 1.000G内存
   × 1 alloca(1073741824)失败，内存溢出
   √ malloc(1073741824)通过
   √ new char[1073741824]成功
   √ VirtualAlloc(NULL, 1073741824, ..)成功
   √ buf1 malloc(1073741824)通过
   × buf2 malloc(1073741824)失败
   √ 1 VirtualAlloc(NULL, 1073741824, ..)成功
   × 2 VirtualAlloc(NULL, 1073741824, ..)失败
 测试申请 1.098G内存
   × 1 alloca(1178599424)失败，内存溢出
   √ malloc(1178599424)通过
   √ new char[1178599424]成功
   √ VirtualAlloc(NULL, 1178599424, ..)成功
   √ buf1 malloc(1178599424)通过
   × buf2 malloc(1178599424)失败
   √ 1 VirtualAlloc(NULL, 1178599424, ..)成功
   × 2 VirtualAlloc(NULL, 1178599424, ..)失败
 测试申请 1.195G内存
   × 1 alloca(1283457024)失败，内存溢出
   √ malloc(1283457024)通过
   √ new char[1283457024]成功
   √ VirtualAlloc(NULL, 1283457024, ..)成功
   √ buf1 malloc(1283457024)通过
   × buf2 malloc(1283457024)失败
   √ 1 VirtualAlloc(NULL, 1283457024, ..)成功
   × 2 VirtualAlloc(NULL, 1283457024, ..)失败
 测试申请 1.293G内存
   × 1 alloca(1388314624)失败，内存溢出
   √ malloc(1388314624)通过
   √ new char[1388314624]成功
   √ VirtualAlloc(NULL, 1388314624, ..)成功
   √ buf1 malloc(1388314624)通过
   × buf2 malloc(1388314624)失败
   √ 1 VirtualAlloc(NULL, 1388314624, ..)成功
   × 2 VirtualAlloc(NULL, 1388314624, ..)失败
 测试申请 1.391G内存
   × 1 alloca(1493172224)失败，内存溢出
   √ malloc(1493172224)通过
   √ new char[1493172224]成功
   √ VirtualAlloc(NULL, 1493172224, ..)成功
   √ buf1 malloc(1493172224)通过
   × buf2 malloc(1493172224)失败
   √ 1 VirtualAlloc(NULL, 1493172224, ..)成功
   × 2 VirtualAlloc(NULL, 1493172224, ..)失败
 测试申请 1.488G内存
   × 1 alloca(1598029824)失败，内存溢出
   √ malloc(1598029824)通过
   √ new char[1598029824]成功
   √ VirtualAlloc(NULL, 1598029824, ..)成功
   √ buf1 malloc(1598029824)通过
   × buf2 malloc(1598029824)失败
   √ 1 VirtualAlloc(NULL, 1598029824, ..)成功
   × 2 VirtualAlloc(NULL, 1598029824, ..)失败
 测试申请 1.586G内存
   × 1 alloca(1702887424)失败，内存溢出
   √ malloc(1702887424)通过
   √ new char[1702887424]成功
   √ VirtualAlloc(NULL, 1702887424, ..)成功
   √ buf1 malloc(1702887424)通过
   × buf2 malloc(1702887424)失败
   √ 1 VirtualAlloc(NULL, 1702887424, ..)成功
   × 2 VirtualAlloc(NULL, 1702887424, ..)失败
 测试申请 1.684G内存
   × 1 alloca(1807745024)失败，内存溢出
   × malloc(1807745024)失败
   × new char[1807745024]失败
   × VirtualAlloc(NULL, 1807745024, ..)失败
   × buf1 malloc(1807745024)失败
   × buf2 malloc(1807745024)失败
   × 1 VirtualAlloc(NULL, 1807745024, ..)失败
   × 2 VirtualAlloc(NULL, 1807745024, ..)失败

 

看天下杂志知乎 看天下杂志知乎
原创粉丝点击
热门IT博客
mac 屏幕睡眠时间mac 屏幕睡眠时间
弹道计算软件中文版弹道计算软件中文版
三国杀菜刀的淘宝
淘宝前500名半价怎么抢
数据库中asc什么意思
武藏点胶机200s编程
小金口网络问政
pp助手mac版铃声
杀妻总动员知乎
淘宝微信客源
怎么用图片在淘宝搜索
python如何打开idle
artoolkit linux
百度touch.js api教程
it三里屯
手机怎么开个淘宝网店
知龙教育
远程监控软件免费版
阿里云域名交易
c语言编写九九乘法表
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 买了中兴股票怎么办 股票长期停牌怎么办 基金停牌了怎么办 白色车上的沥青怎么办 车上粘的沥青怎么办 轮胎沾到沥青怎么办 狗吃了沥青怎么办 吃螃蟹后肚子疼怎么办 大理到洱海下雨怎么办 感通索道维修怎么办 侠义值满了怎么办 王者阿轲连败怎么办 孩子说自己笨怎么办 胃炎痛的时候怎么办 汽车垫圈流体低怎么办 把财神扔了怎么办 纸财神爷不想贴怎么办 登山后小腿疼怎么办 爬山后小腿肚疼怎么办 爬山后大腿酸疼怎么办 爬山腿关节疼痛怎么办 爬山后关节疼痛怎么办 的佛仙了怎么办 济州岛多余的钱怎么办 促排几次不成功怎么办 卡西欧走的不准怎么办 毛衣挂破了怎么办 ipad已经托运了怎么办 ipad开机托运了怎么办 迎客松出现发黄怎么办 孕妇喉咙卡鱼刺怎么办 吃了鱼刺到胃里怎么办 怀孕鱼刺卡喉咙怎么办 异地离职后社保怎么办 异地离职后手续怎么办 异地离职后医保怎么办 爆菊一直疼怎么办 小浪底地质灾害村庄到底怎么办? 地质灾害土地没法种怎么办 湿气重不出汗怎么办 收银中客人插队怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里