Едино разовое объявление структуры в проекте

Question

[Atilla]

Есть, допустим, три файла:
blah.c blah.h main.c
в blah.h объявлена структура:
structure blah test_blah (...);
в blah.c она описана (и подключен файл blah.h).

В main.c подключен blah.h

В этом случае, при попытке скомпилировать эти файлы компилятор ругается об дублированном объявлении структуры test_blah.
Поэтому я пишу вместо structure blah test_blah (...);
static structure blah test_blah (...);

Но в таком случае создаётся 2 независимых экземпляра test_blah (в blah.c и main.c), что не желательно.

Как сделать так, чтобы был объявлен только 1 экземпляр test_blah в main.c

Comments

[tvolf]

Не знаю, правильно ли понял задачу, но условная компиляция при помощи #ifdef не решит эту проблему?

[Atilla]

Нет, как ни странно, не решают

Answer 1

[MikhailEdoshin]

Вы переменную создаете, а не только структуру объявляете. test_blah — это переменная, тип данных struct blah. Задумывалось, наверное, так:

/* blah.h */
struct blah; /* урезанное описание */

/* blah.c */
#include "blah.h"
struct blah { int a, b } /* описание */
test_blah; /* и тут же объявление переменной этого типа */

/* main.c */
#include "blah.h"
/* можно работать с указателями на struct blah */

Comments

[MikhailEdoshin]

Или если вам нужна именно глобальная переменная, то так:

/* blah.h */
extern struct blah { int a, b  } test_blah; /* описание  */

/* blah.c */
#include "blah.h"
struct blah test_blah; /* реальное объявление */

/* mainc. */
#include "blah.h"
/* можно использовать test_blah */

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

/* blah.h */
extern struct blah *test_blah; /* неполное описание  */

/* blah.c */
#include "blah.h"
struct blah { int a, b }; /* полное описание */
static struct blah real_test_blah; /* внутренняя переменная */
struct blah *test_blah = &real_test_blah;

/* mainc. */
#include "blah.h"
/* можно использовать test_blah, но как слепой указатель */

Answer 2

[Door]

Не «описание» и «описание», а объявление (declaration) и определение (definition).
Если у Вас есть тип (struct blah) и Вам нужен один экземпляр (instance) (в Вашем случае test_blah) этого типа, к которому нужно иметь доступ с любой точки программы, то Вам нужно один раз определить этот экземпляр (больше, конечно же, не получится, ODR. Определить — написать полное имя типа, указав имя переменной в одной единице трансляции), а перед использованием объявить, предварительно указав, что переменная (экземпляр) является «внешней» (extern) по отношению к текущей единице трансляции (обычно, это отдельный .cpp файл после препроцессора).

В итоге, у Вас есть, грубо говоря, 2 единици трансляции (blah.c, main.c). Нужно определить переменную в любой из них (в точке, конечно же, когда тип переменной определён, а не объявлён). И, для удобства (чтобы потом просто подключать заголовочный файл, а не каждый раз писать одно и то же) объявить переменную в blah.h, и подключая blah.h в любой, нужный .cpp файл, использовать её. Т.е.:

1. // blah.h
2.  
3. #ifndef BLAH_H
4. #define BLAH_H
5.  
6. // Объявляем и определяем тип (можно только объявить, а определить в другом месте)
7. struct blah
8. {
9.     int value;
10. };
11.  
12. // Объявляем переменную, указав, что она определена в другом месте
13. // (Поскольку в данной точке мы имеем полное определение типа,
14. // можно объявить blah_test типа struct blah, а если бы определение
15. // находилось в другом месте (т.е. имели бы просто struct blah; выше), то пришлось бы
16. // объявлять указатель на struct blah, т.е. struct blah*)
17.  
18. extern struct blah blah_test;
19.  
20. #endif
21.  
22. // ---------------------------------
23. // blah.cpp (blah.c)
24.  
25.  
26. #include "blah.h"
27.  
28. // Определяем переменную
29. struct blah blah_test;
30.  
31. // ---------------------------------
32. // main.cpp (main.c)
33.  
34. // Подключая заголовочный файл, объявляем переменную,
35. // которую хотим использовать.
36. #include "blah.h"
37.  
38. int main()
39. {
40.     // Используем
41.     blah_test.value = 0;
42.  
43.     return 0;
44. }
45.  
46.  

Comments

[Door]

И демонстрация второго варианта (blah.cpp можно выбросить и определить переменную в main.cpp):

1. // blah-declaration.h
2.  
3. #ifndef BLAH_DECLARATION_H
4. #define BLAH_DECLARATION_H
5.  
6. // Объявляем тип
7. struct blah;
8.  
9. // Объявляем переменную, указав, что она определена в другом месте
10. // (Поскольку в данной точке мы имеем НЕ полное определение типа,
11. // объявляем указатель - это всё, что возможно сделать)
12.  
13. extern struct blah* blah_test;
14.  
15. #endif
16.  
17.  
18. // -----------------------------
19. // blah-definition.h
20.  
21. #ifndef BLAH_DEFINITION_H
22. #define BLAH_DEFINITION_H
23.  
24. // Определяем тип
25. struct blah
26. {
27.     int value;
28. };
29.  
30. #endif
31.  
32. // -----------------------------
33. // blah.cpp
34.  
35. #include "blah-definition.h"
36.  
37. // Определяем переменную
38. struct blah* blah_test = new struct blah;
39.  
40. // -----------------------------
41. // main.cpp
42.  
43. // Заголовочные файлы - для удобства
44. #include "blah-definition.h"
45. #include "blah-declaration.h"
46.  
47. // на самом деле мы можем снова всё написать
48. //struct blah
49. //{
50. //    int value;
51. //};
52. //
53. //extern struct blah* blah_test;
54.  
55. int main(int argc, char* argv[])
56. {
57.     // Используем
58.     blah_test->value = 0;
59.  
60.     delete blah_test;
61.     blah_test = NULL;
62.  
63.     return 0;
64. }
65.  
66.  
67.  

Answer 3

[Osmin]

В blah.h должен быть define-guard. Т.е. в начало надо добавить:

#ifndef BLAH
#define BLAH

А в конец:

#endif

Comments

[Atilla]

Всё равно test_blah будет определён 2 раза. #ifndef спасает от двойного подключения только в пределах одного файла.

[Osmin]

Ниже ответ получше, надо использовать extern.

[Atilla]

Да-да я уже прочитал. И отметил как ответ (MikhailEdoshin написал по сути то же самое, что и Door).

Answer 4

[AxisPod]

В голом C использовать extern, в C++ синглтон.