如何确定在某些C文件中是否定义或初始化了声明的extern变量

问题描述

我有一些结构表，这些表根据我使用的驱动程序而有所不同。 我希望能够检查某个驱动程序是否已编译（或者通过关系，如果已定义其表）。

我已经看了很多遍，但似乎无法找到一种方法来确定是否定义了声明的extern变量或 是否可以通过某种方法检查c源文件是否已在给定应用程序中进行了编译（链接）。我曾经看过使用诸如container_of宏之类的宏魔术，但是到目前为止我还很短。

例如说我有以下内容：

checkFile.c

#include "neutral.h"
#include "fileA.h"
#include "fileB.h"

bool setTable(int type,someStruct_t *table) {

    /*
    This doesn't work
    fails to compile with:
    undefined reference to fileA_Table
    ironically this is what I'm trying to check
    */
    switch (type) {
        case FILEA:
            if (fileA_Table) {
                someTable = &fileA_Table;
                return true;
            }
            else {
                someTable = NULL;
                return false; 
            }
        break;
        case FILEB:
            if (fileB_Table) {
                someTable = &fileB_Table;
                return true;
            }
            else {
                someTable = NULL;
                return false; 
            } 
        break;
        default:
            someTable = NULL;
            return false;   
    }
}

neutral.h

typedef struct {
    int memberA;
    bool memberB;
} someStruct_t;

extern someStruct_t fileA_table[];
extern someStruct_t fileB_table[];

fileA.c

#include "neutral.h"

someStruct_t fileA_table[] = {
    {
        .memberA = 0;
        .memberB = false;
    },{
        .memberA = 5;
        .memberB = false;
    }
}

fileB.c

#include "neutral.h"
someStruct_t fileB_table[] = {
    {
        .memberA = 14;
        .memberB = true;
    },{
        .memberA = 5;
        .memberB = true;
    }
}

我什至不确定这是我可以在C中完成的事情，实际上我要解决的基本问题是初始化依赖于fileA或fileB的某种类型的接口，并确保可以使用哪些数组来自fileA和/或fileB。注意这个

理想情况下，我实际上想只使用file_table，但如果fileA和fileB都被编译，那我是不可能的。

请注意，无论fileA或fileB 还是两个文件都已编译，此方法都应起作用。

非常感谢您的帮助。

解决方法

您的代码可以安全地假定该变量存在。

否则，在尝试将目标文件链接到可执行文件时，会在链接阶段从编译器收到错误消息。

如果要进行某种条件编译，则需要根据可用条件设置宏，然后在代码的各个部分中检查该宏。

例如：

#include "neutral.h"

#ifdef USE_FILE_A
#include "fileA.h"
#elif defined USE_FILE_B
#include "fileB.h"
#endif

bool setTable(someStruct_t **table)
{
#ifdef USE_FILE_A
    *table= &fileA_Table;
    return true;
#elif defined USE_FILE_B
    *table= &fileB_Table;
    return true;
#else
    *table = NULL;
    return false;
}

使用更新的代码：

#include "neutral.h"

#ifdef HAS_FILE_A
#include "fileA.h"
#endif
#ifdef HAS_FILE_B
#include "fileB.h"
#endif

bool setTable(int type,someStruct_t *table)
{
    switch (type) {
        case FILEA:
            #ifdef HAS_FILE_A
                someTable = &fileA_Table;
                return true;
            #else
                someTable = NULL;
                return false; 
            #endif
        break;
        case FILEB:
            #ifdef HAS_FILE_B
                someTable = &fileB_Table;
                return true;
            #else
                someTable = NULL;
                return false; 
            #endif
        break;
        default:
            someTable = NULL;
            return false;   
    }
}

,

根据比尔·林奇（Bill Lynch）的建议，我研究了强弱符号here和here，并找到了一种有吸引力的解决方案。大概这就是我想出的。

checkFile.c

#include "neutral.h"
#include "fileA.h"
#include "fileB.h"

bool setTable(int type,someStruct_t *table) {
    /*
     * This will compile and if fileA_table has not been
     * defined in fileA then it will evaluate to 0
     */
    switch (type) {
        case FILEA:
            if (fileA_Table) {
                someTable = &fileA_Table;
                return true;
            }
            else {
                someTable = NULL;
                return false; 
            }
        break;
        case FILEB:
            if (fileB_Table) {
                someTable = &fileB_Table;
                return true;
            }
            else {
                someTable = NULL;
                return false; 
            } 
        break;
        default:
            someTable = NULL;
            return false;   
    }
}

neutral.h

typedef struct {
    int memberA;
    bool memberB;
} someStruct_t;

__attribute__((weak)) extern someStruct_t fileA_table[];
__attribute__((weak)) extern someStruct_t fileB_table[];

fileA.c

#include "neutral.h"

someStruct_t fileA_table[] = {
    {
        .memberA = 0;
        .memberB = false;
    },{
        .memberA = 5;
        .memberB = false;
    }
}

fileB.c

#include "neutral.h"
someStruct_t fileB_table[] = {
    {
        .memberA = 14;
        .memberB = true;
    },{
        .memberA = 5;
        .memberB = true;
    }
}

我喜欢它，因为这意味着我可以获得所需的结果，而对我的界面的影响最小，而对编译器选项/命令没有影响。

我本来希望对fileA和fileB使用相同的符号来使通用接口层和中性标头更干净，以获得类似的内容：

neutral.h

typedef struct {
    int memberA;
    bool memberB;
} someStruct_t;

__attribute__((weak)) extern someStruct_t file_table[];

checkFile.c

#include "neutral.h"
#include "fileA.h"
#include "fileB.h"

bool setTable(int type,someStruct_t *table) {

    if (file_Table) {
        someTable = &file_table;
        return true;
    }
    
    someTable = NULL;
    return false; 
}

只要我们将从checkFile.c开始的接口编译为两个单独的二进制文件，就可以完成此操作。一次与fileA.c链接，一次与fileB.c链接。这的确增加了构建选项的复杂性，增加了代码大小，并且我不确定对性能的影响，但是它使代码更易于维护，并且需要更多潜在文件和几种类型的表，因此代码的维护性更高。已选中。