标签: dynamic-memory-allocation

将shared_ptr复制到数组:是否应该使用它？

根据这篇文章,使用smart_ptr包装数组的好方法是定义一个删除函数,并将删除函数单独传递给带有原始数组的smart_ptr.

我将重构我的代码,比如使用smart_ptr包装原始数组.这是一个例子:

原始代码:

    class MyList{
    public:
       MyList(int size = 0);
       void Resize(int size);
       ~MyList();
    private:
       int* myArray; 
       int* head_;
       size_t size_;
    }

    MyList::MyList(int size){
        myArray = new int[size]; //allocated memory when object is being created 
        head_ = list_;
        size_ = size;
    }

    void MyList::Resize(int size) {
        if (!list_) {
             delete myArray;
             size_ = 0;
        }
        myArray = new int[size];
        head_ = list_;
        size_ = size;
    }

    MyList::~MyList(){
       delete myArray;
       head …

我写了一个方法来释放我的结构.现在我有一个问题.当我两次调用此方法时,它会给我一个错误.但我确实检查我的结构中是否有某些东西,所以我不知道它是如何可能给我错误的.

我的结构:

typedef struct {
    int num_rows;
    int num_cols;
    int** data;
} matrix;

我的免费方法:

void free_matrix(matrix* m){
    int i;
    for(i=0;i<m->num_rows;i++){
        if(m->data[i]!=NULL){
            free(m->data[i]);
        }
    }
    if(m->data!=NULL){
        free(m->data);
    }
}

额外方法:

void fill_matrix_a(matrix* m){
    m->data[0][0] = 1;
    m->data[0][1] = 0;
    m->data[0][2] = 2;
    m->data[1][0] = 0;
    m->data[1][1] = 3;
    m->data[1][2] = 1;
}

void fill_matrix_b(matrix* m){
    m->data[0][0] = 0;
    m->data[0][1] = 3;
    m->data[1][0] = 2;
    m->data[1][1] = 1;
    m->data[2][0] = 0;
    m->data[2][1] = 4;
}

void init_matrix(matrix* m, int num_rows, int num_cols){ …

可能这个问题已经被问过，但我找不到。如果您看到什么，请重定向我。 问题： 使用有什么好处：

myClass* pointer;

超过

myClass* pointer = new(myClass);

通过阅读其他主题，我了解到第一个选项在堆栈上分配一个空间并使指针指向它，而第二个选项在堆上分配一个空间并使指针指向它。但我还读到，第二个选项很乏味，因为您必须通过删除来释放空间。那么为什么人们会使用第二种选择呢？我是个菜鸟所以请详细解释。

编辑

#include <iostream>

using namespace std;

class Dog
{
        public:
                void bark()
                {
                        cout << "wouf!!!" << endl;
                }

};


int main()
{

        Dog* myDog = new(Dog);
        myDog->bark();
        delete myDog;
        return 0;

}

和

#include <iostream>

using namespace std;

class Dog
{
        public:
                void bark()
                {
                        cout << "wouf!!!" << endl;
                }

};


int main()
{

        Dog* myDog;
        myDog->bark();
        return 0;

}

两者都编译并给我“wouf！！！”。那么为什么我应该使用“new”关键字呢？

如何释放动态分配的内存？

假设输入(假设它是由用户给出)是1000,现在如果我分配1000的内存,在此之后(第二次)如果用户输入为500,我可以重用已经分配的内存吗？

如果用户现在输入值为3000,我该如何使用它？我可以重用已分配的1000块内存,然后创建另外2000块内存吗？或者我应该创建所有3000块内存？

哪一个是可取的？

#include <stdio.h>
#include <stdlib.h>
typedef struct a
{
  int a;
  int b;
}aa;

aa* ptr=NULL;
int main() {
//code
int input=2;
ptr=malloc(sizeof(aa)*input);

for(int i=0;i<input;i++)
{
    ptr[i].a=10;
    ptr[i].b=20;
}

for(int i=0;i<input;i++)
{
    printf("%d  %d\n",ptr[i].a,ptr[i].b);
}

return 0;
}

我有一个对象类数组,我想将最后一个indexi分配给NULL我有以下代码,但它给出了一个错误

DNA 是一个班级

allRightSequences 是一个向量

DNA* newDNA = new DNA[allRightSequences.size()];

newDNA [allRightSequences.size()] = NULL; << this line gives an error

我试图释放为该malloc函数分配的空间，但每次收到此消息时：

“malloc：*** 对象 0x7ffeefbff510 错误：未分配正在释放的指针”

即使我明确地将其分配为malloc().

我已经尝试过发送& manufacture并且只是manufacture。我对整个内存分配非常陌生。

char* manufacture = (char*)malloc(15*sizeof(char));   
manufacture = "Suzuki"; 

free(manufacture);

我正在学习 C++ 中的动态内存分配。在运行下面的代码时，每次都会打印不同的输出。

char *const dynamic_array = new char[50];
dynamic_array[0] = '\0';
dynamic_array[0] = 'a';
cout << dynamic_array << endl;
delete[] dynamic_array;

5 次运行的示例输出：

• 一种？
• 一种？
• 一种？
• 一种？
• 一种？

为什么某些运行的输出不同？

代码 1：

int *g(){
    int *p;
    p=(int *)malloc(sizeof(int));
    *p=10;
    return p;
}

代码 2：

int *g(){
    int p=10;
    return &p;
}

输出：

代码 2 ----> [警告] 函数返回局部变量的地址 [-Wreturn-local-addr] 仍然给出正确的输出（10）

代码 1 ----> 工作正常。没有警告，没有错误。

我有很多问题。

1. 代码 1 也返回了一个局部变量的地址，那么为什么没有警告呢？

2. 代码 2 给出了警告，我明白，我正在返回一个局部变量的地址。当函数 g 执行完成时，栈记录被弹出，因此存在悬空指针的情况。尽管如此，当我运行它时，为什么它会给出正确的输出（10）？

3. 代码 1 没有警告，没有错误。但这是一个好习惯吗？

PS 两种场景的主要功能相同。

int main()
{
    int *v=g();
    printf("%d",*v);
    return 1;
}

我已经声明了一个结构变量，它是另一个结构的动态数组，但程序每次都崩溃。我哪里做错了？需要采取哪些必要步骤？我正在使用 DEVC++。

#include<iostream>
#include<cstdlib>

using namespace std;

struct Project{
    int pid;
    string name;
};

struct employee{
    int eid;
    string name;
    Project *project_list;
};

int main(){
   struct employee e;
   e.eid = 123;
   e.name = "789";
   e.project_list = (Project *)malloc(2 * sizeof(Project));

   e.project_list[0].pid = 100;
   e.project_list[0].name = "Game";
}

我看到这个人，他写了这段代码：

func foo1() *string {
    var pointa *string
    pointa = new(string)
    *pointa = "stuff"
    return pointa
}

非常好，非常好，但是，不禁注意到，人们还可以写：

func foo2() *string {
    var pointa *string
    var str = "stuff"
    pointa = &str
    return pointa
}

第一个代码说：

• 动态分配具有空底层存储的字符串容器
• 使用该文字的内容覆盖底层存储
• 我假设，由于 COW，底层存储仅指向 ELF 数据段中的文字数据

第二个代码说：

• 本地分配字符串的实例
• 但因为稍后它会通过引用逃逸作用域&，所以它将被动态分配
• 尽管如此，由于 COW，不会发生任何复制

我的这些假设正确吗？这两个动态字符串分配等效吗？第二个代码中到底发生了什么new(string); *pointer = "payload"，但在幕后，隐式发生了什么？

这些代码片段会产生与分配和初始化字符串相同的代码吗？