标签: heap-memory

较新 Rust 版本的更新：以下代码包含已弃用（并已删除）的构造。box x用。。。来代替Box::new(x)。

我正在研究 Rust 的最基本概念，并对上一个问题有一个后续问题：为什么二元 + 运算符不能与两个 &mut int 一起使用？

我想在堆上创建一个int，并将其传递给另一个函数进行修改。

我想出了这个：

fn increment(number: &mut Box<int>) {

    **number = **number + **number;

    println!("{}", number);
}

fn main() {
    let mut test = box 5;
    increment(&mut test);

    println!("{}", test);
}

这打印

10
10

这就是我想要的。

然而，**看起来很奇怪，我想我也可以写这样的东西：

fn increment(number: &mut int) {

    *number = *number + *number;

    println!("{}", number);
}

fn main() {
    let mut test = box 5;
    increment(&mut* test); …

我正在实施Comsort。我想在堆栈上创建固定大小的数组，但它显示stack overflow. 当我将其更改为位于堆上时（Rust by Example 表示要在我们必须使用的堆中分配Box），它仍然显示stack overflow。

fn new_gap(gap: usize) -> usize {
    let ngap = ((gap as f64) / 1.3) as usize;
    if ngap == 9 || ngap == 10 {
        return 11;
    }
    if ngap < 1 {
        return 1;
    }
    return ngap;
}

fn comb_sort(a: &mut Box<[f64]>) {
    // previously: [f64]
    let xlen = a.len();
    let mut gap = xlen;
    let mut swapped: bool;
    let mut temp: f64; …

我想我理解堆栈对齐是4字节，例如，如果我只添加一个字符，他的地址将位于4字节的右侧（如果还有其他1或2字节变量，则稍早一点）

我仍然无法理解堆中的对齐方式，我认为有 4 字节或 8 字节对齐，但事情是这样的，当我分配 100 然后 20 字节时，第一个字节的末尾和开头之间有 4 个字节第二个，所以我猜测堆将使用 8 字节对齐。

通过连续分配 1 4 7 8 9 14 16 17 字节，我注意到 1、4、7、8、9 各占用 16 字节，14 16 17 各占用 24 字节，为什么呢？

我正在使用 C/C++ 并使用 malloc 进行分配（与 new 相同）。

谢谢。

我从我编写的代码中收到运行时错误。当我调用该grow()函数时，它运行得很好，直到它点击delete，然后它崩溃并显示：

这真的让我很困惑，我不明白这是怎么回事。

这是我的代码发生的地方：

.cpp 文件

#include "MyVector.h"
#include <cstdlib>;
void MyVector::grow()
{

    if (cap == 0)
        cap = MINCAP;
    else
        cap = cap*MINCAP;
    int* temp = new int[cap];

    for (int i = 0; i < vectorSize; i++)
    {
        temp [i] = theVector[i];
    }
    for (int i = vectorSize; i < cap; i++)
    {
        temp[i] = 0;
    }
    delete[] theVector;
    theVector = temp;

}

MyVector::MyVector()
{
    clear();
}

MyVector::~MyVector()
{
    delete[] this->theVector;

}

MyVector::MyVector(int _cap)
{
    cap …

在下面给出的示例程序中（来源：http ://www.cplusplus.com/reference/unordered_map/unordered_map/rehash/ ）

// unordered_map::rehash
#include <iostream>
#include <string>
#include <unordered_map>

int main ()
{
  std::unordered_map<std::string,std::string> mymap;

  mymap.rehash(20);

  mymap["house"] = "maison";
  mymap["apple"] = "pomme";
  mymap["tree"] = "arbre";
  mymap["book"] = "livre";
  mymap["door"] = "porte";
  mymap["grapefruit"] = "pamplemousse";

  std::cout << "current bucket_count: " << mymap.bucket_count() << std::endl;

  return 0;
}

输出变为：

current bucket_count: 23

为什么桶数变成23？对堆大小有什么影响？堆分配什么时候完成？在存储桶重新散列上还是在实际插入上？动态释放何时完成？何时clear()使用或erase()两者都使用？

在 C++ 中，什么决定了要引用的堆分配对象？Mark Allen Weiss 在他的《Data Structures and Algorithm Analysis in C++》一书中写道“当一个对象被new 分配时不再被引用，删除操作必须应用于该对象（通过一个指针）”我觉得这句话有点令人困惑的是，我所理解的是指针持有对内存地址的引用，但是表示该地址的对象如何被其他东西引用？当其他东西不再引用它时，我必须调用删除？

在Kubernetes具有众多微服务的集群中，其中一个专门用于Java Virtual Machine运行Java 1.8数据处理应用程序的（JVM）。

直到最近，在该 JVM pod 中运行的作业消耗的 RAM 还不到 1 GB，因此 pod 的最大内存设置为 4 GB，没有为 JVM 设置任何明确的堆大小。

一些新数据现在整个 pod 需要大约 2.5 GB 的空间，包括 JVM（如kubernetes top命令所报告的，在启动后内存限制增加到 8 GB），但是 pod 在以 4 GB 的限制启动后很快崩溃。

使用-Xms256m -Xmx3072m限制为 4 GB的磁头大小范围并不能解决问题。事实上，现在 pod 甚至还没有启动。

有没有办法参数化 JVM 以适应所需的 2.5 GB，而不增加 pod 的 4 GB 最大内存？

考虑以下代码段，您可以在其中从MyType实例参数获取浮点数（或相应类型）：

void myMethod(MyType floatArgument) {
    float myFloat = (float)MyType.Value;
    if (myFloat < 100) {
        //not meaningfull code
    }
}

如果在侦听器中不断调用该方法，或者在物理或图形引擎的更新中不断调用该方法，那么将其设为这样的类变量是否在效率方面会更好？：

private float myFloat
void myMethod(MyType floatArgument) {
    myFloat = (float)MyType.Value;
    if (myFloat < 100) {
            //not meaningfull code
    }
}

该变量仅在本地范围内使用，因此每次都会在堆栈中创建 AFAIK。所以从它创建一个类变量会更快，这样即使该变量的内存也会在堆上并且内存消耗会更高，代码会运行得更快。

我知道对于一个浮点数来说可能没什么大不了的，但是把它当作是很多变量或一个大数据类的实例。

这个推理正确吗？

我有一个通用的 C++ 问题。

假设我有这个代码：

int& GetInt()
{
    int* num = new int();
    return *num;
}

int numCopy = GetInt();

在这种情况下，返回的引用会发生什么？这个例子使用了一个简单的数据结构，所以它并不重要，但是在返回的数据更复杂的情况下，将变量分配给堆分配的变量引用，像这样将数据numCopy完全复制，或者将numCopy成为另一个参考原文num？

以这种方式创建的数组int a[5]包含 5 个整数内存块，并且在运行时无法更改内存。以这种方式创建的数组 int *ptr=new int[5]也包含 5 个整数块，在这种情况下，内存也不能在运行时增加和减少，因此，从哪个角度来看，它被称为动态内存。