如何从字符串初始化字符数组

Question

我想做以下事情

char a[] = { 'A', 'B', 'C', 'D'};

但我不想单独写这些字符。我想要类似的东西

#define S "ABCD"

char a[] = { S[0], S[1], S[2], S[3] };

但这不会编译（gcc 说'initializer element is not constant'）。

我尝试将#define 行替换为

const char S[] = "ABCD";

但这似乎没有帮助。

我怎样才能做到这一点（或类似的东西），让我把“ABCD”写成一个普通的“字符串”，而不是四个单独的字符？

附：似乎人们没有正确阅读问题...

我无法编译以下代码：

const char S[] = "ABCD";
char t[] = { S[0], S[1], S[2], S[3] };
char u[] = { S[3], S[2], S[1], S[0] };

Answer 1

你不能 - 在 C 中。在 C 中，全局和局部静态变量的初始化被设计为编译器可以将值静态地放入可执行文件中。它不能将非常量表达式作为初始值设定项处理。并且仅在 C99 中，您可以在聚合初始值设定项中使用非常量表达式 - 在 C89 中并非如此！

在您的情况下，由于您的数组是一个包含字符的数组，因此每个元素都必须是一个算术常量表达式。看看它是怎么说的

算术常量表达式应该有算术类型并且应该只有 整数常量、浮点常量、枚举常量、字符的操作数 常量和 sizeof 表达式。

您的初始化程序肯定不满足这一点，它使用指针类型的操作数。当然，另一种方法是使用字符串文字初始化数组，正如它所解释的那样

具有静态存储持续时间的对象的初始化程序中的所有表达式都应为常量表达式或字符串字面量。

所有引用均来自 C99 TC3 委员会草案。所以总而言之，你想做的事情——使用非常量表达式——不能用 C 来完成。你有几个选择：

• 多次写你的东西 - 一次颠倒，另一次不颠倒。
• 更改语言 - C++ 可以做到这一切。
• 如果您真的想要这样做，请改用 char const* 数组

这就是我所说的最后一个选项的意思

char const c[] = "ABCD";
char const *f[] = { &c[0], &c[1], &c[2], &c[3] };
char const *g[] = { &c[3], &c[2], &c[1], &c[0] };

这很好，因为地址常量表达式用于初始化指针

地址常量是一个空指针，一个指向指定静态存储持续时间对象的左值的指针，或者一个指向函数指示符的指针；它应使用一元 & 运算符或转换为指针类型的整数常量显式创建，或通过使用数组或函数类型的表达式隐式创建。数组下标 [] 和成员访问。和 -> 运算符、地址 & 和间接 * 一元运算符以及指针转换可用于创建地址常量，但不得使用这些运算符访问对象的值。

您可能会幸运地调整您的编译器选项 - 另一个引用：

一个实现可以接受其他形式的常量表达式。

Answer 2

简单

const char S[] = "ABCD";

应该可以。

你的编译器是什么？

Answer 3

另一种选择是使用 sprintf。

例如，

char buffer[50];
sprintf( buffer, "My String" );

祝你好运。

Answer 4

这在 gcc 版本 4.3.3 (Ubuntu 4.3.3-5ubuntu4) 上编译得很好。

const char s[] = "cheese";

int main()
{
    return 0;
}

Answer 5

const char S[] = "ABCD";

这应该可行。我只使用这个符号，它对我来说非常好。不知道你是怎么用的。

Answer 6

奇怪的错误。

你能测试一下吗？

const char* const S = "ABCD";
char t[] = { S[0], S[1], S[2], S[3] };
char u[] = { S[3], S[2], S[1], S[0] };

Answer 7

这里是晦涩的解决方案：定义宏函数：

#define Z(x) \
        (x==0 ? 'A' : \
        (x==1 ? 'B' : \
        (x==2 ? 'C' : '\0')))

char x[] = { Z(0), Z(1), Z(2) };

Answer 8

这是生成适当代码的脚本可能会有所帮助的情况之一。

Answer 9

如果三个变量是全局的，编译问题只会发生在我身上（gcc 4.3，ubuntu 8.10）。问题是 C 不像脚本语言那样工作，所以你不能想当然地认为 u 和 t 的初始化发生在 s 之后。这就是你得到编译错误的原因。现在，您无法像以前那样初始化 t 和 y，这就是您需要 char* 的原因。完成这项工作的代码如下：

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

#define STR "ABCD"

const char s[] = STR;
char* t;
char* u;

void init(){
    t = malloc(sizeof(STR)-1);
    t[0] = s[0];
    t[1] = s[1];
    t[2] = s[2];
    t[3] = s[3];


    u = malloc(sizeof(STR)-1);
    u[0] = s[3];
    u[1] = s[2];
    u[2] = s[1];
    u[3] = s[0];
}

int main(void) {
    init();
    puts(t);
    puts(u);

    return EXIT_SUCCESS;
}

Answer 10

我不确定您的问题是什么，但以下似乎可以正常工作：

#include <stdio.h>

int main()
{
    const char s0[] = "ABCD";
    const char s1[] = { s0[3], s0[2], s0[1], s0[0], 0 };

    puts(s0);
    puts(s1);
    return 0;
}


Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.
cl /Od /D "WIN32" /D "_CONSOLE" /Gm /EHsc /RTC1 /MLd /W3 /c /ZI /TC
   .\Tmp.c
Tmp.c
Linking...

Build Time 0:02


C:\Tmp>tmp.exe
ABCD
DCBA

C:\Tmp>

2009 年 6 月 9 日编辑

如果你需要全局访问，你可能需要像这样丑陋的东西：

#include <stdio.h>

const char *GetString(int bMunged)
{
    static char s0[5] = "ABCD";
    static char s1[5];

    if (bMunged) {
        if (!s1[0])  {
            s1[0] = s0[3]; 
            s1[1] = s0[2];
            s1[2] = s0[1];
            s1[3] = s0[0];
            s1[4] = 0;
        }
        return s1;
    } else {
        return s0;
    }
}

#define S0 GetString(0)
#define S1 GetString(1)

int main()
{
    puts(S0);
    puts(S1);
    return 0;
}

Answer 11

也许您的字符数组需要保持不变。由于您使用常量字符串中的字符初始化数组，因此您的数组必须是常量。试试这个：

#define S "ABCD"
const char a[] = { S[0], S[1], S[2], S[3] };