标签: dynamic-memory-allocation

当我意识到我对指针有很大的误解时,我正在解决一些编程练习.请有人解释一下这段代码导致C++崩溃的原因.

#include <iostream>

int main()
{
    int* someInts = new int[5];

    someInts[0] = 1; 
    someInts[1] = 1;

    std::cout << *someInts;
    someInts++; //This line causes program to crash 

    delete[] someInts;
    return 0;
}

PS我知道没有理由在这里使用"new",我只是尽可能地使用这个例子.

获取一个对齐的内存块有几个选项,但它们非常相似,问题主要归结为您所针对的语言标准和平台.

C11

void * aligned_alloc (size_t alignment, size_t size)

POSIX

int posix_memalign (void **memptr, size_t alignment, size_t size)

视窗

void * _aligned_malloc(size_t size, size_t alignment);

当然,手动对齐也是一种选择.

英特尔提供另一种选择

英特尔

void* _mm_malloc (int size, int align)
void _mm_free (void *p)

基于英特尔发布的源代码,这似乎是分配工程师喜欢的对齐内存的方法,但我找不到任何将其与其他方法进行比较的文档.我发现的最接近的只是承认存在其他对齐的内存分配例程.

https://software.intel.com/en-us/articles/memory-management-for-optimal-performance-on-intel-xeon-phi-coprocessor-alignment-and

要动态分配一段对齐的内存,请使用posix_memalign,它由GCC和Intel Compiler支持.使用它的好处是您不必更改内存处理API.您可以像往常一样使用free().但要注意参数配置文件:

  int posix_memalign(void**memptr,size_t align,size_t size);

英特尔编译器还提供另一组内存分配API.C/C++程序员可以使用_mm_malloc和_mm_free来分配和释放对齐的内存块.例如,以下语句为8个浮点元素请求64字节对齐的内存块.

  farray =(float*)__ mm_malloc(8*sizeof(float),64);

必须使用_mm_free释放使用_mm_malloc分配的内存.在使用_mm_malloc分配的内存上调用free或在使用malloc分配的内存上调用_mm_free将导致不可预测的行为.

从用户的角度来看,明显的区别是_mm_malloc需要直接的CPU和编译器支持以及分配的内存_mm_malloc必须被释放_mm_free.鉴于这些缺点,使用_mm_malloc?它的原因是什么？它有轻微的性能优势吗？历史事故？

我们想在项目的某些部分使用pimpl习语.项目的这些部分也恰好是禁止动态内存分配的部分,这个决定不在我们的控制范围内.

所以我要问的是,在没有动态内存分配的情况下,有没有一种干净又好的方法来实现pimpl习语？

编辑
以下是一些其他限制:嵌入式平台,标准C++ 98,没有外部库,没有模板.

我正在看新操作员的签名.这是:

void* operator new (std::size_t size) throw (std::bad_alloc);

但是当我们使用这个运算符时,我们从不使用强制转换.即

 int *arr = new int;

那么,如何C++类型的指针转换void*到int*在这种情况下.因为,即使malloc返回a void*,我们也需要明确使用强制转换.

我正在寻找一些在Linux下使用汇编语言并使用系统调用的动态内存分配的良好代码示例,而不是malloc和朋友.

有哪些最简单但有效的方法呢？

在Intel 386+计算机上.

动态内存分配是C编程中非常重要的主题.但是,我无法找到一个很好的解释,这使我们能够做到这一点,或者为什么需要这样做.

我们不能只声明变量和结构,而不必使用malloc()吗？

作为旁注,有什么区别:

ptr_one = (int *)malloc(sizeof(int));

和

int *ptr_one = malloc(sizeof(int));

从man realloc:realloc()函数返回一个指向新分配的内存的指针,该内存适用于任何类型的变量,可能与ptr不同,如果请求失败则为NULL.

所以在这段代码中:

ptr = (int *) malloc(sizeof(int));
ptr1 = (int *) realloc(ptr, count * sizeof(int));
if(ptr1 == NULL){           //reallocated pointer ptr1
    printf("Exiting!!\n");
    free(ptr);
    exit(0);
}else{
    free(ptr);          //to deallocate the previous memory block pointed by ptr so as not to leave orphaned blocks of memory when ptr=ptr1 executes and ptr moves on to another block
    ptr = ptr1;         //deallocation using free has been done assuming that ptr and ptr1 do not point to the same address                     
}

仅仅假设重新分配的指针指向不同的记忆块而不是同一个块就足够了.因为如果假设变为false并且realloc返回ptr指向的原始内存块的地址然后free(ptr)执行(由于评论中给出的原因)然后内存块将被删除,程序将疯狂.我应该放入另一个条件来比较ptr和ptr1的相等性并排除执行free(ptr)语句吗？

我正在尝试编写一个程序,该程序从文本文件中读取一系列字符串,并将它们存储在字符串数组中,为每个元素动态分配内存.我的计划是使用指针将每个字符串存储在一个数组中,然后在读入更多数据时增大数组大小.我无法理解为什么我的测试代码无效.这是一个可行的想法吗？

char *aPtr;
aPtr =(char*)malloc(sizeof(char));

aPtr[0]="This is a test";


printf("%s",aPtr[0]);

我想知道一个实现是否std::variant必须"平坦"或是否允许为其成员动态分配内存,这样一系列变体会退化为一系列指针,从而破坏缓存局部性.

我已经读过delete[]需要运算符,因为运行时环境不会保留有关分配的块是否是需要析构函数调用的对象数组的信息,但它确实保留了有关存储分配块的内存位置的信息,当然还有块的大小.
如果需要在删除时调用析构函数,还需要记住一点元元数据,那么为什么不这样做呢？

我很确定有一个很好的解释,我不是在质疑它,我只想知道它.