Question

我很难解决这个问题：

typedef struct {
.....
} info;   
info array[1000][10][10]; //now i have this 3d matrix

对于内存优化，我想动态分配第一维：我想拥有一个动态矩阵array [10] [10]。所以我已经声明了这样的指针：

info *array[10][10];

但是如何执行malloc来将N矩阵[10] [10]添加到数组中？

我尝试过：

info *array[10][10]=malloc(N*sizeof(array));

Answer 1

您可以使用以下解决方案：

package main

import (
    "database/sql"
    // "fmt"
    _ "github.com/go-sql-driver/mysql"
    "html/template"
    "net/http"
  "github.com/****/****/config"
  "github.com/****/****/db"
)

var tpl *template.Template

func init() {
    tpl = template.Must(template.ParseGlob("templates/*.gohtml"))
}

func main() {
    Connect()
    defer Close()
    loadRoutes()
    http.ListenAndServe(":8080", nil)
}

Answer 2

如WhozCraig在评论中和kiranBiradar在回答中所述，您尝试分配：

info *array[10][10]=malloc(N*sizeof(array));

尝试为数组或指针数组分配。您正在分配N 10x10指针数组。

您打算为N 10x10 info分配存储空间。为此，您需要将array声明为指向数组的指针 info [10][10]。这样声明，您就可以在单个分配中自由分配N 10x10数组info（这样做的好处是只需要单个free（而不是分配{{1} }，并要求分别分配指针，行指针和最后的每行元素），但是要声明指向数组的指针 info ***，必须将数组声明为：

info [10][10]

（注意：根据您在整个代码中如何使用info (*array)[10][10];以及将所有元素初始化为某个默认值是否有益，可以使用array代替calloc。{{ 1}}将分配所有字节并将其清零（将新内存清零所需的额外时间通常可以忽略不计）。

我该如何重新分配数组（以防我需要更多空间）？

由于您已将malloc声明为数组的指针 calloc并一次性分配了存储空间，因此您只需要array来创建一个更大的存储的内存块。有许多分配方案可以有效地处理重新分配，您可以根据需要自由处理。

通常，经验法则是声明一些合理预期数量的指针和info[10][10]的{{1}}数组的存储。您为当前分配的指针和数组的数量保留一个计数器（例如在realloc中）。您将保留第二个计数器，该计数器当前填充的数字（例如10x10 –索引的缩写）。当索引达到分配的指针和数组的数量时，您将info的存储空间增加了nptrs倍，并更新了ndx的计数器，一直到realloc再次，然后重复。

一个简短的示例可能会有所帮助。由于1.5 - 2的成员是未定义的，因此在此示例中，只需使用一个简单的指针进行排列 nptrs。任何集合的处理过程都是相同的，唯一的不同是ndx == nptrs将更改为每个10x10数组分配的字节数。（如果您有info的其他成员需要动态分配-这将是一个附加要求）

重新分配时，总是将返回int [10][10]分配给临时指针。如果sizeof *array失败，它将返回info，并且如果您将其分配给原始指针-您刚刚创建了内存泄漏，并且丢失了对原始内存块的引用。通过使用临时指针，如果realloc失败，则原始数据和指向它的指针将保持有效。

简单地用一个常数（例如realloc填充每个10x10数组，然后调用NULL两次以将10x10块的分配从realloc增加到1, 2, 3, ...的示例最后realloc将是：

使用/输出示例

输出只是指针和每个10x10的数字块：

在您编写的任何动态分配内存的代码中，对于任何分配的内存块，您都有2个职责：（1）始终保留指向起始地址的指针因此，（2）当不再需要它时可以释放。

当务之急是使用一个内存错误检查程序来确保您不会尝试访问内存或在已分配的块的边界之外/之外进行写入，不要试图以未初始化的值读取或基于条件跳转，最后，以确认您释放了已分配的所有内存。

对于Linux，32是正常选择。每个平台都有类似的内存检查器。它们都很容易使用，只需通过它运行程序即可。

内存使用/错误检查

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

#define NMTRX  8    /* if you need constants, then #define one (or more) */
#define MSIZE 10    /* don't use "magic numbers" in your code, unless    */
#define NTEST 24    /* mandatory (like scanf field-width modifiers)      */

/** set single MSIZExMSIZE array to n */
void set_m_to_n (int m[MSIZE][MSIZE], int n)
{
    for (int i = 0; i < MSIZE; i++)
        for (int j = 0; j < MSIZE; j++)
            m[i][j] = n;
}

/** print single MSIZExMSIZE array */
void print_m (int m[MSIZE][MSIZE])
{
    for (int i = 0; i < MSIZE; i++) {
        for (int j = 0; j < MSIZE; j++)
            printf (" %2d", m[i][j]);
        putchar ('\n');
    }
}

/** realloc to twice 'sz * *nelement' bytes returning
 *  pointer to reallocated block on success, NULL otherwise.
 */
void *realloc_2x (void *ptr, size_t sz, size_t *nelem)
{
    char *memptr = realloc (ptr, 2 * *nelem * sz);
    if (memptr == NULL) {
        perror ("realloc-m");
        return NULL;
    }   /* optionally zero all new memory */
    memset (memptr + *nelem * sz, 0, *nelem * sz);
    *nelem *= 2;  /* update nelem (nptrs) to reflect new allocation */

    return memptr;    /* return pointer to new block for assignment */
}

int main (void) {

    size_t ndx = 0,         /* index */
        nptrs = NMTRX;      /* initial pointers to allocate */
    int (*m)[MSIZE][MSIZE]; /* pointer to MSIZExMSIZE array */

    m = calloc (nptrs, sizeof *m);  /* allocate & initialize zero */
    if (m == NULL) {        /* validate allocation */
        perror ("calloc-m");
        exit (EXIT_FAILURE);
    }

    for (ndx = 0; ndx < NTEST; ndx++) { /* loop filling NTEST arrays */
        if (ndx == nptrs) { /* check if index reached allocation */
            void *tmp = realloc_2x (m, sizeof *m, &nptrs);  /* realloc_2x */
            if (tmp == NULL)/* validate reallocation */
                break;      /* don't exit on failure, original data good */
            m = tmp;        /* assign reallocated block to m */
        }
        set_m_to_n (m[ndx], ndx + 1);   /* set array values to ndx+1 */
    }

    for (size_t i = 0; i < ndx; i++) {  /* output all MSIZExMSIZE arrays */
        printf ("\nm[%2zu]:\n", i);
        print_m (m[i]);
    }

    free (m);   /* free allocated memory */

    return 0;
}

始终确认已释放已分配的所有内存，并且没有内存错误。

仔细检查一下，如果还有其他问题，请告诉我。

动态矩阵数组

2 个答案: