标签: dynamic-memory-allocation

背景:我正在编写一个使用大量地理数据的C++程序,并且希望一次性加载大块进程.我不得不使用为32位机器编译的应用程序.我正在测试的机器运行的是64位操作系统(Windows 7)并且有6 GB的内存.使用MS VS 2008.

我有以下代码:

byte* pTempBuffer2[3];
try
{
    //size_t nBufSize = nBandBytes*m_nBandCount;
    pTempBuffer2[0] = new byte[nBandBytes];
    pTempBuffer2[1] = new byte[nBandBytes];
    pTempBuffer2[2] = new byte[nBandBytes];
}
catch (std::bad_alloc)
{
    // If we didn't get the memory just don't buffer and we will get data one
    // piece at a time.
    return;
}

我希望能够分配内存,直到应用程序达到32位寻址的4千兆字节限制.但是,当nBandBytes为466,560,000时,第二次尝试新抛出std :: bad_alloc.在这个阶段,进程的工作集(内存)值是665,232 K所以,我似乎无法获得分配的内存.

对于32位Windows中的应用程序,已经提到了2 gig的限制,对于win32,可以使用/ 3GB开关扩展到3 gig.在这种环境下这是一个很好的建议,但与这种情况无关.

在具有32位应用程序的64位操作系统下,您应该分配多少内存？

我正在编写一个包装器容器模板类,std::vector它会自动创建一个multi-resolution pyramid元素std::vector.

现在的关键问题是我希望金字塔的创建是(GCC)自动矢量化的.

内部存储在std :: vector和我的解析金字塔中的所有数据数组都是使用标准的new或allocator模板参数在堆上创建的.有没有我可以帮助编译器强制对我的数据进行特定对齐,以便矢量化可以在具有最佳对齐的元素(数组)(块)上运行(通常为16).

因此我使用自定义分配器, AlignmentAllocator但GCC自动向量化消息输出仍然在第144行中声明包含表达式的未对齐内存std::mr_vector::construct_pyramidmulti_resolution.hpp

for (size_t s = 1; s < snum; s++) { // for each cached scale
...
}

如下

tests/../multi_resolution.hpp:144: note: Detected interleaving *D.3088_68 and MEM[(const value_type &)D.3087_61]
tests/../multi_resolution.hpp:144: note: versioning for alias required: can't determine dependence between *D.3088_68 and *D.3082_53
tests/../multi_resolution.hpp:144: note: mark for run-time aliasing test between *D.3088_68 and *D.3082_53
tests/../multi_resolution.hpp:144: note: versioning for alias …

我知道我可以new char[n]创建一个n字符数组.即使n不是编译时常量,这也可以工作.

但是让我说我​​想要一个大小变量后跟n个字符:

我的第一次尝试是:

struct Test
{
  std::size_t size;
  char a[];
};

然而,似乎new Test[n]没有做我期望的,而是分配n sizes.

我还发现sizeof(std::string)在ideone处是4,所以它似乎可以在一个块中分配size和char数组.

有没有办法实现我所描述的(大概是std::string已经做过的)？

当我std::string使用默认构造函数创建一个时,是否在堆上分配了任何内存？我希望答案不依赖于实施,并且是标准化的.考虑以下:

std::string myString;

我的项目有问题.我必须制作一个可变大小的2D数组来存储一些预测错误.所以这是关于图像.麻烦的是我必须加载不同大小的图像,所以对于每个图像,我必须进入一个文件,相应的像素数的二维数组..我已经搜索了你的问题,但它不是我在看什么for.Can有人帮帮我吗？

谢谢

标题是不言自明的.很容易的问题.我认为这是O(n),但是想在明天的最后一天之前进行验证.

我正在尝试将内存动态分配到堆中，然后在这些内存地址中分配值。我了解如何分配内存，但我如何将例如寄存器中的值分配给第一个动态内存地址？这是我到目前为止：

    push rbp
    mov rbp, rsp            ;initialize an empy stack to create activation records for the rest of the subroutines                                                                                                                        

    mov rax, 0x2d           ;linux system call for brk()                                                                                                                                                                                  
    mov rbx, 0x0            ;to get the adress of the first adress we are allocating we must have 0 in rbx                                                                                                                                
    int 0x80                ;calls the linux operating system kernel for assistance                                                                                                                                                       
    mov [brk_firstLocation], rax ;the first position in the heap will be returned in rax thus i save the first loaction in a …

已经提出将大小的释放特征包括在C++ 1y中.但是我想了解它将如何影响/改进当前的c ++ 低级内存管理？

该提议在N3778中提出,其中说明了此意图.

对于C++ 11,程序员可以定义一个静态成员函数operator delete,它接受一个size参数来指示要删除的对象的大小.等效的全局运算符删除不可用.这种遗漏带来了不幸的性能后果.

现代内存分配器通常在大小类别中进行分配,并且出于空间效率的原因,不要将对象的大小存储在对象附近.然后,取消分配需要搜索包含该对象的大小类别存储.这种搜索可能很昂贵,特别是因为搜索数据结构通常不在内存缓存中.解决方案是允许实现和程序员定义全局运算符delete的大小版本.当大小版本可用时,编译器应优先调用大小不同的版本.

从上面的段落看,它看起来像操作员删除所需的大小信息可以保持并因此通过使用的程序传递.这将避免在重新分配时搜索大小.但是根据我的理解,在分配时,内存管理将大小信息存储在某种标题中(在dlmalloc中解释为boundary-tag方法),这将在解除分配时使用.

T* p = new T();
// Now size information would be stored in the header
// *(char*)(p - 0x4) = size;
// This would be used when we delete the memory????.
delete p;

如果大小信息存储在标题中,为什么重新分配需要搜索它？看起来我错过了一些显而易见的东西,完全不理解这个概念.

此外,在处理C++中的低级内存管理时,如何在程序中使用此功能.希望有人能帮我理解这些概念.

我刚刚开始编程并有一个初学者的问题,我想编写一个函数来逐行读取未知长度的文件.因为我不知道每行的长度所以我使用了getline()函数:

void readDict(FILE *dict_file){
  //Read dic 
  char *line;
  size_t len = 0, read;
  while((read = getline(&line, &len, dict_file))!=-1){
    check(line); 
  }
  free(line);
  return;
}

因为getline()有点类似于malloc()和realloc()字符串,所以如果我继续使用这个函数来读取很多未知长度的行,我会得到内存泄漏还是内存不足？

我有一个关于动态内存分配的问题.

上下文:我正在编写一个程序来读取单词的文本文件,并计算每个单词出现的频率(每行一个单词).

这个特殊的函数读取文件,计算行和字符,然后动态地将内存分配给字符串指针数组,一个数组存储每行的字符数和字符串本身.(其他部分与我的问题不太直接相关).

问题:如果空间不足,我应该多久重新分配一次内存？我设置了一个常量("memstart")来设置初始内存分配值.在下面的代码片段中,我重新分配了"memstart"值的每一行.如果重新分配更大的内存块而不是每次增加1"变量类型"的内存空间,程序是否会更快？

对于这样的事情,最佳做法是什么？

代码剪辑:

int read_alloc(FILE* fin, FILE *tmp, char **wdp, int *sz){
    int line_cnt= 0, chr, let=1;
    do{
        chr=getc(fin);
        let++;          
        //count characters

        if(chr!=EOF){
            chr=tolower(chr);
            fputc(chr, tmp);
        }               
        //convert to lcase and write to temp file

        if ('\n' == chr || chr==EOF){
            sz[(line_cnt)]=((let)*sizeof(char));            //save size needed to store string in array
            *(wdp+(line_cnt))=malloc((let)*sizeof(char));   //allocate space for the string
            if ((line_cnt-1) >= memstart){
                realloc(wdp, (sizeof(wdp)*(memstart+line_cnt)));    //if more space needed increase size
                realloc(sz, (sizeof(sz)*(memstart+line_cnt)));
            }
            line_cnt++;         
            let=1;
        }
    } …