Не знаю в какой раздел форума написать, пишу сюда.
Хочется иметь тип данных гибкого размера, с размером, зависящим от значения некоего define.
Т.е. - например:
VAL_X_MAX - максимальное значение, которое может принимать некоторая переменная x.
если: 0 <= VAL_X_MAX < 256, то переменная x должна объявиться размером == байт;
если: 256 <= VAL_X_MAX < 32768, то переменная x должна объявиться размером == 16 бит;
и т.п.

Попытался сделать что-то типа:

чтобы можно было объявить переменную:
static flexType(u, 54) x;
где: 54 - макс. значение которое может принимать x
Но препроцессор упорно не хочет полностью вычислять выражение и доводить его до u8
останавливается на:
static ((54) < 0x00000100) ? u8: ((54) < 0x00010000) ? u16: ((54) < B32) ? u32: u64) x;

Интересно - есть-ли какие другие способы?
Конечно можно с помощью #if/#else/#endif, но эту конструкцию придётся городить для каждой такой переменной, а хотелось бы 1 раз определить макрос, а потом его использовать, записывая объявления кратко.

ЗЫ: Компилятор - IAR for ARM 7.20.

Что за глупости? Только безумец не знает, что число 54 можно хранить в 8-битной переменной. Зачем для этого хитрый макрос?
Ну а если в порядке изучения языка Си в плане возможностей препроцессора, то нет, ничего не получится. Читайте книжки, в которых написано, как работает препроцессор. Там всё просто и понятно.

Блин...
Так понятнее?
Чтобы потом, если вдруг потребуется изменить кол-во обрабатываемых событий, не потребовалось лазить по всему коду и менять размер всех переменных, размерность которых зависит от MAX_EVENTS.
И конечно имеются массивы типа flexType(u, MAX_EVENTS)

Это всё достигается стандартными средствами. Для того чтобы не требовалось лазить по коду и менять, придуманы макросы и typedefы:

Если хочется минимальный размер типа, то достаточно добавить assert:

Если сработает assert, то достаточно будет скорректировать код в одном месте (typedef). Ничего страшного, руки не отвалятся.

Ну да, можно так. Но хочется чтобы всё автоматом собиралось само. У меня есть сейчас массив структур, в котором несколько элементов могут хранить некие значения. Максимальное значение для
каждого из них задаётся соответствующим define. Все они около 100..200 сейчас. Но завтра возможно придётся один или несколько из них сделать больше.

PS: Из реальных вариантов пока вижу только кувалдой в лоб - прописать массив:


На 8 и 16 бит хватит. Если компилятор потянет такое кол-во констант

На c++ это делается просто. Вот ссылка по теме. (Там и на си есть решение, но только для типов не меньше int).

На плюсах можно копать в сторону templates и traits. Несколько лет назад подобное (подобное - в смысле, генерация типа в зависимости от условий) делал для оптимизации типа, передаваемого в функцию. Там если размер передаваемого объекта был меньше 4 байт, то передавался обычный тип (а объект - по значению), а если больше - то константная ссылка. Подробностей не помню. Но, в общем, traits как раз для подобных целей и предназначены.

Хотелось-бы обойтись без плюсов и их шаблонов. Силами си-препроцессора.

напишите свой препроцессор, который перед билдом будет исходники шерстить и подменять слова - типы. Можете написать его на С

При написании меню мне понадобилось статически менять тип переменной. Для инициализации.
Задача не совсем Ваша, но может посмотрите и что-то заимствуете ...
Объявление:

Применение


И примерно аналогично... ещё пример приведу ... в бутлоадере
Правда не я писал

А что кстати дает такой тип кроме путаницы и зоопарка дефайнов?

в чем разница между




и



если вопрос в том чтобы не считать сколько нужно для хранения 54, ну можно табличку завести в экселе, например....

ведь если есть MAX_EVENTS, то вы ее ровно в тех местах где она используется ровно нужное число раз напишите, так же как вы напишите MY_TYPE. Меняется в одном месте в начале программы, тайпдефов будет столько сколько уникальных типов, ровно столько сколько у вас было бы дефайновых макс_евантов. В тех местах где вы размер задаете не через дефайн, а явно, можно поставить прямой тип.


Ну и опять же если все структуры и все плавает по размерам, съезжают протоколы, ИМХО только путаница....





чет между объявлением и применением я не нашел корреляции %(

Давайте упростим.
Объявлен следующий тип:

Далее объявляется следующая переменная

То есть на этапе инициализации выбирается её тип.

Я не проверял что будет, если я объявлю например данную конструкцию
typedef union
{
int8_t i8;
int16_t i16;
int32_t i32;
float f;
} variant_t;

а при объявлении скажем сделаю
const variant_t min = {.i8 = 19};

Сколько будет выделено памяти?
Скорее всего будет выделено по максимуму.

понятно, ну тогда можно и так

char AbstractData[8];

*((int *)AbstractData) = 10;
*((float *)AbstractData) = 15.43;
*((char *)AbstractData) = 'a';

как я понимаю все метания автора не выделить памяти больше чем надо, А то так все можно было лонгами покрыть и всех делов....


кстати вот здесь

интересный вопрос что будет если обратиться к ней потом по неправильному полю...

такого рода заморочки в структурах надо конечно через void * решать. делать указатель воид, и по какому то признаку правильно к нему обращаться,а юнионы тут излишни ИМХО

И во-первых огрести все проблемы с выравниванием на отличных от AVR архитектурах, а во-вторых - загадить исходник явными приведениями типов. Тяжелое ассемблерное детство...
Почему именно так? Чем это лучше варианта с union (намекаю на выравнивание и загаживание исходников явными приведениями)? А если надо хранить uint64_t, когда указатель на void занимает 32 бита?