Технический приём для формирования согласованных данных

Evg · Регистрация: 30.03.2009

Студворк — интернет-сервис помощи студентам

Кому-то может пригодиться

Если нет чёткого представления о том, как работает препроцессирование, то смотрим сюда (про директиву #include) и сюда (про директиву #define)

Допустим, нужно сделать две согласованных конструкции

C
1
2
3
4
5
6
7
8
9
10
11
12
13
enum
{
  ENUM_VAL1,
  ENUM_VAL2,
  ENUM_VAL3,
};
 
char *names[] =
{
  "VAL1",
  "VAL2",
  "VAL3",
};

При этом элемент enum'а является индексом в массив, для доставания соотвествующего строкового значения. Если нам нужно что-то добавить, то надо править в двух местах, которые, как правило в разных файлах. А когда файлы большие и подобных данных много, то можно запутаться. Если изменить только enum (особенно если добавить элемент в середину), то names станет несогласованным.

А потому нужно такое решение, чтобы каждый элемент условно задавался одной строкой, чтобы во все места подставились нужные данные. Для этого делаю дополнительный файл. У меня он имеет расширение *.def, но это непринципииально (у gnu'шников он *.def, а потому я тоже так делаю, чтобы как у людей было)

В итоге получается такая штука

C
1
2
3
4
5
6
7
8
9
10
11
12
13
enum
{
#define DEF_ELEM(p1,p2) p1,
#include "file.def"
#undef DEF_ELEM
};
 
char *names[] =
{
#define DEF_ELEM(p1,p2) p2,
#include "file.def"
#undef DEF_ELEM
};

C
1
2
3
4
/* Файл file.def */
DEF_ELEM (ENUM_VAL1, "VAL1")
DEF_ELEM (ENUM_VAL2, "VAL2")
DEF_ELEM (ENUM_VAL3, "VAL3")

В итоге после подстановки директив #include на этапе прероцессирования получаем файл

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
enum
{
#define DEF_ELEM(p1,p2) p1,
DEF_ELEM (ENUM_VAL1, "VAL1")
DEF_ELEM (ENUM_VAL2, "VAL2")
DEF_ELEM (ENUM_VAL3, "VAL3")
#undef DEF_ELEM
};
 
char *names[] =
{
#define DEF_ELEM(p1,p2) p2,
DEF_ELEM (ENUM_VAL1, "VAL1")
DEF_ELEM (ENUM_VAL2, "VAL2")
DEF_ELEM (ENUM_VAL3, "VAL3")
#undef DEF_ELEM
};

Теперь смотрим, как макросы подстанавливаются

C
1
2
#define DEF_ELEM(p1,p2) p1,
DEF_ELEM (ENUM_VAL1, "VAL1")

раскроется как

C
1
ENUM_VAL1,

а

C
1
2
#define DEF_ELEM(p1,p2) p2,
DEF_ELEM (ENUM_VAL1, "VAL1")

раскроется как

C
1
"VAL1",

В итоге весь файл после препроцессирования окажется вот таким

C
1
2
3
4
5
6
7
8
9
10
11
12
13
enum
{
ENUM_VAL1,
ENUM_VAL2,
ENUM_VAL3,
};
 
char *names[] =
{
"VAL1",
"VAL2",
"VAL3",
};

Такми образом инициализаторы от двух разных конструкций у на оказываются в одной строке. Добавление новых элементов о\существляется только в файл *.def

@Taky · 21.08.2009, 09:16

Класно

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

Evg · 21.08.2009, 11:40 **[ТС]**

Я под линухом работаю с командной строкой. Как это в студиях делается - не знаю

@CheshireCat · 21.08.2009, 12:24

Сообщение от Evg

При этом элемент enum'а является индексом в массив, для доставания соотвествующего строкового значения. Если нам нужно что-то добавить, то надо править в двух местах, которые, как правило в разных файлах. А когда файлы большие и подобных данных много, то можно запутаться. Если изменить только enum (особенно если добавить элемент в середину), то names станет несогласованным.

Мммм........ Любопытно, конечно. Но должен признаться: не люблю макросы. Поэтому возник вопрос: что мешает сделать проще? Например:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
enum MY_ENUM
{
    ENUM_VALUE_1 = 0,
    ENUM_VALUE_2,
    ...
    ENUM_VALUE_N,
    NUM_VALUES      // <-- число значений
};
 
const char* const strings[] =
{
    "строка 1",
    "строка 2",
    ...
    "строка N"
};
 
#include "boost/static_assert.hpp"
 
BOOST_STATIC_ASSERT(sizeof(strings) / sizeof(strings[0]) == NUM_VALUES);

@IT_Exp · 21.08.2009, 12:29

что мешает сделать проще? Например: ...

или даже так:

C++
1
2
3
4
5
6
7
8
9
10
#include <boost/assign/list_of.hpp>
using boost::assign::map_list_of;
 
enum MY_ENUM = ...
 
const std::map<MY_ENUM, std::string> strings = map_list_of
    (ENUM_VALUE1, "строка 1")
    (ENUM_VALUE2, "строка 2")
    ...
    ;

Evg · 21.08.2009, 12:33 **[ТС]**

CheshireCat, Можно перепутать местами два элемента. По количеству будет согласовано, по начинке - нет

Rififi, на Си такого нет. Вернее на современных расширениях это можно сделать. Но проблема остаётся та же самая. Тебе нужно иметь 10 согласованных величин и тебе надо будет править в 10 местах в различных файлах. Особенно это проблемно в чужих исходниках (эти места ещё найти надо). Особенно если нет примитивного статического контроля, о котором написал CheshireCat

@IT_Exp · 21.08.2009, 12:38

Evg,
Откуда 10 мест, править надо лишь в одном месте - при объявлении карты.

@CheshireCat · 21.08.2009, 12:41

Вариант, предложенный коллегой Rififi, конечно же, тоже возможен и имеет право на жизнь. В нем только есть неприятный "подводный камень": если сама эта std::map и какая-либо функция, обращающаяся к ней, расположены в разных единицах компиляции, то эффект может быть феерическим (в смысле, может привести к большому "ба-бах!").

@IT_Exp · 21.08.2009, 12:43

может привести к большому "ба-бах!"
каким образом?

Evg · 21.08.2009, 12:56 **[ТС]**

Сообщение от Rififi

Evg,
Откуда 10 мест, править надо лишь в одном месте - при объявлении карты.

В твоём случае по крайней мере в двух местах - в enum'е и при объявлении map'а

@CheshireCat · 21.08.2009, 13:50

Сообщение от Rififi

может привести к большому "ба-бах!"
каким образом?

Потому, что эта самая std::map - не "настоящая" константа с compile-time initialization (CTI), а является всего-лишь обычной неизменяемой переменной с run-time initialization (RTI). Порядок же инициализации переменных, определенных в разных единицах компиляции, не определен, и к чему может привести обращение к неинициализированной переменной - сам знаешь.

Вот код, который успешно собирается под MSVC++ 2005 и так же успешно "падает", если определен дефайн DO_BABAH (в constants.h), и успешно работает, если дефайн не определен. Код, конечно, намеренно грубый и упрощенный, но он предназначен именно для того, чтобы проиллюстрировать проблему. Имена файлов именно такие преднамеренно

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
//-------- constants.h ----------
#ifndef __CONSTANTS_H__
#define __CONSTANTS_H__
 
enum MY_ENUM
{
    ENUM_VALUE1,
    ENUM_VALUE2
};
 
#define DO_BABAH
 
#endif //__CONSTANTS_H__
 
 
//-------- A.cpp -----------
#include <string>
#include <iostream>
#include <map>
#include "Constants.h"
 
const std::map<MY_ENUM, std::string>& get_strings();
 
//----------------------------------------------------
#ifndef DO_BABAH
#include "boost/assign/list_of.hpp"
using boost::assign::map_list_of;
 
const std::map<MY_ENUM, std::string> strings = map_list_of
    (ENUM_VALUE1, "this is string 1")
    (ENUM_VALUE2, "this is string 2")
;
 
const std::map<MY_ENUM, std::string>& get_strings()
{
    return strings;
}
#endif // DO_BABAH
//----------------------------------------------------
 
class String
{
    std::string _value;
 
public:
    String(MY_ENUM _enum)
    {
        const std::map<MY_ENUM, std::string>::const_iterator it = get_strings().find(_enum);
        if (it != get_strings().end())
            _value = it->second;
    };
    std::string get() const { return _value; }
};
 
String s1(ENUM_VALUE1);
String s2(ENUM_VALUE2);
 
int main()
{
    std::cout << s1.get() << std::endl << s2.get() << std::endl;
}
 
 
//-------- B.cpp -----------
#include "Constants.h"
 
#ifdef DO_BABAH
 
#include <map>
#include "boost/assign/list_of.hpp"
using boost::assign::map_list_of;
 
const std::map<MY_ENUM, std::string> strings = map_list_of
    (ENUM_VALUE1, "ñòðîêà 1")
    (ENUM_VALUE2, "ñòðîêà 2")
;
 
const std::map<MY_ENUM, std::string>& get_strings()
{
    return strings;
}
 
#endif  // DO_BABAH

@#pragma · 01.09.2009, 20:58

Кстати,для С++ придётся использовать небольшой "костыль",хотя в принципе это не так страшно.После последней переменной перечислимого типа не должно быть запятой,поэтому,похоже,придётся сделать что-то вроде этого:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
enum
{
#define DEF_ELEM(p1,p2) p1,
#include "file1.def"
#undef DEF_ELEM
#define DEF_ELEM(p1,p2) p1
#include "file2.def"
#undef DEF_ELEM
};
 
char *names[] =
{
#define DEF_ELEM(p1,p2) p2,
#include "file1.def"
#undef DEF_ELEM
#define DEF_ELEM(p1,p2) p2
#include "file2.def"
#undef DEF_ELEM
};

В файле номер два лежит только последняя переменная.

@#pragma · 02.09.2009, 03:55

Есть такая мысль,не знаю,насколько это хорошо или плохо:
Можно в одном файле объявлять все типы данных (всё что нужно)для всех модулей(единиц трансляции),но включением этих данных оперировать в самих файлах .cpp с помощью #define.То есть получим концентрацию данных в одном файле,не теряя модульности,сокрытия данных.

@CheshireCat · 02.09.2009, 12:49

Брррр! Это еще хуже. Потому что через год-два (а иногда может сложиться и так, что через пять-восемь или больше) программист, которому "по счастливому стечению обстоятельств" придется поддерживать этот код и буквально продираться с боем через весь этот частокол накопленных за многие годы #define'ов, наградит вас весьма разнообразными (и далеко не приятными) эпитетами......

Джон Роббинс писал (хотя не ручаюсь за точность цитаты): "Пишите Ваш код так, как будто тот, кто будет его поддерживать - опасный психопат, знающий, где Вы живете."

@schdub · 03.09.2009, 00:56

Не по теме:

"Пишите Ваш код так, как будто тот, кто будет его поддерживать - опасный психопат, знающий, где Вы живете."

:)

похожая статья от Дмитрия analizer Потапова
http://www.quizful.net/post/enum-types-c

Evg · 28.05.2010, 20:07 **[ТС]**

Волей случая меня опять занесло в эту тему, а потому отвечу на то, что в своё время так и не прочёл

Сообщение от Rififi

[I]что мешает сделать проще? Например: ...

Вот тебе реальный пример из моей практики. Писал когда-то ассемблер и дизассемблер для БК-0010. Вот фрагмент описания, сделанного по этой технологии. При помощи этого описания формировался один enum и инициализировалось 4 массива, находящиеся в разных исходниках, к тому же часть из них попадало только в ассемблер, а часть - только в дизассемблер, а часть входило и туда и сюда. Через map по-моему запаришься так писать

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
DEFINE_OPER  (OPER_NONE,  NULL,    0,             0,        0)
 
/*            +- enum name
 *            |
 *            |           +- symbol name
 *            |           |
 *            |           |        +- lex kind
 *            |           |        |
 *            |           |        |              +- opcode
 *            |           |        |              |
 *            |           |        |              |        +- mask
 *            |           |        |              |        |
 */
 
/* One operand commands */
 
DEFINE_OPER  (OPER_CLR,   "clr",   COMMAND_ARG1,  0005000,  0177700)
DEFINE_OPER  (OPER_CLRB,  "clrb",  COMMAND_ARG1,  0105000,  0177700)
DEFINE_OPER  (OPER_COM,   "com",   COMMAND_ARG1,  0005100,  0177700)
DEFINE_OPER  (OPER_COMB,  "comb",  COMMAND_ARG1,  0105100,  0177700)
DEFINE_OPER  (OPER_INC,   "inc",   COMMAND_ARG1,  0005200,  0177700)
DEFINE_OPER  (OPER_INCB,  "incb",  COMMAND_ARG1,  0105200,  0177700)
DEFINE_OPER  (OPER_DEC,   "dec",   COMMAND_ARG1,  0005300,  0177700)
DEFINE_OPER  (OPER_DECB,  "decb",  COMMAND_ARG1,  0105300,  0177700)
DEFINE_OPER  (OPER_NEG,   "neg",   COMMAND_ARG1,  0005400,  0177700)
DEFINE_OPER  (OPER_NEGB,  "negb",  COMMAND_ARG1,  0105400,  0177700)
DEFINE_OPER  (OPER_ADC,   "adc",   COMMAND_ARG1,  0005500,  0177700)
DEFINE_OPER  (OPER_ADCB,  "adcb",  COMMAND_ARG1,  0105500,  0177700)
DEFINE_OPER  (OPER_SBC,   "sbc",   COMMAND_ARG1,  0005600,  0177700)
DEFINE_OPER  (OPER_SBCB,  "sbcb",  COMMAND_ARG1,  0105600,  0177700)
DEFINE_OPER  (OPER_TST,   "tst",   COMMAND_ARG1,  0005700,  0177700)
DEFINE_OPER  (OPER_TSTB,  "tstb",  COMMAND_ARG1,  0105700,  0177700)
DEFINE_OPER  (OPER_ROR,   "ror",   COMMAND_ARG1,  0006000,  0177700)
DEFINE_OPER  (OPER_RORB,  "rorb",  COMMAND_ARG1,  0106000,  0177700)
DEFINE_OPER  (OPER_ROL,   "rol",   COMMAND_ARG1,  0006100,  0177700)
DEFINE_OPER  (OPER_ROLB,  "rolb",  COMMAND_ARG1,  0106100,  0177700)
DEFINE_OPER  (OPER_ASR,   "asr",   COMMAND_ARG1,  0006200,  0177700)
DEFINE_OPER  (OPER_ASRB,  "asrb",  COMMAND_ARG1,  0106200,  0177700)
DEFINE_OPER  (OPER_ASL,   "asl",   COMMAND_ARG1,  0006300,  0177700)
DEFINE_OPER  (OPER_ASLB,  "aslb",  COMMAND_ARG1,  0106300,  0177700)
DEFINE_OPER  (OPER_SWAB,  "swab",  COMMAND_ARG1,  0000300,  0177700)
DEFINE_OPER  (OPER_MTPS,  "mtps",  COMMAND_ARG1,  0106400,  0177700)
DEFINE_OPER  (OPER_MFPS,  "mfps",  COMMAND_ARG1,  0106700,  0177700)
 
/* Two operand commands */
 
DEFINE_OPER  (OPER_MOV,   "mov",   COMMAND_ARG2,  0010000,  0170000)
DEFINE_OPER  (OPER_MOVB,  "movb",  COMMAND_ARG2,  0110000,  0170000)
DEFINE_OPER  (OPER_CMP,   "cmp",   COMMAND_ARG2,  0020000,  0170000)
DEFINE_OPER  (OPER_CMPB,  "cmpb",  COMMAND_ARG2,  0120000,  0170000)
DEFINE_OPER  (OPER_BIT,   "bit",   COMMAND_ARG2,  0030000,  0170000)
DEFINE_OPER  (OPER_BITB,  "bitb",  COMMAND_ARG2,  0130000,  0170000)
DEFINE_OPER  (OPER_BIC,   "bic",   COMMAND_ARG2,  0040000,  0170000)
DEFINE_OPER  (OPER_BICB,  "bicb",  COMMAND_ARG2,  0140000,  0170000)
DEFINE_OPER  (OPER_BIS,   "bis",   COMMAND_ARG2,  0050000,  0170000)
DEFINE_OPER  (OPER_BISB,  "bisb",  COMMAND_ARG2,  0150000,  0170000)
DEFINE_OPER  (OPER_ADD,   "add",   COMMAND_ARG2,  0060000,  0170000)
DEFINE_OPER  (OPER_SUB,   "sub",   COMMAND_ARG2,  0160000,  0170000)
 
DEFINE_OPER  (OPER_XOR,   "xor",   COMMAND_R_DST, 0074000,  0177000)
 
/* Control transfer commands */
 
DEFINE_OPER  (OPER_BR,    "br",    COMMAND_CNTR,  0000400,  0177400)
DEFINE_OPER  (OPER_BNE,   "bne",   COMMAND_CNTR,  0001000,  0177400)
DEFINE_OPER  (OPER_BEQ,   "beq",   COMMAND_CNTR,  0001400,  0177400)
DEFINE_OPER  (OPER_BPL,   "bpl",   COMMAND_CNTR,  0100000,  0177400)
DEFINE_OPER  (OPER_BMI,   "bmi",   COMMAND_CNTR,  0100400,  0177400)
DEFINE_OPER  (OPER_BVC,   "bvc",   COMMAND_CNTR,  0102000,  0177400)
DEFINE_OPER  (OPER_BVS,   "bvs",   COMMAND_CNTR,  0102400,  0177400)
DEFINE_OPER  (OPER_BGE,   "bge",   COMMAND_CNTR,  0002000,  0177400)
DEFINE_OPER  (OPER_BLT,   "blt",   COMMAND_CNTR,  0002400,  0177400)
DEFINE_OPER  (OPER_BGT,   "bgt",   COMMAND_CNTR,  0003000,  0177400)
DEFINE_OPER  (OPER_BLE,   "ble",   COMMAND_CNTR,  0003400,  0177400)
DEFINE_OPER  (OPER_BHI,   "bhi",   COMMAND_CNTR,  0101000,  0177400)
DEFINE_OPER  (OPER_BLOS,  "blos",  COMMAND_CNTR,  0101400,  0177400)
DEFINE_OPER  (OPER_BHIS,  "bhis",  COMMAND_CNTR,  0103000,  0177400)
DEFINE_OPER  (OPER_BLO,   "blo",   COMMAND_CNTR,  0103400,  0177400)
 
DEFINE_OPER  (OPER_BCS,   "bcs",   COMMAND_CNTR,  0103400,  0177400)  /* bcs = blo */
DEFINE_OPER  (OPER_BCC,   "bcc",   COMMAND_CNTR,  0103000,  0177400)  /* bcc = bhis */
 
DEFINE_OPER  (OPER_SOB,   "sob",   COMMAND_SOB,   0077000,  0177000)
DEFINE_OPER  (OPER_JMP,   "jmp",   COMMAND_ARG1,  0000100,  0177700)
 
/* Subroutine commands */
 
DEFINE_OPER  (OPER_JSR,   "jsr",   COMMAND_R_DST, 0004000,  0177000)
DEFINE_OPER  (OPER_RTS,   "rts",   COMMAND_RTS,   0000200,  0177770)
DEFINE_OPER  (OPER_RTT,   "rtt",   COMMAND_ARG0,  0000006,  0177777)
 
DEFINE_OPER  (OPER_CALL,  "call",  COMMAND_ARG1,  0004700,  0177700)  /* call arg = jsr pc, arg */
 
/* Interrupt commands */
 
DEFINE_OPER  (OPER_EMT,   "emt",   COMMAND_TRAP,  0104000,  0177400)
DEFINE_OPER  (OPER_TRAP,  "trap",  COMMAND_TRAP,  0104400,  0177400)
DEFINE_OPER  (OPER_IOT,   "iot",   COMMAND_ARG0,  0000004,  0177777)
DEFINE_OPER  (OPER_BPT,   "bpt",   COMMAND_ARG0,  0000003,  0177777)
 
/* No operand commands */
 
DEFINE_OPER  (OPER_HALT,  "halt",  COMMAND_ARG0,  0000000,  0177777)
DEFINE_OPER  (OPER_WAIT,  "wait",  COMMAND_ARG0,  0000001,  0177777)
DEFINE_OPER  (OPER_RESET, "reset", COMMAND_ARG0,  0000005,  0177777)
DEFINE_OPER  (OPER_NOP,   "nop",   COMMAND_ARG0,  0000240,  0177777)
DEFINE_OPER  (OPER_CLC,   "clc",   COMMAND_ARG0,  0000241,  0177777)
DEFINE_OPER  (OPER_CLV,   "clv",   COMMAND_ARG0,  0000242,  0177777)
DEFINE_OPER  (OPER_CLZ,   "clz",   COMMAND_ARG0,  0000244,  0177777)
DEFINE_OPER  (OPER_CLN,   "cln",   COMMAND_ARG0,  0000250,  0177777)
DEFINE_OPER  (OPER_CCC,   "ccc",   COMMAND_ARG0,  0000257,  0177777)
DEFINE_OPER  (OPER_SEC,   "sec",   COMMAND_ARG0,  0000261,  0177777)
DEFINE_OPER  (OPER_SEV,   "sev",   COMMAND_ARG0,  0000262,  0177777)
DEFINE_OPER  (OPER_SEZ,   "sez",   COMMAND_ARG0,  0000264,  0177777)
DEFINE_OPER  (OPER_SEN,   "sen",   COMMAND_ARG0,  0000270,  0177777)
DEFINE_OPER  (OPER_SCC,   "scc",   COMMAND_ARG0,  0000277,  0177777)
 
DEFINE_OPER  (OPER_LAST,  NULL,    0,             0,        0)

Сообщение от #pragma

Кстати,для С++ придётся использовать небольшой "костыль",хотя в принципе это не так страшно.После последней переменной перечислимого типа не должно быть запятой

На самом деле запятая там допускается. Потому как разработчики изначально понимали, что язык будет работать совместно с препроцессором

@#pragma · 28.05.2010, 20:23

>На самом деле запятая там допускается. Потому как разработчики изначально понимали, что язык будет работать совместно с препроцессором
Видимо,у меня это не пполучилось из-за опций компиляции
Кстати,интересная система комментариев для длинных записей..

Evg · 04.09.2014, 17:49 **[ТС]**

Вот альтернативная форма этого же приёма (без дополнительного файла)
Вывести содержимое Enum

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Desktop (MinGW): Рисуем цветные прямоугольники с помощью рисовальщика SDL3 на Си и C++ 8Observer8 17.03.2026 Содержание блога Финальные проекты на Си и на C++: finish-rectangles-sdl3-c. zip finish-rectangles-sdl3-cpp. zip	Символические и жёсткие ссылки в Linux. algri14 15.03.2026 Существует два типа ссылок — символические и жёсткие. Ссылка в Linux — это запись в каталоге, которая может указывать либо на inode «файла-ИСТОЧНИКА», тогда это будет «жёсткая ссылка» (hard link),. . .	[Owen Logic] Поддержание уровня воды в резервуаре количеством включённых насосов: моделирование и выбор регулятора ФедосеевПавел 14.03.2026 Поддержание уровня воды в резервуаре количеством включённых насосов: моделирование и выбор регулятора ВВЕДЕНИЕ Выполняя задание на управление насосной группой заполнения резервуара,. . .	делаю науч статью по влиянию грибов на сукцессию anaschu 13.03.2026 прикрепляю статью
SDL3 для Desktop (MinGW): Создаём пустое окно с нуля для 2D-графики на SDL3, Си и C++ 8Observer8 10.03.2026 Содержание блога Финальные проекты на Си и на C++: hello-sdl3-c. zip hello-sdl3-cpp. zip Результат:	Установка CMake и MinGW 13.1 для сборки С и C++ приложений из консоли и из Qt Creator в EXE 8Observer8 10.03.2026 Содержание блога MinGW - это коллекция инструментов для сборки приложений в EXE. CMake - это система сборки приложений. Здесь описаны базовые шаги для старта программирования с помощью CMake и. . .	Как дизайн сайта влияет на конверсию: 7 решений, которые реально повышают заявки Neotwalker 08.03.2026 Многие до сих пор воспринимают дизайн сайта как “красивую оболочку”. На практике всё иначе: дизайн напрямую влияет на то, оставит человек заявку или уйдёт через несколько секунд. Даже если у вас. . .	Модульная разработка через nuget packages DevAlt 07.03.2026 Сложившийся в . Net-среде способ разработки чаще всего предполагает монорепозиторий в котором находятся все исходники. При создании нового решения, мы просто добавляем нужные проекты и имеем. . .

@Taky 10 / 10 / 5 Регистрация: 25.03.2009 Сообщений: 65
	21.08.2009, 09:16
	Класно Интересный трюк с препроцессором. А не знаешь в студии можно просматривать файлы на выходе из препроцессора, ну грубо говоря проверть как препрыессорные директивы отработали. Когда много инклудов легко запутаться и вылавливать ошибку... 0

Evg 21281 / 8305 / 637 Регистрация: 30.03.2009 Сообщений: 22,660 Записей в блоге: 30
	21.08.2009, 11:40 [ТС]
	Я под линухом работаю с командной строкой. Как это в студиях делается - не знаю 0

Evg 21281 / 8305 / 637 Регистрация: 30.03.2009 Сообщений: 22,660 Записей в блоге: 30
	21.08.2009, 12:33 [ТС]
	CheshireCat, Можно перепутать местами два элемента. По количеству будет согласовано, по начинке - нет Rififi, на Си такого нет. Вернее на современных расширениях это можно сделать. Но проблема остаётся та же самая. Тебе нужно иметь 10 согласованных величин и тебе надо будет править в 10 местах в различных файлах. Особенно это проблемно в чужих исходниках (эти места ещё найти надо). Особенно если нет примитивного статического контроля, о котором написал CheshireCat 0

@IT_Exp MCSD: APP BUILDER 8795 / 1074 / 104 Регистрация: 17.06.2006 Сообщений: 32,602
	21.08.2009, 12:38
	Evg, Откуда 10 мест, править надо лишь в одном месте - при объявлении карты. 0

@CheshireCat 2924 / 1274 / 114 Регистрация: 27.05.2008 Сообщений: 3,465
	21.08.2009, 12:41
	Вариант, предложенный коллегой Rififi, конечно же, тоже возможен и имеет право на жизнь. В нем только есть неприятный "подводный камень": если сама эта std::map и какая-либо функция, обращающаяся к ней, расположены в разных единицах компиляции, то эффект может быть феерическим (в смысле, может привести к большому "ба-бах!"). 0

@IT_Exp MCSD: APP BUILDER 8795 / 1074 / 104 Регистрация: 17.06.2006 Сообщений: 32,602
	21.08.2009, 12:43
	может привести к большому "ба-бах!" каким образом? 0

@#pragma Временно недоступен 957 / 228 / 14 Регистрация: 12.04.2009 Сообщений: 926
	02.09.2009, 03:55
	Есть такая мысль,не знаю,насколько это хорошо или плохо: Можно в одном файле объявлять все типы данных (всё что нужно)для всех модулей(единиц трансляции),но включением этих данных оперировать в самих файлах .cpp с помощью #define.То есть получим концентрацию данных в одном файле,не теряя модульности,сокрытия данных. 0

@CheshireCat 2924 / 1274 / 114 Регистрация: 27.05.2008 Сообщений: 3,465
	02.09.2009, 12:49
	Брррр! Это еще хуже. Потому что через год-два (а иногда может сложиться и так, что через пять-восемь или больше) программист, которому "по счастливому стечению обстоятельств" придется поддерживать этот код и буквально продираться с боем через весь этот частокол накопленных за многие годы #define'ов, наградит вас весьма разнообразными (и далеко не приятными) эпитетами...... Джон Роббинс писал (хотя не ручаюсь за точность цитаты): "Пишите Ваш код так, как будто тот, кто будет его поддерживать - опасный психопат, знающий, где Вы живете." 2

@#pragma Временно недоступен 957 / 228 / 14 Регистрация: 12.04.2009 Сообщений: 926
	28.05.2010, 20:23
	>На самом деле запятая там допускается. Потому как разработчики изначально понимали, что язык будет работать совместно с препроцессором Видимо,у меня это не пполучилось из-за опций компиляции Кстати,интересная система комментариев для длинных записей.. 0

Evg 21281 / 8305 / 637 Регистрация: 30.03.2009 Сообщений: 22,660 Записей в блоге: 30
	04.09.2014, 17:49 [ТС]
	Вот альтернативная форма этого же приёма (без дополнительного файла) Вывести содержимое Enum 0