在c中使用字符数组实现64块逻辑磁盘

我对C真的很陌生。。。。 我想要的逻辑磁盘（让我们调用logdisk）必须有64个块，每个块是64字节

比如说,， logdisk[i][j]，i是logdisk上逻辑块的数量或索引，j是以字节为单位的块长度

所以

logdisk[5][0]应该给我块5的第一个字节

但是我在创建这个日志磁盘时遇到了麻烦，因为我不知道如何使用malloc分配一个2d字符数组，我有下面的代码

char *logdisk = malloc(64 * 64);    

有人能告诉我如何创建一个包含64字节块的2d字符数组吗

谢谢你的评论，现在我得到一些线索

char (*logdisk)[64] = malloc(64*64);

上面一个是Jasen的，下面一个是我的想法，64*64逻辑磁盘应该使用哪一个

 char **logdisk = malloc(sizeof(char)*64); 
 for (int i = 0; i < 64; i++) {
     logdisk[i] = malloc(sizeof(char)*64); 
 }

char**logdisk=malloc（sizeof（char）*64）；
对于（int i=0；i<64；i++）{
logdisk[i]=malloc（sizeof（char）*64）；
}

您可以声明一个

字符**

来保存二维数组：

char **logdisk = malloc(64 * sizeof(char *)); // allocate block pointers
int i;

for (i = 0; i < 64; ++i) { // allocate each block
    logdisk[i] = malloc(64 * sizeof(char));
}

char**logdisk=malloc（64*sizeof（char*））；//分配块指针
int i；
对于（i=0；i<64；++i）{//分配每个块
logdisk[i]=malloc（64*sizeof（char））；
}

---

解除分配的方式相同，但相反。

您可以声明一个

char**

来保存二维数组：

char **logdisk = malloc(64 * sizeof(char *)); // allocate block pointers
int i;

for (i = 0; i < 64; ++i) { // allocate each block
    logdisk[i] = malloc(64 * sizeof(char));
}

char**logdisk=malloc（64*sizeof（char*））；//分配块指针
int i；
对于（i=0；i<64；++i）{//分配每个块
logdisk[i]=malloc（64*sizeof（char））；
}

解除分配的方式相同，但相反。

您正在寻找的 或者

其中，磁盘y的字节x由

logdisk[y*64+x];

或

你在找什么 或者

其中，磁盘y的字节x由

logdisk[y*64+x];

或

我使用了无符号char，因为char可以根据您使用的编译器而被签名或未签名，并且大多数人认为字节是未签名的。 这将logdisk定义为指向块（由64个无符号字符组成的数组）的指针

然后你可以说logdisk[5][7]，并有块5的第七个字节等等

I would do it this way:

#define MAX_DISK_BLOCK_LEN (64)
#define MAX_DISK_BLOCKS    (64)

struct diskBlock
{
    char diskBlock[MAX_DISK_BLOCK_LEN];
};


struct diskBlock * logDisk = malloc(MAX_DISK_BLOCKS*sizeof(struct diskBlock) );

if( NULL == logDisk )
{
    perror( "malloc for logDisk failed" );
    exit( EXIT_FAILURE _;
}

// implied else, malloc successful

logDisk[x].diskBlock[y]  to access the areas in this logDisk
                         remembering to keep 'x' to the range 0...(MAX_DISK_BLOCKS-1)
                         remembering to keep 'y' to the range 0...(MAX_DISK_BLOCK_LEN -1)

我使用了无符号char，因为char可以根据您使用的编译器而被签名或未签名，并且大多数人认为字节是未签名的。 这将logdisk定义为指向块（由64个无符号字符组成的数组）的指针

---

然后你可以说logdisk[5][7]，并有块5的第七个字节等等。

无符号字符**logdisk[64]=malloc（sizeof（char）*64）；（字符*）的大小如何？我是否需要它？@Noah这首先看起来像是一个语法错误。你

将logdisk声明为指向无符号字符的指针的数组64，然后尝试用标量初始化数组
sizeof（char）
永远不需要，它总是1.unsigned char**logdisk[64]=malloc（sizeof（char）*64）；（字符*）的大小如何？我是否需要它？@Noah这首先看起来像是一个语法错误。你
将logdisk声明为指向无符号字符的指针的数组64，然后尝试用标量初始化数组
sizeof（char）
永远不需要，它总是1。是的：）这就是我刚才想的！但是我只需要64*64字节，sizeof（char）*64*64会给我一个不同的内存吗？不会，但在分配中使用
sizeof
是一个很好的做法，以确保跨平台的内存大小合适。是的：）这就是我刚才想的！但是我只需要64*64字节，sizeof（char）*64*64会给我一个不同的内存吗？不会，但在分配中使用
sizeof
是一个很好的做法，以确保跨平台的内存大小合适。是的：）这就是我刚才想的！但是我只需要64*64字节，大小（char）*64*64会给我一个不同的内存吗？你能告诉我更多关于释放的信息吗？你说的是什么意思？@Noah
64*sizeof（char*）
用于分配64个指针的数组注意
*
在
char
之后，然后循环这次单独分配每个扇区
64*sizeof（char）
，实际上是
64
@Noah，这将分配64*64个字符，但也分配64个字符指针。我认为这不对，我认为我们应该一次分配整个数组，如果我们在for循环中分配，内存是不连续的。是的：）这就是我刚才想的！但是我只需要64*64字节，大小（char）*64*64会给我一个不同的内存吗？你能告诉我更多关于释放的信息吗？你说的是什么意思？@Noah
64*sizeof（char*）
用于分配64个指针的数组注意
*
在
char
之后，然后循环这次单独分配每个扇区
64*sizeof（char）
，实际上是
64
@Noah，这将分配64*64个字符，但也会分配64个字符指针。我认为这不对，我认为我们应该一次分配整个数组，如果我们在for循环中分配，内存是不连续的。我不明白您在这里试图实现什么。你说的是逻辑磁盘——很好，然后做
char*logdisk=start\u of_disk。为什么你要把一个指针数组分配给更多的数组来描述线性的定义？我不明白你在这里想要实现什么。你说的是逻辑磁盘——很好，然后做
char*logdisk=start\u of_disk。为什么要将一个指针数组分配给更多的数组来描述线性定义？
I would do it this way:

#define MAX_DISK_BLOCK_LEN (64)
#define MAX_DISK_BLOCKS    (64)

struct diskBlock
{
    char diskBlock[MAX_DISK_BLOCK_LEN];
};


struct diskBlock * logDisk = malloc(MAX_DISK_BLOCKS*sizeof(struct diskBlock) );

if( NULL == logDisk )
{
    perror( "malloc for logDisk failed" );
    exit( EXIT_FAILURE _;
}

// implied else, malloc successful

logDisk[x].diskBlock[y]  to access the areas in this logDisk
                         remembering to keep 'x' to the range 0...(MAX_DISK_BLOCKS-1)
                         remembering to keep 'y' to the range 0...(MAX_DISK_BLOCK_LEN -1)

I would do it this way:

#define MAX_DISK_BLOCK_LEN (64)
#define MAX_DISK_BLOCKS    (64)

struct diskBlock
{
    char diskBlock[MAX_DISK_BLOCK_LEN];
};


struct diskBlock * logDisk = malloc(MAX_DISK_BLOCKS*sizeof(struct diskBlock) );

if( NULL == logDisk )
{
    perror( "malloc for logDisk failed" );
    exit( EXIT_FAILURE _;
}

// implied else, malloc successful

logDisk[x].diskBlock[y]  to access the areas in this logDisk
                         remembering to keep 'x' to the range 0...(MAX_DISK_BLOCKS-1)
                         remembering to keep 'y' to the range 0...(MAX_DISK_BLOCK_LEN -1)