如何在C中创建字符串数组？


How do I create an array of strings in C?

我正在尝试在C中创建字符串数组。如果使用此代码：

1
2
3
char (*a[2])[14];
a[0]="blah";
a[1]="hmm";

GCC给出"警告：来自不兼容指针类型的赋值"。正确的方法是什么？

编辑：我很好奇为什么这会给出一个编译器警告，因为如果我执行printf(a[1]);，它会正确地打印"hmm"。

相关讨论

如果你不想改变的字符串，然后你可以简单的做 ＜／P >

1
2
3
const char *a[2];
a[0] ="blah";
a[1] ="hmm";

当你这样做，你将allocate安阵列const char分到两个。然后，请将这些组分的静态地址的字符串"blah"和"hmm"。 ＜／P >

如果你想能对变化的实际内容的字符串，你要做什么样 ＜／P >

1
2
3
char a[2][14];
strcpy(a[0],"blah");
strcpy(a[1],"hmm");

这将allocate阵列的二维连续14 chars每部、售后部车辆的静态内容的字符串将copied成了他们。 ＜／P >

有几种方法可以在C中创建字符串数组。如果所有字符串的长度都相同(或至少具有相同的最大长度)，只需声明一个二维char数组，并根据需要分配：

1
2
3
4
char strs[NUMBER_OF_STRINGS][STRING_LENGTH+1];
...
strcpy(strs[0], aString); // where aString is either an array or pointer to char
strcpy(strs[1],"foo");

还可以添加初始值设定项列表：

1
char strs[NUMBER_OF_STRINGS][STRING_LENGTH+1] = {"foo","bar","bletch", ...};

这假定初始值设定项中字符串的大小和数目与数组维度匹配。在这种情况下，每个字符串文字(本身是以零结尾的char数组)的内容都被复制到分配给strs的内存中。这种方法的问题是可能存在内部碎片；如果您有99个长度不超过5个字符的字符串，但是1个长度为20个字符的字符串，那么99个字符串将至少有15个未使用的字符；这是浪费空间。

您可以存储指向char的一维指针数组，而不是使用二维char数组：

1
char *strs[NUMBER_OF_STRINGS];

注意，在这种情况下，您只分配了内存来保存指向字符串的指针；字符串本身的内存必须分配到其他地方(作为静态数组或使用malloc()或calloc())。可以像前面的示例那样使用初始值设定项列表：

1
char *strs[NUMBER_OF_STRINGS] = {"foo","bar","bletch", ...};

与复制字符串常量的内容不同，您只需存储指向它们的指针。请注意，字符串常量可能不可写；您可以重新分配指针，如下所示：

1
2
strs[i] ="bar";
strs[i] ="foo";

但您可能无法更改字符串的内容；即，

1
2
strs[i] ="bar";
strcpy(strs[i],"foo");

可能不允许。

可以使用malloc()为每个字符串动态分配缓冲区并复制到该缓冲区：

1
2
strs[i] = malloc(strlen("foo") + 1);
strcpy(strs[i],"foo");

顺便说一句，

1
char (*a[2])[14];

声明作为指向14个char元素数组的指针的2元素数组。

相关讨论

唉！常数字符串： ＜／P >

1
const char *strings[] = {"one","two","three"};

如果我记得correctly。 ＜／P >

哦，你想使用strcpy的分配，不等于运算符。_ strcpy的冰更安全，但它的来信在C89标准C99标准输入。 ＜／P >

1
2
char arr[MAX_NUMBER_STRINGS][MAX_STRING_SIZE];
strcpy(arr[0],"blah");

更新：托马斯说strlcpy是要走的路。 ＜／P >

相关讨论

这里是一些你的选项： ＜／P >

1
2
3
4
5
6
7
char a1[][14] = {"blah","hmm" };
char* a2[] = {"blah","hmm" };
char (*a3[])[] = { &"blah", &"hmm" };  // only since you brought up the syntax -

printf(a1[0]); // prints blah
printf(a2[0]); // prints blah
printf(*a3[0]); // prints blah

A2的优势(这是你能做的，然后在下面的字符串 ＜／P >

1
2
a2[0] ="hmm";
a2[1] ="blah";

A3和你可以做下面的： ＜／P >

1
2
a3[0] = &"hmm";
a3[1] = &"blah";

用A1，你将要使用的，甚至当assigning strcpy字符串字面值。The reason这是A2和A3，是阵列的部分，你可以让他们的元素(即分)点到任何存储，而A1是阵列的阵列(""字符的每个元素是数组的一切"owns"其自己的存储网络(这意味destroyed山羊当它出的范围。)你可以只复制的东西到它的存储。 ＜／P >

这也brings美元到disadvantage利用A2和A3，自从他们到静态存储点(可存储在字符串字面值是)"内容"的消息，请reliably(即变。undefined行为)，如果你想些后台非字符串的元素(A2或A3，你将要dynamically第一allocate则有足够的内存和处理单元对存储器的这一点，才复制到网络的特点，然后确定你要问到释放的内存的时候做的。 ＜／P >

呸，在C + +小姐已；) ＜／P >

另外，让我知道如果你需要的实例。 ＜／P >

或者，您可以声明一个包含字符arry(1个字符串)的结构类型，它们创建一个结构数组，从而创建一个多元素数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedef struct name
{
   char name[100]; // 100 character array
}name;

main()
{
   name yourString[10]; // 10 strings
   printf("Enter something
:);
   scanf("%s",yourString[0].name);
   scanf("%s",yourString[1].name);
   // maybe put a for loop and a few print ststements to simplify code
   // this is just for example
 }

与任何其他方法相比，这种方法的一个优点是，它允许您直接扫描到字符串中，而不必使用strcpy；

在ANSI C： ＜／P >

1
2
3
4
char* strings[3];
strings[0] ="foo";
strings[1] ="bar";
strings[2] ="baz";
相关讨论

如果您不想跟踪数组中的字符串数量，并且想对其进行迭代，只需在末尾添加空字符串：

1
2
3
4
5
6
7
8
9
char *strings[]={"one","two","three", NULL };

int i=0;
while(strings[i]) {
  printf("%s
", strings[i]);
  //do something
  i++;
};
相关讨论

如果字符串是静态的，那么最好使用：

1
const char *my_array[] = {"eenie","meenie","miney"};

虽然不是基本的ANSIC的一部分，但您的环境很可能支持该语法。这些字符串是不可变的(只读的)，因此在许多环境中，使用的开销比动态构建字符串数组要少。

例如，在小型微控制器项目中，这种语法使用程序内存，而不是(通常)更宝贵的RAM内存。AVR-C是一个支持这种语法的示例环境，但其他大多数环境也是如此。

这是const char *s字符串字面值。 ＜／P >

和你的使用parenthesis冰奇。你可能均 ＜／P >

1
const char *a[2] = {"blah","hmm"};

这两个阵列部宣布分到的等特点，和他们对initializes硬编码的字符串的指针，双常数。 ＜／P >

你的代码的冰[[Creating阵列功能的部分。就安全了 ＜／P >

1
char* a[size];

或 ＜／P >

1
char a[size1][size2];

而不是。 ＜／P >

详见维基教科书对阵列和分 ＜／P >

相关讨论

您好，您可以尝试以下操作：

1
2
 char arr[nb_of_string][max_string_length];
 strcpy(arr[0],"word");

一个很好的使用C中字符串数组的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <stdio.h>
#include <string.h>


int main(int argc, char *argv[]){

int i, j, k;

// to set you array
//const arr[nb_of_string][max_string_length]
char array[3][100];

char temp[100];
char word[100];

for (i = 0; i < 3; i++){
    printf("type word %d :",i+1);
    scanf("%s", word);
    strcpy(array[i], word);
}

for (k=0; k<3-1; k++){
    for (i=0; i<3-1; i++)
    {
        for (j=0; j<strlen(array[i]); j++)
        {
            // if a letter ascii code is bigger we swap values
            if (array[i][j] > array[i+1][j])
            {
                strcpy(temp, array[i+1]);
                strcpy(array[i+1], array[i]);
                strcpy(array[i], temp);

                j = 999;
            }

            // if a letter ascii code is smaller we stop
            if (array[i][j] < array[i+1][j])
            {
                    j = 999;
            }

        }
    }
}

for (i=0; i<3; i++)
{
    printf("%s
",array[i]);
}

return 0;
}

我在某种程度上缺少了更动态的字符串数组，其中字符串的数量可以根据运行时选择的不同而变化，但否则字符串应该是固定的。

我已经结束了这样的代码片段：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#define INIT_STRING_ARRAY(...)          \
    {                                   \
        char* args[] = __VA_ARGS__;     \
        ev = args;                      \
        count = _countof(args);         \
    }

void InitEnumIfAny(String& key, CMFCPropertyGridProperty* item)
{
    USES_CONVERSION;
    char** ev = nullptr;
    int count = 0;

    if( key.Compare("horizontal_alignment") )
        INIT_STRING_ARRAY( {"top","bottom" } )

    if (key.Compare("boolean"))
        INIT_STRING_ARRAY( {"yes","no" } )

    if( ev == nullptr )
        return;

    for( int i = 0; i < count; i++)
        item->AddOption(A2T(ev[i]));

    item->AllowEdit(FALSE);
}

char** ev选择指向数组字符串的指针，count使用_countof函数选择字符串的数量。(与sizeof(arr) / sizeof(arr[0])相似)。

还有使用A2T宏进行的额外的ansi到unicode转换，但这对于您的情况可能是可选的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
char name[10][10]
int i,j,n;//here"n" is number of enteries
printf("
Enter size of array =");
scanf("%d",&n);
for(i=0;i<n;i++)
{
    for(j=0;j<1;j++)
    {
        printf("
Enter name =");
        scanf("%s",&name[i]);
    }
}
//printing the data
for(i=0;i<n;i++)
{
    for(j=0;j<1;j++)
    {
        printf("%d\t|\t%s\t|\t%s",rollno[i][j],name[i],sex[i]);
    }
    printf("
");
}

试试这里！！！！

相关讨论

一个好方法是定义一个你自己的字符串。

1
2
3
4
5
6
#include <stdio.h>
typedef char string[]
int main() {
    string test ="string";
    return 0;
}

这真的很简单。

相关讨论