C 将一维字符*划分为二维字符**

关于将二维数组转换为一维数组，有很多问题，但我的尝试正好相反。我试图将一个字符串划分为等长的子字符串，并将它们放入2D数组中。该2D矩阵的每一行应包含初始字符串的子字符串，如果要连续读取并连接每一行，则应复制初始字符串

我几乎让它工作了，但由于某种原因，我丢失了初始字符串（bin）的第一个子字符串（partitions[0]--长度8*blockSize）：

---

第一个for循环中的分区构造是成功的。在读取时构造之后，分区[0]处的字符串包含垃圾值。有人能提供一些见解吗？

他们对您的代码有一些问题

• 您分配的分区不正确
  而不是：

  char** partitions = (char**)malloc((numBlocks+1)*sizeof(char)); /* dont need +1, as numblocks is enough space. */
  

  您需要为

  char*

  指针分配空间，而不是

  char

  字符
  相反，这需要：

  char** partitions = malloc((numBlocks+1)*sizeof(char*));
  

• 也请阅读，因为C中不需要它

• 每次都需要检查

  malloc（）

  ，因为失败时它可能返回

  NULL

• 一旦分配完空间，就可以使用以前由

  malloc（）

  请求的内存。在程序中的某个时候这样做很重要

下面是一些代码，显示了以下内容：

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

#define BLOCKSIZE 2
#define BLOCK_MULTIPLIER 8

int main(void) {
    const char *bin = "00011101010000100001111101001101000010110000111100000010000111110100111100010011010011100011110000011010";
    const size_t blocksize = BLOCKSIZE;
    const size_t multiplier = BLOCK_MULTIPLIER;
    const size_t numblocks = strlen(bin)/(multiplier * blocksize);
    const size_t numbytes = multiplier * blocksize;

    char **partitions = malloc(numblocks * sizeof(*partitions));
    if (partitions == NULL) {
        printf("Cannot allocate %zu spaces\n", numblocks);
        exit(EXIT_FAILURE);
    }

    for (size_t i = 0; i < numblocks; i++) {
        partitions[i] = malloc(numbytes+1);
        if (partitions[i] == NULL) {
            printf("Cannot allocate %zu bytes for pointer\n", numbytes+1);
            exit(EXIT_FAILURE);
        }
        memcpy(partitions[i], &bin[numbytes * i], numbytes);
        partitions[i][numbytes] = '\0';
        printf("Printing partitions[%zu]: %s\n", i, partitions[i]);
    }

    printf("\n");
    for(size_t j = 0; j < numblocks; j++) {
        printf("Printing partitions[%zu]: %s\n", j,partitions[j]);
        free(partitions[j]);
        partitions[j] = NULL;
    }

    free(partitions);
    partitions = NULL;

    return 0;
}

---

malloc（（numBlocks+1）*sizeof（char））

-->malloc（（numBlocks+1）*sizeof（char*））如果字符串是固定长度的，为什么首先要使用指针到指针？你可以声明一个固定大小的2D数组。我必须同意这里的@Lundin，这段代码不需要任何指针。

char** partitions = malloc((numBlocks+1)*sizeof(char*));

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

#define BLOCKSIZE 2
#define BLOCK_MULTIPLIER 8

int main(void) {
    const char *bin = "00011101010000100001111101001101000010110000111100000010000111110100111100010011010011100011110000011010";
    const size_t blocksize = BLOCKSIZE;
    const size_t multiplier = BLOCK_MULTIPLIER;
    const size_t numblocks = strlen(bin)/(multiplier * blocksize);
    const size_t numbytes = multiplier * blocksize;

    char **partitions = malloc(numblocks * sizeof(*partitions));
    if (partitions == NULL) {
        printf("Cannot allocate %zu spaces\n", numblocks);
        exit(EXIT_FAILURE);
    }

    for (size_t i = 0; i < numblocks; i++) {
        partitions[i] = malloc(numbytes+1);
        if (partitions[i] == NULL) {
            printf("Cannot allocate %zu bytes for pointer\n", numbytes+1);
            exit(EXIT_FAILURE);
        }
        memcpy(partitions[i], &bin[numbytes * i], numbytes);
        partitions[i][numbytes] = '\0';
        printf("Printing partitions[%zu]: %s\n", i, partitions[i]);
    }

    printf("\n");
    for(size_t j = 0; j < numblocks; j++) {
        printf("Printing partitions[%zu]: %s\n", j,partitions[j]);
        free(partitions[j]);
        partitions[j] = NULL;
    }

    free(partitions);
    partitions = NULL;

    return 0;
}

Printing partitions[0]: 0001110101000010
Printing partitions[1]: 0001111101001101
Printing partitions[2]: 0000101100001111
Printing partitions[3]: 0000001000011111
Printing partitions[4]: 0100111100010011
Printing partitions[5]: 0100111000111100

Printing partitions[0]: 0001110101000010
Printing partitions[1]: 0001111101001101
Printing partitions[2]: 0000101100001111
Printing partitions[3]: 0000001000011111
Printing partitions[4]: 0100111100010011
Printing partitions[5]: 0100111000111100

int numBlocks = strlen(bin)/(8*blockSize); // number of block to analyze
char** partitions = (char**)malloc((numBlocks+1)*sizeof(char)); // break text into block
for(int i = 0; i<numBlocks;++i){
    partitions[i] = (char*)malloc((8*blockSize+1)*sizeof(char));
    memcpy(partitions[i],&bin[8*i*blockSize],8*blockSize);
    partitions[i][8*blockSize] = '\0';
    printf("Printing partitions[%d]: %s\n", i, partitions[i]);
}

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

#define BLOCK_SIZE 8

int main(void) {
    char const *bin = "00011101010000100001111101001101000010110000111100000010000111110100111100010011010011100011110000011010";
    size_t bin_length = strlen(bin),
           block_count = (bin_length / BLOCK_SIZE)
                       + (bin_length % BLOCK_SIZE > 0); // excess as per point 6 above
    char (*block)[BLOCK_SIZE + 1] = malloc(block_count * sizeof *block);
    if (!block) { exit(EXIT_FAILURE); }
    for (size_t x = 0; x < block_count; x++) {
        snprintf(block[x], BLOCK_SIZE + 1, "%s", bin + x * BLOCK_SIZE);
        printf("Printing partitions[%zu]: %s\n", x, block[x]);
    }
    for (size_t x = 0; x < block_count; x++) {
        printf("Printing partitions[%zu]: %s\n", x, block[x]);
    }
    free(block);
    exit(0);
}