我正在学习在 C 中使用 MPI 进行编程，但当其中一个进程调用 MPI_Abort 时，我没有设法从 MPI 通信器/组中的所有进程中找到动态分配的内存（malloc/calloc）会发生什么。
不释放动态分配的内存会导致故障/不可预测的行为？这是否被视为泄漏？
我目前正在研究算法和高级数据结构：因为我熟悉 C 并且它确实在实现和指针使用之上提供了很好的控制水平，我正在使用它来测试到目前为止对主题的理解。
在测试需要动态事物（如列表和树）的结构时，我问自己：由于 C 没有垃圾收集器，如果我不调用 free() 函数来释放动态分配的所有变量，那在哪里记忆去？
其他相关问题包括（抱歉误用了一些术语，我在低级抽象方面没有太多经验）：
编译器是使用实际的硬盘驱动器资源（例如驱动器的 x 记录中的变量）还是“实例化”一部分虚拟内存来编译和运行我的程序？
我的硬盘中是否有很多列表、树和图形，所有这些都涉及从 0 到 100 的计数或字符串“abcd”和“qwerty”？
操作系统是否将所述数据识别为垃圾，或者在我格式化驱动器之前我一直被这些垃圾困住？
我真的很好奇，我从来没有低于 C 的抽象级别。
我知道关于我在这里指出的问题有很多问题，但我找不到任何复杂的答案（无论是在 StackOverflow 上还是在其他来源中）。
我想问一下堆（RAM）碎片问题。
据我所知，有两种碎片： 内部- 与分配单元大小（AU）和分配内存大小 AM 之间的差异有关（浪费内存等于 AM % AU）， 外部- 与空闲的非连续区域有关内存，所以即使空闲内存区域的总和可以处理新的分配请求，如果没有可以处理的继续区域，它也会失败。
这是很清楚的。当“分页”出现时，问题就开始了。
有时候能找到分页解决外部碎片问题的信息。事实上，我同意由于分页操作系统能够创建内存的虚拟连续区域，分配给进程，即使内存的部分在物理上是分散的。
但它究竟如何帮助外部碎片化？ 我的意思是，假设一个页面的大小有 4kB，而我们想要分配 16kB，那么当然我们只需要找到四个空页面帧，即使这些帧在物理上不属于继续区域的一部分。
但是如果分配较小呢？ 我相信页面本身仍然可能是碎片化的，并且（在最坏的情况下）如果旧框架不能用于分配请求的内存，操作系统仍然需要提供一个新框架。
那么（假设最坏的情况），无论是否有分页，分配和释放堆内存（不同大小）的长时间工作的应用程序迟早会因为外部碎片而陷入低内存状态吗？
那么问题来了，外部碎片怎么处理呢？ 自己实现分配算法？分页（如我所写，不确定是否有帮助）？还有什么 ？操作系统（Windows、Linux）是否提供了一些碎片整理方法？
最彻底的解决方案是禁止使用堆，但是对于具有分页、虚拟地址空间、虚拟内存等的平台来说真的有必要吗……唯一的问题是应用程序需要不间断地运行一年？
还有一个问题……内部碎片化是一个含糊不清的术语吗？ 我在某处发现了内部碎片指向页面框架部分的定义，这是浪费的，因为进程不需要更多内存，但单个框架不能由多个进程拥有。
我把问题加粗了，所以赶时间的人不用阅读所有内容也能找到问题。
问候！
paging memory-management fragmentation dynamic-memory-allocation memory-fragmentation
我正在用 C++ 编写一个链表程序。为了实现这个概念，我在全局创建了一个指针“start”，指向列表的第一个元素。
程序完成后，我尝试通过使用 start 和另一个本地声明的指针“p”访问连续节点来删除动态分配的所有内存以防止内存泄漏。在这里，我使用了一个指向相同正确地址的指针，但这个指针不是用于内存分配的指针，而是像任何普通指针一样在本地声明。
我的问题是 - 是否可以使用指向同一位置的普通指针来删除动态分配的内存？
c++ pointers linked-list dynamic-memory-allocation delete-operator
每当我在线程中分配动态内存时，都会出现“大小损坏与 prev_size”错误。每当我在 main() 中分配内存时，它都可以正常工作。但是在线程中分配动态内存会产生错误。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void *fib(void *p);
struct mystruct
{
int *array;
int size;
};
int main(int argc, char *argv[])
{
pthread_t tid;
pthread_attr_t attr;
pthread_attr_init(&attr);
struct mystruct obj;
obj.size = atoi(argv[1]);;
pthread_create(&tid, &attr, fib, (void *)&obj);
pthread_join(tid, NULL);
}
void *fib (void *p)
{
struct mystruct *x = (struct mystruct *)p;
x->array = (int *) malloc (x->size);
for (int i=0; i<x->size; i++){
x->array[i] = i;
printf("The array is = %d\n", x->array[i]);
}
} …如果我有一个容器，比如std::set指向动态对象的指针，那么我如何释放它的元素？
int main()
{
// new scope
{
int x = 10;
std::set<int*> spi;
spi.insert(new int(1));// elem is a dynamic object init from 1
spi.insert(new int[3]()); // elem is a dynamic array of 3 default-init integers
spi.insert(&x); // elem is address of stack memory object
}
}
那么如何有效地释放具有动态内存的元素呢？
我正在实现我自己的队列版本以供练习，但想知道我是否在“pop()”函数中正确删除了元素。
我是 C++ 的新手，我不确定我是否只是删除指向我要删除的节点的指针，而不是实际节点本身。
#include <iostream>
template <typename T>
class Queue {
struct Node {
Node* next;
Node* previous;
T data;
Node(T value){
next = nullptr;
previous = nullptr;
data = value;
}
};
Node* front;
Node* back;
public:
Queue(){
front = nullptr;
back = nullptr;
}
void push_back(T data){
Node* n = new Node(data);
if(front == nullptr){
front = n;
back = n;
} else {
back->next = n;
back = n;
}
}
void print(){
Node* cursor = …我想知道这两行有什么区别：
queue* f=(queue*)malloc(sizeof(queue));
queue* f=(queue*)malloc(sizeof(queue*));
队列的定义如下：
typedef struct queue
{
int arr[N];
int tail;
}queue;
提前致谢！
我的工作站有 128GB 内存。我无法分配占用（连续）内存超过 ~16GB 的数组。但是我可以分配多个数组，每个数组大约需要 15GB。
示例代码：
#include <stdlib.h>
#include <iostream>
using namespace std;
int main(int argc, char **argv)
{
int MM = 1000000;
int NN = 2200; // 2000 is okay, used ~16GB memory; 2200 produces Segmentation fault
double* testMem1d;
testMem1d = (double*) malloc(MM*NN*sizeof(double));
double* testMem1d1; // NN=2000, allocate another array (or two) at the same time is okay
testMem1d1 = (double*) malloc(MM*NN*sizeof(double));
cout << "testMem1d allocated" << endl;
cin.get(); // here is okay, only malloc but not accessing …#include <iostream>
using namespace std;
int main() {
int *p1;
p1 = new int;
int *p2;
p2 = new int;
p2 = p1; // what happens here?
*p1=5;
cout << "pointer 2 is " << *p2 << endl << *p1 << endl; // both give out 5
delete p1; // what happens to p2 ?
cout << "pointer 2 is " << *p2 << endl;
delete p2;
return 0;
}
当我删除指针对象 p1 时会发生什么？什么是指针 p2 现在引用？有人能解释一下吗？谢谢您的帮助