C 是否可以在初始值设定项中使用三元运算符初始化静态数组？

是否可以在初始值设定项中使用三元运算符初始化静态数组？ 例如：

// Array of functions 
static const Callback_t CallbackArray[] =
{
    GenConfig,
    GenInfo,
    /* here is the ternary operator to chose a callback */
    Test() ? Config : NULLConfig,   
};

其中Test（）是返回0或1的函数

// somewhere else in the code
int gVar = 0;

int TEST(void)
{
    return gVar;
}

---

CallbackArray

数组具有静态存储持续时间（即由于

static

关键字或它可能被放置在任何函数之外），这意味着它必须用常量表达式初始化

---

这里，条件运算符

？：

不产生常量表达式（因为它包含函数调用），因此该代码无效。

调用数组

具有静态存储持续时间（即，由于
静态关键字或它可能被放置在任何函数之外），这意味着，它必须用常量表达式初始化

这里，条件运算符
？：
不产生常量表达式（因为它包含函数调用），因此该代码无效。
您不能基于函数初始化
静态数组的内容

但要选择另一个函数

typedef returntype (*fxtype)(parmtypes);

fxtype choose(void) {
    return Test() ? Config : NULLConfig;
}

static const Callback_t CallbackArray[] =
{
    GenConfig,
    GenInfo,
    choose,   
};

不能基于函数初始化
静态
数组的内容

但要选择另一个函数

typedef returntype (*fxtype)(parmtypes);

fxtype choose(void) {
    return Test() ? Config : NULLConfig;
}

static const Callback_t CallbackArray[] =
{
    GenConfig,
    GenInfo,
    choose,   
};

如果数组没有静态存储持续时间，则可以将运算符用作初始值设定项表达式

来自C标准（6.7.9初始化）

4具有静态属性的对象的初始值设定项中的所有表达式
或线程存储持续时间应为常量表达式或字符串
文字

请注意，您可能不会声明函数数组，但可以声明指向函数的指针数组

这是一个演示程序

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

int main(void) 
{
    int x = 1, y = 2;

    void ( *fp[] )( void ) = { x < y ? f : g };

    fp[0]();

    return 0;
}

如果函数类型太复杂，可以为其引入typedef。比如说

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

int main(void) 
{
    int x = 1, y = 2;

    typedef void F( void );

    F * fp[] = { x < y ? f : g };

    fp[0]();

    return 0;
}

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

typedef void F( void );

F * fp[] = { 1 ? &f : &g };

int main(void) 
{
    fp[0]();

    return 0;
}

#包括
void f（void）{put（“f”）；}
void g（void）{put（“g”）；}
内部主（空）
{
int x=1，y=2；
类型定义无效F（无效）；
F*fp[]={x

可以使用条件运算符初始化具有静态存储持续时间的数组。问题是，条件必须是一个常数表达式，但并不总是合适的。比如说

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

int main(void) 
{
    int x = 1, y = 2;

    typedef void F( void );

    F * fp[] = { x < y ? f : g };

    fp[0]();

    return 0;
}

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

typedef void F( void );

F * fp[] = { 1 ? &f : &g };

int main(void) 
{
    fp[0]();

    return 0;
}

#包括
void f（void）{put（“f”）；}
void g（void）{put（“g”）；}
类型定义无效F（无效）；
F*fp[]={1？&F:&g}；
内部主（空）
{
fp[0]（）；
返回0；
}

来自C标准（6.6常量表达式）

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

如果数组没有静态存储持续时间，则可以将运算符用作初始值设定项表达式

来自C标准（6.7.9初始化）

4具有静态属性的对象的初始值设定项中的所有表达式
或线程存储持续时间应为常量表达式或字符串
文字

请注意，您可能不会声明函数数组，但可以声明指向函数的指针数组

这是一个演示程序

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

int main(void) 
{
    int x = 1, y = 2;

    void ( *fp[] )( void ) = { x < y ? f : g };

    fp[0]();

    return 0;
}

如果函数类型太复杂，可以为其引入typedef。比如说

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

int main(void) 
{
    int x = 1, y = 2;

    typedef void F( void );

    F * fp[] = { x < y ? f : g };

    fp[0]();

    return 0;
}

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

typedef void F( void );

F * fp[] = { 1 ? &f : &g };

int main(void) 
{
    fp[0]();

    return 0;
}

#包括
void f（void）{put（“f”）；}
void g（void）{put（“g”）；}
内部主（空）
{
int x=1，y=2；
类型定义无效F（无效）；
F*fp[]={x

可以使用条件运算符初始化具有静态存储持续时间的数组。问题是，条件必须是一个常数表达式，但并不总是合适的。比如说

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

int main(void) 
{
    int x = 1, y = 2;

    typedef void F( void );

    F * fp[] = { x < y ? f : g };

    fp[0]();

    return 0;
}

#include <stdio.h>

void f( void ) { puts( "f"); }
void g( void ) { puts( "g"); }

typedef void F( void );

F * fp[] = { 1 ? &f : &g };

int main(void) 
{
    fp[0]();

    return 0;
}

#包括
void f（void）{put（“f”）；}
void g（void）{put（“g”）；}
类型定义无效F（无效）；
F*fp[]={1？&F:&g}；
内部主（空）
{
fp[0]（）；
返回0；
}

来自C标准（6.6常量表达式）

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

对这是完全正确的。只要
Test（）
s是宏，你试过吗？它起作用了吗？如果没有，您会遇到什么错误？我认为这里唯一的问题是
Test（）
，因为函数不是常量表达式。如果不是这样，代码应该是可以的。Test（）是一个函数，正如我所写的，不是宏。这似乎是可行的，但我不明白怎么做，因为Test（）在初始化时检查一个全局变量，代码使用
Test（）
。有一个函数名为
TEST（）
TEST（）
与
TEST（）
不同。发布真实代码。目前还不清楚被问到了什么问题。这是完全正确的。只要
Test（）
s是宏，你试过吗？它起作用了吗？如果没有，您会遇到什么错误？我认为这里唯一的问题是
Test（）
，因为函数不是常量表达式。如果不是因为这个，t