标签: dynamic-allocation

我创建了一个二维数组，其内容如下

     int i,j,lx,ly;// lx,ly are the row and column respectively
     double** a;

     a=(double**) malloc((lx+2)*sizeof(double));

     a[0]= (double*) malloc((lx+2)*(ly+2)* sizeof(double));

     assert(a[0]); 

     for(i=1;i<lx+2;i++)
     {
       a[i]=a[i-1]+i*(ly+2);
     }

// 我为这个数组中的所有元素分配了一个值 0，如下所示

    for(i=0;i<(lx+2)*(ly+2);i++)
    {
      a[i]=0;
    } 

// 我打印出下面的所有元素

      for(i=0;i<(lx+2)*(ly+2);i++)
      {
         printf("position %d values %d\n",i,a[i]);
      } 

// 当我看到输出时，它向我显示了一个特定位置 13 处的垃圾值。我无法弄清楚。还请告诉我如何访问行和列，如 Eg 以访问第 7 列第 0 行和第 5 行就 lx 而言，第 6 列列，如我的代码所示

我有以下静态内存声明:

void* array[5000];

如何operator new在C++中使用相同的内存分配？

当我从C#转换到C++时,我得到了很多建议,尽可能使用值语义.几乎可以肯定的是,如果我在任何地方发布带有指针的问题,并建议它应该是一个值.我开始看到了光,我在代码中找到了很多地方,我可以用堆栈分配的变量(通常是引用)替换动态分配和指针.所以我认为我掌握了使用堆栈分配的对象,并且当调用者中的对象生命周期比被调用者更长时,将它们作为引用传递给其他函数.

但是,当被调用者获得所有权时,我有一个关于按值传递对象的问题.请看以下示例:

class Zoo
{
  void AddAnimal(Animal animal);
  std::list<Animal> animals_;
}

通常从灵活性和单元测试的角度来看,我希望Animal成为一个接口(C++中的抽象类),这样我就可以轻松地发送任意动物并通过模拟实现来模拟它.

在指针实现中,客户端代码将调用它:

Animal animal = new Lion("Bob");
myZoo.AddAnimal(animal);

这里的客户端代码并不真正需要动物对象.它只是暂时构建它以传递给方法.所以在这种情况下,没有共享语义.所以它似乎是价值语义的一个好例子.但是,我的理解是你不能使用Animal作为值传递的参数,因为它是一个抽象类.

我的大多数不采用原始类型的成员函数都采用抽象类参数.那么处理这个问题的C++方法是什么？(那你是如何使用值语义编写C++接口的呢？)

在主函数的最后一行,为什么&word2不同word2？假设正确的标题已到位.谢谢!

int main()
{
    char word1[20];
    char *word2;

    word2 = (char*)malloc(sizeof(char)*20);

    printf("Sizeof word 1: %d\n", sizeof (word1));
    printf("Sizeof word 2: %d\n", sizeof (word2));

    strcpy(word1, "string number 1");
    strcpy(word2, "string number 2");

    printf("%s\n", word1);
    printf("%s\n", word2);
    printf("Address %d, evaluated expression: %d\n", &word1, word1);
    printf("Address %d, evaluated expression: %d\n", &word2, word2); 
    //Why this one differ?
}

我正在学习c ++,而我正在阅读关于指针的内容.我对以下场景感到好奇:

场景1:

如果我没有弄错,如果用户输入-1,就会出现内存泄漏:

#include <iostream>
using namespace std;

int main(){

    int *p = new int;

    cout << "Please enter a number: ";
    cin >> *p;

    if (*p == -1){
        cout << "Exiting...";
        return 0;
    }

    cout << "You entered: " << *p << endl;

    delete p;

    return 0;
}

场景2:

但是在下面的代码中会发生什么？根据我的阅读并纠正我,如果我错了,当在第二个场景中声明指针时,一旦你超出范围,指针就会被清除.因此,如果用户没有进入-1,*p将自动清除？

#include <iostream>
using namespace std;

int main(){

    int x;
    int *p = &x;

    cout << "Please enter a number: ";
    cin >> …

我正在尝试ary[i][j]使用以下代码分配要访问的2D字符数组:

#define stringmaxlen 20

void do_alloc( char ***vals, int valscount ){
    *vals = (char**) calloc( sizeof( char** ), valscount );
    int i = 0;
    for ( ; i<valscount; i++ )
        *vals[i] = (char*) calloc( sizeof( char* ), stringmaxlen );
}

int main( ){
    //......
    char** ary;
    do_alloc( &ary, 10 );
    strcpy( ary[0], "test" );
    //......
}

不幸的是,这导致某处出现溢出并且程序执行中存在错误,我从这里获得了一些动态分配的引用:http://staff.science.nus.edu.sg/~phywjs/CZ1102/lecture20/sld014.嗯.

我想知道这里有什么问题以及如何解决这个问题,谢谢.

码:

struct LinkedList {
    int someData;
    LinkedList* next;

    LinkedList() : next(0) {}
    ~LinkedList() {delete next;}
};

void someFunction() {
    LinkedList list;

    list.next = new LinkedList;
    list.next->next = new LinkedList;
    list.next->next->next = new LinkedList;
    // And so on...
}

我是否正确地说这段代码没有泄漏内存？当列表范围时,它应该调用它的析构函数,它调用next的析构函数,它调用next的析构函数,依此类推,直到调用delete 0为止.

假设我通过p1以下方式进行动态内存分配,

int* p1 = new int;
*p1 = 1;

我知道引用的内存p1可以通过使用释放

delete p1;
p1 = nullptr;

但我想知道是否有另一个指针p2指向1,我可以delete这个指针,以释放内存？指针会发生什么p1？此外,什么是之间的关系p1和p2本质？例如,

int* p1 = new int;
*p1 = 1;
int* p2 = p1;
// Can I delete p2 like this? And what would happen to p1?
delete p2;
p2 = nullptr;

我正在尝试制作一个霍夫曼代码来练习C编码,并且我仍然保持同样的错误.

让我解释一下代码.首先,它创建下面的结构:

struct sNo {
    int valor;
    char letra;
    struct sNo *esq;
    struct sNo *dir;
};
typedef struct sNo sNo;

然后它创建一个结构数组('否'):

sNo *No;
No = calloc(qtd_no, sizeof(sNo));

它从键盘中读取一个字符串,在该数组中放置字母和它出现的次数.就像下面的代表'abracadabra'一样:

No:    a/5 b/2 r/2 c/1 d/1  

现在,要创建一个Huffman树,我需要创建另一个数组('pNo'),并指向原始数组:

int qtd_pno = qtd_no;
sNo **pNo;
pNo = calloc(qtd_pno, sizeof(sNo*));
for (i = 0; i < qtd_pno; i++){
    pNo[i] = &No[i];    
}

这两个数组看起来像这样:

No:    a/5 b/2 r/2 c/1 d/1  
pNo:   a/5 b/2 r/2 c/1 d/1  

之后,它可以像下面那样对指针数组进行排序而不更改原始指针:

No:    a/5 b/2 r/2 c/1 d/1  
pNo:   c/1 d/1 …

我需要为一个代表三角矩阵的非常大的数组分配内存.我写了以下代码:

const int max_number_of_particles=20000;
float **dis_vec;

dis_vec = new float **[max_number_of_particles];

for (i = 0; i<max_number_of_particles; i++)
  dis_vec[i] = new float *[i];

for (i = 0; i<max_number_of_particles; i++)
  for (j = 0; j<i; j++)
    dis_vec[i][j] = new float[2];

问题是这样做所需的时间(分配内存)随着矩阵大小的增加而迅速增加.有谁知道这个问题更好的解决方案？

谢谢.