标签: dynamic-memory-allocation

我正在实施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; …

这个问题已经在这里得到回答，但对我来说，有些事情仍然悬而未决，而且讨论太旧了，任何人都无法回复评论，此外我想问我的实现中出了什么问题。

无论如何，问题设置。我想为 3D 维度数组分配空间3, h, w。我在做什么：

int ***a = (int***)malloc(3 * sizeof(int*));
for (int i = 0; i < 3; i++)
{
   a[i] = (int **) malloc(height * sizeof(int*)); 
}

我理解这是为三个 3 创建第一个空间int**，然后分配高度int**；然后 ：

for (int i = 0; i < 3; i++)
{
  a[i][0] = (int *) malloc(height * width * sizeof(int *));
  for (int j = 1; j < height; j++)
   {
     a[i][j] = a[i][j-1] + width;
   }
}

所以现在我认为每个a[i][0] …

我对向量（STL - C++）中的内存分配有疑问。据我所知，每当向量的大小等于其容量时，其容量就会动态加倍。如果是这样的话，为什么分配是连续的呢？它如何仍然允许像数组一样使用 [] 访问运算符进行 O(1) 访问？谁能解释这种行为？（列表也有动态内存分配，但我们无法使用 [] 访问运算符访问其元素，向量怎么可能呢？）

#include<iostream>
#include<vector>
using namespace std;

int main() {
    // your code goes here
    vector<int> v;

    for(int i=0;i<10;i++){
        v.push_back(i);
        cout<<v.size()<<" "<<v.capacity()<<" "<<"\n";
    }

    return 0;
}

输出：

1 1
2 2
3 4
4
4 5
8 6
8 7
8 8 8
9 16
10 16

我试图理解C++ 中的放置新表达式。

这个 Stack Overflow 答案指出，这T* p = new T(arg);相当于

void* place = operator new(sizeof(T));  // storage allocation\nT* p = new(place) T(arg);               // object construction\n

这delete p;相当于

p->~T();             // object destruction\noperator delete(p);  // storage deallocation\n

为什么我们需要在对象构造中放置 new 表达式T* p = new(place) T(arg);，\xe2\x80\x99t 与以下等价吗？

T* p = (T*) place;\n*p = T(arg);\n

正如标题，我想知道如何用指针初始化双指针sizeof。

例如

int **p=malloc(sizeof *p * rows);

for(size_t i = 0; i < rows; i++){
    p[i]=malloc(sizeof ? * cols);
}

我应该填写什么?。

任何帮助，将不胜感激。

C 中存在一些代码，用于calloc()创建有效的向量。它看起来像这样：

uint64_t *reverseOrder = (uint64_t *)calloc((size + 1), sizeof(uint64_t));

我想用 C++ 语法和向量来模仿这种行为，以便它实际上具有相同的效果。我可以使用以下语法吗？

std::vector<uint64_t> reverseOrder(size + 1, 0);

我知道calloc()实际上会遍历内存并将它们设置为 0，所以我想知道是否是这种情况。

我正在尝试将我的字符串转换为动态的双精度数组.我的字符串的每个空格代表一列,每个";" 代表一个新行.当此代码运行时,它仅适用于*F [0] [col]时.当它到达*F [1] [col]时,它给出了错误"CCode.exe中0x00e4483c处的未处理异常:0xC0000005:访问冲突读取位置0xcccccccc." 谁知道为什么？

void main(void) {  
    double **F = NULL;  
    F = malloc(row * sizeof (double *));  
    for (m=0; m < row;m++) {  
        F[m] = malloc(col * sizeof(double ));
    }  
    FParser(string, &F);
for (m=0;m<rowF;m++)
    free(F[m]);
free(F);
}

void FParser(char string[256], double ***F) {  
  while (dummyChar_ptr != NULL) {
    dummyChar_ptr = strtok(dummyChar_ptr," ");
    while ((dummyChar_ptr) != NULL) {
      *F[row][col] = atof(dummyChar_ptr);
      dummyChar_ptr = strtok(NULL," ");
      col++;
    }
    col=0;
    row++;
    strcpy(dummyChar,string);
    dummyChar_ptr = strtok(dummyChar,";");
    for (x=0;x<row;x++) 
      dummyChar_ptr = …

我正在编写一个函数,它增加了使用malloc创建的动态内存对象的大小.该函数应该作为参数获取指向要增加的内存块的指针,块的当前大小以及块将增加的量.

像这样的东西:

int getMoreSpace(void **pnt, int size, int add) {
    xxxxxx *tmp; /* a pointer to the same as pnt */
    if (tmp = realloc(pnt, (size+add)*sizeof(xxxxxx))) { /* get size of what pnt points to */
        *pnt=tmp;
        return 1;
    else return 0;
}

问题是,无论pnt指向什么,我都希望函数能够工作.我如何实现这一目标？

我有一个列表定义为std::list<BunnyInfo> bList;私有,在类中BunnyInfo是一个结构

struct BunnyList::BunnyInfo {
    std::string name;
    char gender;
    std::string color;
    unsigned int age : 6; // 0 - 63
    bool mutant;
};

列表通过成员函数增长的位置

void BunnyList::add(int count){
    bListIter iter;
    while(count--){
        BunnyInfo *bNew = &fill(*new BunnyInfo());
        for(iter = bList.begin(); iter != bList.end(); iter++){
            if(iter->age <= bNew->age)
                break;
        }
        bList.insert(iter, *bNew);
    }
}

where fill()只是一个为结构生成值的函数.我还有一个删除列表一半的成员函数

void BunnyList::reap(){
    int toKill = bList.size() / 2;
    int find;
    bListIter iter;
    while(toKill--){
        find = rng(0, bList.size()-1);
        iter = bList.begin();
        for(int i …

我有一个用C++编写的递归函数,它使用动态分配2D数组new.我怎样才能测量在整个生命周期内空间函数在堆和堆栈上分配的总量？

以下是如何测量Stack的示例(不是我的代码).

unsigned int maxStackLocation ; 
unsigned int minStackLocation ; 
main () 
{ 
    //get the address of a local variable before calling Quicksort 
    //the stack grows down, so this is the max stack location 
    int localVariable;
    void *currPtrLocation = (void*)(&localVariable); 
    maxStackLocation = *(unsigned int *)(&currPtrLocation); 
    //we get the value for the minimum stack location in quicksort itself 
    //call quicksort 
    Quick (A, num); 
    space = maxStackLocation - minStackLocation;
} 
//some redundant function whose stack usage will be measured
void …