标签: dynamic-memory-allocation

所以我执行这段代码

#include <cstdlib>
#include <iostream>
int main()
{
    char *test = new char[10];
    strcpy(test, "Hello Ther");;
    std::cout << test << std::endl;
    delete[] test;
    std::cout << test << std::endl;
    return 0;
}

而输出是

你好Ther

你好Ther

似乎该delete[] test语句没有做任何事情......根本没有运行时或编译时错误

完全难过我

我有一个指向结构数组的指针,如下所示:

class Terrian  {
     ...
    private:
        Vector *terrian_vertices;
     ...
}

并且指针的数据在"construct_vertices"函数中生成

Terrian::Terrian(int width, int height)  {
    this->width = width;
    this->height = height;

    std::cout << "Width: " << width << "  Height: " << height << "\n";

    std::cout << "Vertices\n";
    construct_vertices();
    std::cout << "Element\n";
    construct_elements();
    std::cout << "Buffers\n";
    construct_buffers();
}

void Terrian::construct_vertices()  {
    terrian_vertices = new Vector[width * height];

    std::cout << "Generating data\n";

    for (int x = 0; x < width; x++)  {
        for (int y = 0; y < height; …

我想知道的是,如果我在c ++程序中使用calloc/malloc而不是operator new,它是否会使内存分配更快,或者因为使用c ++编译器编译程序而无关紧要.

编辑:

我想应该已经明白我没有使用new运算符来调用构造函数.只是像数组一样的内存分配.

我正在尝试使用overload()运算符将值分配给动态分配的2D数组,这是我的代码 -

class test {
    private:
        int** data ; int row, col ;

    public:
        test(int row = 2, int col = 2)  {
            this->row = row ; this->col = col ;
            this->data = new int*[this->row] ;
            for(int i = 0 ; i < this->row ; i++)
                this->data[i] = new int[this->col] ;
        }

        ~test() {
            for(int i = 0 ; i < this->row ; i++)
                delete [] this->data[i] ;
            delete [] this->data ;
        }

        const int operator() (int row, int col) …

我是初学者,这个问题总让我感到困惑.我的学术书说新操作员返回一个地址.但在许多教程中,我发现new返回指向特定地址的指针.拿着这个:

  char *name = new char[x];

这里为name命名了什么值,动态分配的地址或指向动态分配的char的指针？谢谢

我已经构建了一个如下所示的book结构:

typedef struct _book{
    char name[NAME_LENGTH];
    char authors[AUTHORS_NAME_LENGTH];
    char publisher[PUBLISHER_NAME_LENGTH];
    char genre[GENRE_LENGTH];
    int year;
    int num_pages;
    int copies;
}book;

我正在尝试定义一个图书馆,这是一个书籍阵列,所以稍后我可以在图书馆中存放另一个功能的图书.当像这样定义库时,内存写入/读取有问题library[BOOK_NUM],所以我决定分配.

问题是,它只允许我在main函数内部进行分配.当我写这行时:

book *library = (book*)malloc(BOOK_NUM*sizeof(book));

在main()它之外给我一个错误:

IntelliSense:常量表达式中不允许函数调用

错误C2099:初始化程序不是常量

但如果我将上面的线移到里面main()就行了.这是为什么？

另外,定义数组的更好方法是什么,以便以后可以用其他函数更改它？

我正在使用C++ 14.我们假设我有一个class X和一个std::vector<X> mVector.

我还有以下代码:

std::shared_ptr<X> AddX(const X &x)
{
    mVector.push_back[x];
    return std::shared_ptr<X>(&mVector[mVector.size()-1])
}

此方法将对象x插入mVector并返回一个指向此插入对象的共享指针.

X x1;
shared_ptr<X> pX1 = AddX(x1);

一切正常,但当我插入第二个对象

X x2;
shared_ptr<X> pX2 = AddX(x2);

pX1不指向插入的对象x1,因为最后一个push_back已经在内存中移动了它的位置(在硬调试之后看到).这对我来说很可惜,因为我的程序需要这些指针才能正常工作,并且mVector需要是动态的,它一直在修改(使用新X对象或删除旧对象).

我怎样才能解决这个问题？我想比一种方法可以使用对象索引而不是它们的指针,但这会惩罚我的执行时间,因为我应该每次修改时更新许多属性mVector.是否可以管理它并仍然使用指针？

该练习提供了一个简单的程序来创建数据库,该程序转向以下结构

struct Address {
  int id;
  int set;
  char name[MAX_DATA];
  char email[MAX_DATA];
};

我被要求修改代码,以便我可以作为参数传递给程序的最大长度 .name和.email.当然,现在,如果不是将其定义MAX_DATA为宏而是将其作为全局变量使用,我会得到错误:在文件范围内修改了'name'.

然后我尝试创建不同的if循环,旨在通过重新定义来传递MAX_DATA值struct Address,例如:

if(argc > 6) {
  int maxdata = atoi(argv[6]);
  struct Address {
    int id;
    int set;
    char name[maxdata];
    char email[maxdata];
  };
  DatabaseSet(conn, id, argv[4], argv[5]);
  DatabaseWrite(conn);
  break;
}

但DatabaseSet与DatabaseWrite(这在工作struct Connection,涉及到另一个struct Database,谁最终直接关系到struct Address)忽略的新长度name和email.

编辑:谢谢.

谢谢大家的意见和答案,你真的帮助我完成了练习和我的一般未知的C.

我编写了一个代码,它首先创建一个内存alloc并将一个字符串保存在另一个指针中.根据代码,该值必须在空闲后保存在其他地址中,但它会给出错误"munmap_chunk():无效指针".

我的代码是:

#include <stdio.h>
#include <stdlib.h>
#include "testfunc.h"
#include <string.h>

int main()
{
static char *server_alg;
char *test;
char *test = (char*) malloc(30*sizeof(char));
server_alg = "A";
strcpy(test, server_alg);
printf("server_alg addr = %u \n", &*server_alg);
printf("server_alg value = %u \n", server_alg);
printf("SERVER_ALGO addr = %d \n", *server_alg);
free(server_alg);
server_alg=NULL;
printf("           nulled          \n");
printf("server_alg addr = %u \n", &*server_alg);
printf("server_alg value = %u \n", server_alg);
printf("SERVER_ALGO addr = %u \n", test);
printf("SERVER_ALGO value = %u \n", *test);
return 0;
}

这是错的吗？

谢谢你的帮助

以下代码可以编译并完美运行：

typedef struct n {
    char value;
    struct n* next;
} node;
void insert_new_node(node** head, char new_value)
{
    node* new_node = malloc(sizeof(node*));
    new_node->value = new_value;
    new_node->next = NULL;

    if(*head == NULL)
    {
        *head = new_node;
    }
    else
    {
        node* current = *head;

        while(current->next != NULL)
        {
            current = current->next;
        }

        current->next = new_node;
    }
}

我的问题是-请注意，我实际上实际上只是为指向结构的指针分配了空间，而不是为结构本身分配了空间（ref：）node* new_node = malloc(sizeof(node*));。所以我的问题是，该结构数据实际存储在哪里，如果存储在堆中，它将如何工作？