标签: dynamic-memory-allocation

编程语言书籍解释了在堆栈上创建了值类型,并且在堆上创建了引用类型,而没有解释这两者是什么.我还没有看清楚这个问题.我理解堆栈是什么.但,

• 它们在哪里和它们(物理上在真实计算机的记忆中)？
• 它们在多大程度上受操作系统或语言运行时控制？
• 它们的范围是什么？
• 是什么决定了它们的大小？
• 是什么让一个更快？

我想知道静态内存分配和动态内存分配有什么区别？

你能用任何一个例子解释一下吗？

我偶然发现了一个涉及不同大小数组声明的测验。我想到的第一件事是我需要对new命令使用动态分配，如下所示：

while(T--) {
   int N;
   cin >> N;
   int *array = new int[N];
   // Do something with 'array'
   delete[] array;
}

但是，我看到其中一种解决方案允许以下情况：

while(T--) {
    int N;
    cin >> N;
    int array[N];
    // Do something with 'array'
}

经过一番研究，我读到 g++ 允许这样做，但它让我一直在思考，在哪些情况下有必要使用动态分配？还是编译器将其翻译为动态分配？

包括删除功能。但是请注意，这里的问题与内存泄漏无关。

鉴于可用性make_unique和make_shared自动删除unique_ptr以及shared_ptr析构函数,在C++ 14中使用new和使用的情况(除了支持遗留代码之外)是delete什么？

这是我在实际代码中遇到的问题的最小工作示例。

#include <iostream>

namespace Test1 {
    static const std::string MSG1="Something really big message";
}

struct Person{
    std::string name;
};

int main() {
    auto p = (Person*)malloc(sizeof(Person));
    p = new(p)Person();
    p->name=Test1::MSG1;

    std::cout << "name: "<< p->name << std::endl;

    free(p);

    std::cout << "done" << std::endl;

    return 0;
}

当我编译它并通过Valgrind运行它时，它给了我这个错误：

肯定丢失：1 个块中 31 个字节

约束条件

1. 我一定会malloc在上面的示例中使用，因为在我的实际代码中，我在 C++ 项目中使用了 C 库，该项目malloc在内部使用了它。所以我无法摆脱malloc使用，因为我没有在代码中的任何地方明确地这样做。
2. 我需要在我的代码中一次又一次地重新std::string name分配。Person

好吧,我无法理解何时以及为什么需要使用分配内存malloc.

这是我的代码:

#include <stdlib.h>

int main(int argc, const char *argv[]) {

  typedef struct {
    char *name;
    char *sex;
    int age;
  } student;


  //Now I can do two things
  student p;

  //or
  student *ptr = (student *)malloc(sizeof(student));

  return 0;
}

为什么我可以使用时需要分配内存student p;？

我有一个Animal带有虚拟析构函数的类和一个派生类Cat。

#include <iostream>

struct Animal
{
    Animal() { std::cout << "Animal constructor" << std::endl; }
    virtual ~Animal() { std::cout << "Animal destructor" << std::endl; }
};

struct Cat : public Animal
{
    Cat() { std::cout << "Cat constructor" << std::endl; }
    ~Cat() override { std::cout << "Cat destructor" << std::endl; }
};

int main()
{
    const Animal *j = new Cat[1];
    delete[] j;
}

这给出了输出：

动物构造函数
猫构造函数
动物析构函数

我不明白Cat当我的基类析构函数是虚拟的时，为什么不调用 的析构函数？

该文件说std::list效率低下:

std :: list是一个非常低效的类,很少有用.它为插入其中的每个元素执行堆分配,因此具有极高的常数因子,特别是对于小数据类型.

评论:这让我感到惊讶.std::list是一个双向链表,所以尽管它的元件结构效率低下,它支持插入/删除在O(1)的时间复杂度,但这种功能在此引用的段落完全忽略.

我的问题:说我需要一个连续的小尺寸均匀元素的容器,这种容器应支持元素插入/为O删除(1)复杂性和不并不需要随机存取(虽然支持随机访问是好的,它不是必须的这里).我也不希望堆分配为每个元素的构造引入高常量因子,至少当元素的数量很小时.最后,只有在删除相应的元素时,迭代器才会失效.显然我需要一个自定义容器类,它可能(或可能不)是双向链表的变体.我该如何设计这个容器？

如果无法实现上述规范,那么也许我应该有一个自定义内存分配器,比如说,指针分配器？我知道std::list将分配器作为其第二个模板参数.

编辑:我知道从工程的角度来看,我不应该太关心这个问题 - 足够快就足够了.这只是一个假设的问题,所以我没有更详细的用例.随意放松一些要求!

编辑2:据我所知,O(1)复杂度的两种算法由于其常数因子的不同而具有完全不同的性能.

例如:

int main() {
    Foo *leedle = new Foo();

    return 0;
}

class Foo {
private:
    somePointer* bar;

public:
    Foo();
    ~Foo();
};

Foo::~Foo() {
    delete bar;
}

析构函数会被编译器隐式调用还是会出现内存泄漏？

我是动态内存的新手,所以如果这不是一个可用的测试用例,我很抱歉.

我在测试程序中观察到以下行为：

我正在malloc()为1 MB，然后free()之后sleep(10)。我做了五次。我正在观察top程序运行时的内存消耗。

一次free()-d，我期望程序的虚拟内存（VIRT）消耗将减少1 MB。但实际上并非如此。它保持稳定。这种现象的解释是什么？malloc()分配内存时是否做一些保留？