Можно ли включать #include исходный файл .c для удобства сопровождения встроенного C-кода?

Определение const как static в нескольких файлах не является хорошей идеей, поскольку создает несколько экземпляров большой переменной MyElements. Это увеличит память во встроенной системе. Спецификатор static необходимо удалить.

Вот предлагаемое решение:

в file.h

#define TOTO_IND 0 
#define TITI_IND 1 
…
#define TATA_IND 50
#define MAX_ELEMS 51

extern const MyElements elems[MAX_ELEMS];

в file.c

#include "file.h"
const MyElements elems [MAX_ELEMS] = {
    {"TOTO", 18, "French"},
    {"TITI", 27, "English"},
    ...,
    {"TATA", 45, "Spanish"}
}

После модификации поместите #include "file.h" в необходимые файлы .c.

В других ответах этот вопрос уже описан более четко, но для полноты изложения здесь используется подход x-macro, если вы хотите пойти по этому пути и рискнуть яростью своего коллеги.

X-макросы - это форма генерации кода, использующая встроенный препроцессор Си. Цель состоит в том, чтобы свести повторение к минимуму, хотя и с некоторыми недостатками:

1. Исходный файл, который генерирует перечисления и структуры с использованием препроцессора, может показаться сложным, если вы к ним не привыкли.
2. По сравнению с внешним сценарием сборки, который генерирует исходные файлы, с x-макросами вы никогда не увидите, как сгенерированный код выглядит во время компиляции, если вы не используете настройку компилятора и не проверяете предварительно обработанный файл вручную.
3. Поскольку вы не видите предварительно обработанные выходные данные, вы не можете использовать отладчик для пошагового выполнения сгенерированного кода так же, как и с кодом, сгенерированным внешним сценарием.

Вы начинаете с создания списка вызовов макро в отдельном файле, например, elements.inc, не определяя, что на самом деле делает макрос в этот момент:

// elements.inc

// each row passes a set of parameters to the macro,
// although at this point we haven't defined what the
// macro will output

XMACRO(TOTO, 18, French)
XMACRO(TITI, 27, English)
XMACRO(TATA, 45, Spanish)

И затем вы определяете макрос каждый раз, когда вам нужно включить этот список, чтобы каждый вызов отображался в одной строке конструкция, которую вы хотите создать - и вы обычно повторяете это несколько раз подряд, т.е.

// concatenate id with "_IND" to create enums, ignore code and description
// (notice how you don't need to use all parameters each time)
// e.g. XMACRO(TOTO, 18, French) => TOTO_IND,
#define XMACRO(id, code, description) id ## _IND,
typedef enum
{
#    include "elements.inc"
     ELEMENTS_COUNT
}
Elements;
#undef XMACRO

// create struct entries
// e.g. XMACRO(TOTO, 18, French) => [TOTO_IND] = { "TOTO", 18, "French" },
#define XMACRO(id, code, description) [id ## _IND] = { #id, code, #description },
const MyElements elems[] = {
{
#    include "elements.inc"
};
#undef XMACRO

Что будет предварительно обработано во что-то вроде:

typedef enum
{
    TOTO_IND,
    TITI_IND,
    TATA_IND,
    ELEMENTS_COUNT
}
Elements;

const MyElements elems[] = {
{
    [TOTO_IND] = { "TOTO", 18, "French" },
    [TITI_IND] = { "TITI", 27, "English" },
    [TATA_IND] = { "TATA", 45, "Spanish" },
};

Очевидно, что частое обслуживание списка становится проще, за счет того, что генерирующий код становится более запутанным.

Чтобы ответить на конкретный вопрос об использовании #include с файлом .c (другие ответы предлагают лучшие варианты, особенно тот, который предлагает Groo), в общем, в этом нет необходимости.

Все в файле .c можно сделать внешне видимым и доступным, так что вы можете ссылаться на него через прототипы функций и #extern. Так, например, вы можете сослаться на свою таблицу с помощью #extern const MyElements elems []; в вашем основном файле .c.

Кроме того, вы можете поместить определения в файл .h и включить его. Это позволяет вам разделять код так, как вы хотите. Имейте в виду, что все, что делает #include, - это вставляет содержимое включаемого файла, где находится оператор #include, поэтому у него не должно быть какого-либо конкретного расширения файла. .h используется по соглашению, и большинство IDE автоматически добавляют файлы .c в список файлов для компиляции, но что касается компилятора, именование является произвольным.

Вы можете использовать назначенные инициализаторы для инициализации элементов elems[] без необходимости знать явное значение каждого индекса индекса (или макроса).

const MyElements elems[] = {
    [TOTO_IND] = {"TOTO", 18, "French"},
    [TITI_IND] = {"TITI", 27, "English"},
    [TATA_IND] = {"TATA", 45, "Spanish"},
};

Элементы массива будут инициализированы таким же образом, даже если вы измените порядок их появления в исходном коде:

const MyElements elems[] = {
    [TITI_IND] = {"TITI", 27, "English"},
    [TATA_IND] = {"TATA", 45, "Spanish"},
    [TOTO_IND] = {"TOTO", 18, "French"},
};

Если длина массива устанавливается автоматически из инициализатора, как указано выше (т.е. используя [], а не [NUM_ELEMS]), тогда длина будет на единицу больше, чем максимальный индекс элемента.

Это позволяет вам сохранить значения индекса и внешнюю декларацию массива elems в файле .h, а также определить содержимое массива elems в отдельном файле .c.