除了函数calloc可以用零初始化已分配的内存之外，您不能动态分配已初始化的数组。
因此，首先需要为二维数组分配内存，然后根据需要设置其元素。
要将矩阵动态分配为二维数组，可以编写以下代码，例如

enum { M = 8, N = 24 };
char ( *matriz2D )[N] = calloc( 1, sizeof( char[M][N] ) );

memset( matriz2D[0], '#', sizeof( matriz2D[0] ) );
memset( matriz2D[M-1], '#', sizeof( matriz2D[M-1] ) );

for ( size_t i = 1; i < M-1; i++ )
{
    matriz2D[i][0] = '#';
    matriz2D[i][N-1] = '#';
}

字符串
请注意，与其使用幻数8和24，不如使用命名常量。还要记住，矩阵的元素不包含字符串。

有很多方法可以写这个。要走的路取决于你将使用该地区的方式。

第一个问题是矩阵维数是否总是相同

如果char[8][23]是你需要的所有东西，我将向你展示一个更简单的编写方法的例子。
无论如何，你需要知道char **是另一回事，必须仔细构造，就像char ** **一样。这些都是非常有用的结构，但在这里您可能不需要它们。
如果你的用例是更动态的写回，我可以使用char **或其他东西发布替代方案。

示例输出

Set 1 [ a b c d e f ]
Set 2 [ g h i j k l ]

allocating new area for matrix

copy set 1 to new area
In new area: [ a b c d e f ]

copy set 2 to new area
In new area: [ g h i j k l ]

free()'ing memory

字符串

C示例代码

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

typedef char(Target)[2][3];
int print_set(Target*, const char*);

int main(void)
{
    Target set_1 = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};
    Target set_2 = {{'g', 'h', 'i'}, {'j', 'k', 'l'}};

    print_set(&set_1, "Set 1");
    print_set(&set_2, "Set 2");

    printf("\nallocating new area for matrix\n");
    Target* pTarget = (Target*)malloc(sizeof(Target));

    printf("\ncopy set 1 to new area\n");
    memcpy(pTarget, set_1, sizeof(Target));
    print_set(pTarget, "In new area:");

    printf("\ncopy set 2 to new area\n");
    memcpy(pTarget, set_2, sizeof(Target));

    memcpy(pTarget, set_2, sizeof(Target));
    print_set(pTarget, "In new area:");
    printf("\nfree()'ing memory\n");
    free(pTarget);
    return 0;
};

int print_set(Target* tgt, const char* title)
{
    if (tgt == NULL) return -1;
    printf("%s [ ", title);
    for (size_t a = 0; a < 2; a += 1)
    {
        for (size_t b = 0; b < 3; b += 1)
            printf("%c ", (*tgt)[a][b]);
    }
    printf("]\n");
    return 0;
}

型
typedef只是为了可读性。print_set()是如何将区域作为一个整体传递的示例。

别让我为难使用结构。

struct your_matrix_s {
   char matriz2D[8][24];
};
struct your_matrix_s *matrix = malloc(sizeof(*matrix));

字符串
不强制转换malloc的结果。
如果你准备好接受挑战，那么你可能需要一个指向数组的指针：

char (*another_matrix)[24] = malloc(8 * sizeof(*another_matrix));

型

您已经分配了矩阵。不是动态的（dynamic）。
考虑到这个矩阵在堆栈上的大小并不禁止，你需要动态分配的唯一原因是如果你在一个函数中 * 创建 * 它，并且需要它在该函数的生命周期中生存。
你的问题暗示了你的问题在于把这个传递给一个函数。当你的矩阵被传递给一个函数时，它会衰减为一个指针，但是什么样的指针呢？它会衰减为一个指向24个字符的数组的指针。
如果你尝试写下面的代码，你会从编译器得到警告，然后在我的测试中，一个分段错误。

void foo(char **m) {
    m[0][0] = 'A';
}

个字符
但是，如果你写了下面的代码，那么你的函数参数类型就正确了，并且它可以按预期的方式工作。

void foo(char (*m)[24]) {
    m[0][0] = 'A';
}

型
如果你需要能够传递不同维度的矩阵，我们也可以传递一个size_t参数。

void foo(size_t n, char (*m)[n]) {
    m[0][0] = 'A';
}

型
对于您的矩阵，这将被称为：

foo(24, matriz2D);

型