标签: memory-management

我这里有我的代码：

int main(){
  printf("%lu\n",(1 * sizeof(int)));
  int* hello=malloc(1 * sizeof(int));
  hello[1000000]=10;
  printf("%d \n",hello[1000000]);
  printf("%lu \n", sizeof(hello));

  int* goodbye=malloc(100 * sizeof(int));
  printf("%lu \n",sizeof(goodbye));

  hello=goodbye;

  printf("%lu \n",sizeof(hello));

  hello=realloc(hello,20);

  hello[1]=0;

  printf("%lu \n",sizeof(hello));
}

它输出这个：

4 10 8 8 8 8

这个 throws 没有警告或错误，这对我来说很奇怪，因为我只为数组 hello 分配了 4 个字节，但可以访问 hello[1000000]。

另外，我尝试调整你好和再见的大小，但大小保持不变。在第 10 行，我做了 hello=goodbye; 哪个应该调整它的大小？我对 C 内存的东西有点陌生。Realloc 也不会改变我的数组的大小。我试图使“hello”成为一个动态大小的数组。我在这里做错了什么？

该代码应该是重新分配内存并更改 int 数组的大小的准系统。

如何删除 KDB/q 内存中当前的所有变量？

而不是像这样手动列出变量（我有很多变量）：

delete a,b,c from `.

我想做这样的事情（下面的命令不起作用）：

delete (system "v") from `.
{delete x from `.} each system "v"

感谢您的帮助！

《算法导论》中有如下练习：

考虑在具有相对少量快速主内存和相对大量较慢磁盘存储的计算机中实现堆栈。PUSH 和 POP 操作适用于单字值。我们希望支持的堆栈可能会变得比内存容量大得多，因此其中大部分必须存储在磁盘上。...

...一个简单但低效的堆栈实现将整个堆栈保留在磁盘上。由于磁盘操作相对昂贵，现在考虑一种堆栈实现，其中我们将堆栈的一页保留在内存中。（我们还维护少量内存来跟踪当前内存中的页面。）仅当相关磁盘页面驻留在内存中时，我们才能执行堆栈操作。如果需要，我们可以将当前内存中的页面写入磁盘，并将新页面从磁盘读入内存。如果相关的磁盘页面已经在内存中，则不需要磁盘访问。...

我想在 C 或 C++ 的实际代码中实现这一点。我知道如何使用mmap()并且可以使用内存映射磁盘文件来实现此目的，但我不知道如何实现“一个堆栈实现，其中我们将堆栈的一页保留在内存中”。有没有办法以 C/C++ 指针的方式逐页管理内存？

push_back当我们使用 时会发生什么size() == capacity()？

关于这个问题我听到了很多意见。最流行的是：当向量的大小达到其容量时，它分配一个新的内存区域，将向量复制到新分配的内存，并将新值插入到向量的末尾。

但是，为什么我们必须这样做呢？我们有一个虚拟内存机制，我们可以直接调用realloc(vec.data(), (sizeof(vec::value_type) * vec.size()) * 2). 这Allocator将为我们提供一个新的内存页，并且虚拟地址使内存“一致”，因此我们不必从向量中复制值。

难道我对虚拟内存机制的理解有误？

考虑结构：

struct MainStruct {
    struct A a;
    struct B b;
    struct C c;
};

通常，编译器应该将 a、b 和 c 依次放入内存中并进行一定的对齐。

但是，如果我想让 a、b 和 c 的变量始终以 mainStruct 内的精确偏移量开始，而与它们的大小无关，该怎么办？“在编译时”执行此操作的便捷方法是什么？

举个例子： mainStruct 总共可能有 256 个字节，而a总是从 开始&mainStruct，b总是从 开始&mainstruct + 100，c总是从 开始&mainStruct + 179。

编辑： mainStruct 的地址可能是可变的。这里重要的一点是偏移量始终是恒定的。每当我定义类型的变量时Struct MainStruct，该变量应该始终具有相同的内存布局，并且内部结构具有恒定的偏移量。

假设我们的 中存储了 100 万个元素std::vector<T>，它的容量已满。现在我只想在其中添加 1 个元素。根据向量的概念，现在向量的容量将在堆中的新内存中增加一倍，并且所有 100 万个元素将被复制到新的内存位置。这似乎是一项艰巨的任务。有什么方法可以避免这种复制并仅在下一个位置添加这个新元素吗？

没有什么。我想不出有什么方法可以避免。大多数开发人员建议我使用另一个容器。

要使用旧向量（我想清空）的内容创建一个新向量，我将使用：

foo.bar = my_vector.drain(0..).collect();

这是惯用的 Rust 吗？

Drain() 是否已优化掉，原始向量的内存是否已分配给新向量？

或者每个元素都被一一复制到新的堆分配中？

我想我也许终于在指针理解上有了一点突破，但我正在努力解决一个看似简单的问题，我想让一个指针指向与另一个指针相同的内存地址，例如：

char* foo = "foo"; // memory address: 0x7ffdabc4dbf8\nchar* bar = "bar"; // memory address: 0x7ffdabc4dbf0\n

如何将 foo 指向与 bar 相同的地址？我知道如何更改该值，例如：

foo = bar; // foo is now "bar" but the memory address is the same as before\n

我做了一些实验：

#include<stdio.h>\n#include<stdlib.h>\n#include<string.h>\n#include<errno.h>\n\nvoid print_info(char* string1, char* string2) {\n    printf("Memory address of string1: %p\\n", &string1);\n    printf("Memory address of string2: %p\\n", &string2);\n    printf("Value of string1: %s\\n", string1);\n    printf("Value of string2: %s\\n", string2);\n    printf("\\n");\n}\n\nvoid change(char** ptr1, char** ptr2) {\n    *ptr1 = …

根据我的理解，堆栈分配的变量在超出范围时将被丢弃。然而，返回对堆栈上分配的变量的引用并随后访问声明变量的范围之外的这些引用的概念让我感到困惑。他们不会指向现在已被释放的内存吗？我能想到的唯一可能性是内存被复制到引用指向的位置。

这是我尝试打印 4 的示例，即使它引用的对象在技术上超出了范围。

#include <iostream>

class A {
    
    public:
        int x;
        A(int a) : x(a) {}
};


A& ref_func() {
    A obj {4};
    
    A& ret_val = obj;
    
    return ret_val;
    
}

int main()
{
    A& ret = ref_func();
    
    // shouldn't the object that ref_func is returning a reference to be deallocated?
    // why is it able to be accessed like normal below?

    std::cout << ret.x << std::endl;

    return 0;
}

这是 C 语言中的相同示例，打印 5。

#include <stdio.h>

int* ref_func() {
    
    int …

我对工作方式有疑问cudaFree。在下面的代码中，为了在设备上分配数组，cudaMalloc需要数组的地址。这是通过使用&array_d.

int *array_d;
cudaMalloc((void**)&array_d, sizeof(int) * 100);
cudaFree(array_d);

从逻辑上讲，当我们想要释放内存时，我们cudaFree还必须传递数组地址。否则，它如何知道哪部分内存必须被释放？