在C中创建2（或3？）维字符串数组

我想创建一个字符串数组，如：

{{"zero","zero"},
{"zero","one"},
{"one","zero"},
{"one","one"}}

如果我没有错，我需要3D阵列。如何使用动态内存分配创建它，以及如何从函数返回它？我的意思是我的函数应该是什么（char***getString等），在我的主函数中，我该如何使用它？是

char***string=getstring（）工作

我还没有弄明白我必须使用3d阵列，我用2个Malloc试过了。
我在函数中创建数组字符串，如

char**editKeys=malloc（128*sizeof（char*））；
对于（int i=0；i<128；i++）
{
editKeys[i]=（char*）calloc（2，sizeof（char））；
}

它在功能上起作用。之后，我从main调用了my函数

char**editFile=getEditFile（）；
printf（“%s”，editFile[0][0]）；

在这一点上我失败了，现在我不能确定是2d还是3d，我的大脑也让我失望。我想不出如何在3d数组中转换它。
如果您的编译器支持可变长度数组，那么您可以按以下方式分配数组

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

void f( size_t n1, size_t n2, size_t n3, char s[n1][n2][n3] )
{
    for ( size_t i = 0; i < n1; i++ )
    {
        if ( i < n1 / 2 )
        {
            strcpy( s[i][0], "zero" );
        }
        else
        {
            strcpy( s[i][0], "one" );
        }

        if ( i % 2 == 0 )
        {
            strcpy( s[i][1], "zero" );
        }
        else
        {
            strcpy( s[i][1], "one" );
        }
    }
}

int main(void) 
{
    enum { N1 = 4, N2 = 2, N3 = 5 };
    char ( *p )[N2][N3] = malloc( sizeof( char[N1][N2][N3] ) );

    f( N1, N2, N3, p );

    for ( size_t i = 0; i < N1; i++ )
    {
        printf( "\"%s\" \"%s\"\n", p[i][0], p[i][1] );
    }

    free( p );

    return 0;
}

或者您确实可以分配一个数组的数组

比如说

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

void f( char ***s, size_t n1, size_t n2, size_t n3 )
{
    for ( size_t i = 0; i < n1; i++ )
    {
        if ( i < n1 / 2 )
        {
            strcpy( s[i][0], "zero" );
        }
        else
        {
            strcpy( s[i][0], "one" );
        }

        if ( i % 2 == 0 )
        {
            strcpy( s[i][1], "zero" );
        }
        else
        {
            strcpy( s[i][1], "one" );
        }
    }
}

int main(void) 
{
    enum { N1 = 4, N2 = 2, N3 = 5 };
    char ***p  = malloc( N1 * sizeof( char ** ) );

    for ( size_t i = 0; i < N1; i++ )
    {
        p[i] = malloc( N2 * sizeof( char * ) );
        for ( size_t j = 0; j < N2; j++ )
        {
            p[i][j] = malloc( N3 );
        }
    }

    f( p, N1, N2, N3 );

    for ( size_t i = 0; i < N1; i++ )
    {
        printf( "\"%s\" \"%s\"\n", p[i][0], p[i][1] );
    }


    for ( size_t i = 0; i < N1; i++ )
    {
        for ( size_t j = 0; j < N2; j++ )
        {
            free( p[i][j] );
        }

        free( p[i] );
    }

    free( p );

    return 0;
}

还有第三种方法，指针的数量可以少于上一种情况。您所需要的只是将一维指针数组分配给二维数组的第一个元素

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

enum { N1 = 4, N2 = 2, N3 = 5 };

void f( char ( **s )[N3], size_t n1 )
{
    for ( size_t i = 0; i < n1; i++ )
    {
        if ( i < n1 / 2 )
        {
            strcpy( s[i][0], "zero" );
        }
        else
        {
            strcpy( s[i][0], "one" );
        }

        if ( i % 2 == 0 )
        {
            strcpy( s[i][1], "zero" );
        }
        else
        {
            strcpy( s[i][1], "one" );
        }
    }
}

int main(void) 
{
    char ( **p )[N3]  = malloc( N1 * sizeof( char ( * )[N3] ) );

    for ( size_t i = 0; i < N1; i++ )
    {
        p[i] = malloc( N2 * sizeof( char[N3] ) );
    }

    f( p, N1 );

    for ( size_t i = 0; i < N1; i++ )
    {
        printf( "\"%s\" \"%s\"\n", p[i][0], p[i][1] );
    }


    for ( size_t i = 0; i < N1; i++ )
    {
        free( p[i] );
    }

    free( p );

    return 0;
}

#包括
#包括
#包括
枚举{N1=4，N2=2，N3=5}；
空f（字符（**s）[N3]，大小为n1）
{
对于（大小i=0；i

最后（我希望）有第四种方法，首先声明指向数组的指针数组

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

enum { N1 = 4, N2 = 2, N3 = 5 };

void f( char * ( *s )[N2], size_t n1, size_t n3 )
{
    for ( size_t i = 0; i < n1; i++ )
    {
        if ( i < n1 / 2 )
        {
            strcpy( s[i][0], "zero" );
        }
        else
        {
            strcpy( s[i][0], "one" );
        }

        if ( i % 2 == 0 )
        {
            strcpy( s[i][1], "zero" );
        }
        else
        {
            strcpy( s[i][1], "one" );
        }
    }
}

int main(void) 
{
    char * ( *p )[N2]  = malloc( N1 * sizeof( char * [N2] ) );

    for ( size_t i = 0; i < N1; i++ )
    {
        for ( size_t j = 0; j < N2; j++ )
        {
            p[i][j] = malloc( N3 * sizeof( char ) );
        }           
    }

    f( p, N1, N3 );

    for ( size_t i = 0; i < N1; i++ )
    {
        printf( "\"%s\" \"%s\"\n", p[i][0], p[i][1] );
    }


    for ( size_t i = 0; i < N1; i++ )
    {
        for ( size_t j = 0; j < N2; j++ ) free( p[i][j] );
    }

    free( p );

    return 0;
}

#包括
#包括
#包括
枚举{N1=4，N2=2，N3=5}；
空f（字符*（*s）[N2]，大小为n1，大小为n3）
{
对于（大小i=0；i

如果编译器确实支持可变长度数组，那么第一种方法是最好的

注：在这些方法中，有时不使用某些参数，例如
n2
，因为我不知道它等于
2
。但一般来说，应该指定它。
到目前为止，您尝试了什么？什么不起作用？在发布问题之前，你做过任何努力吗？如果是，请编辑您的问题，并提供有关您面临的问题的更多详细信息。事实上，我不明白我必须使用3d阵列，我尝试了2个Malloc。我在函数中创建数组字符串，比如
cchar**editKeys=malloc（128*sizeof（char*））；对于（inti=0；i<128；i++）{editKeys[i]=（char*）calloc（2，sizeof（char））；}
，它在函数中工作。之后，我从main调用了my函数，比如
cchar**editFile=getEditFile（）；printf（“%s”，editFile[0][0]）在这一点上我失败了，现在我不能确定是2d还是3d，我的大脑也让我失望了。我想不出如何在3d数组中转换它。请发布一条“不要强制转换调用
calloc（）
等的结果”-这是不必要的，可以掩盖缺少原型的严重错误。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

enum { N1 = 4, N2 = 2, N3 = 5 };

void f( char ( **s )[N3], size_t n1 )
{
    for ( size_t i = 0; i < n1; i++ )
    {
        if ( i < n1 / 2 )
        {
            strcpy( s[i][0], "zero" );
        }
        else
        {
            strcpy( s[i][0], "one" );
        }

        if ( i % 2 == 0 )
        {
            strcpy( s[i][1], "zero" );
        }
        else
        {
            strcpy( s[i][1], "one" );
        }
    }
}

int main(void) 
{
    char ( **p )[N3]  = malloc( N1 * sizeof( char ( * )[N3] ) );

    for ( size_t i = 0; i < N1; i++ )
    {
        p[i] = malloc( N2 * sizeof( char[N3] ) );
    }

    f( p, N1 );

    for ( size_t i = 0; i < N1; i++ )
    {
        printf( "\"%s\" \"%s\"\n", p[i][0], p[i][1] );
    }


    for ( size_t i = 0; i < N1; i++ )
    {
        free( p[i] );
    }

    free( p );

    return 0;
}

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

enum { N1 = 4, N2 = 2, N3 = 5 };

void f( char * ( *s )[N2], size_t n1, size_t n3 )
{
    for ( size_t i = 0; i < n1; i++ )
    {
        if ( i < n1 / 2 )
        {
            strcpy( s[i][0], "zero" );
        }
        else
        {
            strcpy( s[i][0], "one" );
        }

        if ( i % 2 == 0 )
        {
            strcpy( s[i][1], "zero" );
        }
        else
        {
            strcpy( s[i][1], "one" );
        }
    }
}

int main(void) 
{
    char * ( *p )[N2]  = malloc( N1 * sizeof( char * [N2] ) );

    for ( size_t i = 0; i < N1; i++ )
    {
        for ( size_t j = 0; j < N2; j++ )
        {
            p[i][j] = malloc( N3 * sizeof( char ) );
        }           
    }

    f( p, N1, N3 );

    for ( size_t i = 0; i < N1; i++ )
    {
        printf( "\"%s\" \"%s\"\n", p[i][0], p[i][1] );
    }


    for ( size_t i = 0; i < N1; i++ )
    {
        for ( size_t j = 0; j < N2; j++ ) free( p[i][j] );
    }

    free( p );

    return 0;
}