Использую Keil....

Есть переменная a. Теперь каким-то образом хочу указатель на int "b" не просто определить как адрес переменной "а", а используя некое константное выражение:



Но компилятор выдает ошибку типа "не константное выражение". Но я то знаю, что константное.

Что делать? Вариант проинициализировать этот указатель b перед использованием отпадает, т.к. он уже используется)

P.S. Это мне нужно для побитовых операций с некоторыми переменными в STM32F1xx.

Непонятно, как уже используется?

Вы можете на этапе компиляции сказать, по какому адресу живёт a? Вот и компилятор не может.

"П-п-прведи". (С)
Если что-то до такой степени мешает инициализировать b перед первым использованием, напишите свой init().

Ничченепонимаю. Ты можешь словами объяснить, куда должен указывать b?

Я вас запутал. Имел в виду, что вариант этот уже используется.

Я не могу, а keil может. Например, определение: "u32 *b = (u32*)(((u32)(&a) - 0x40000000) + 0x42000000);" работает. А вот стоит добавить что-то сложнее вычитания или сложения, то ошибка.Я свой инит итак использую, но это не по феншую, и я думаю, что есть более хитрое решение.


b должен указывать туда, куда мы определим с помощью мегаформулы из адреса &а. Если конкретно, то в моем случае b указывает на начало a в битбенд области ОЗУ.

Мисье знает толк в извращениях )))

Вы может быть более конкретно бы описали суть решаемой Вами задачи? может быть окажется, что и не нужно всё это....

Почитайте стандарт (или любую книжку по Си).
С указазателями можно выполнять ТОЛЬКО следущие операции:

• & - взятие адреса
• * - взятие значения
• присвоение указателей
• сложение/вычитание указателя и целого числа
• сравнение указателей
• присвоение нуля и сравнение с ним
• Может что еще забыл!?!?

И ВСЕ!!!!
В этом списке нету ни умножения, ни деления, ни даже возведения в степень.
А теперь посмотрите на свой код и скажите какая операция лишняя??

В рунтайме любые операции работают. На этапе компиляции ограниченное кол-во.

Какие операции "не работают" на этапе компиляции в примере ТС ? Я понимаю, что значение адреса переменной на этапе компиляции неизвестно, будет определено позже линковщиком, а в примере ТС значение этого адреса на что-то там умножается... В общем, я бы с Вами согласился, о том, что не все операции "работают" при компиляции, но (!) давайте упростим пример ТС до такого
Что мы видим? Компилятор считает это неконстантным выражением. Пробуем найти: какая часть этого выражения - "не константа" с точки зрения компилятора?
Здесь всё нормально. Выходит, что преобразование u32 в указатель делает выражение неконстантным? Пробуем:
Тоже - всё нормально. Так почему же не "работает" u32 * b = (u32 *)( (u32)(&a) ) ? Кто может объяснить?

P.S. А, таким образом извращатся с адресами я бы ТС не рекомендавал - нужно искать друкое решение Вашей залачи.

Не работает умножение 32. А пример u32 * b = (u32 *)( (u32)(&a) ); работает в keil.


С помощью этой формулы я получаю адрес начала структуры флагов в битбенд области ОЗУ. И обращаюсь к каждому флагу в отдельности. На данный момент это очень оказалось кстати. Например, раньше я работал с флагами через маски или флаги делал 8битными. И к этом флагам добавлял флаги "занятости флагов", дабы не произошло ошибок чтения-модификации-записи. А с битбендом отказался от всего этого. Никаких масок и проблем.

Сейчас адрес начала флагов в битбенд области ОЗУ расчитываю в функции инициализации флагов. и к любому флагу обращаюсь так: и все замечательно работает.

Думал, что есть какая-нибудь фишка keil, так сказать какой-нибудь атрибут или прагма, чтобы можно было без всякой инициализации определить этот указатель

У меня все работает. Компилируется без ошибок. Правда не в Keil.
И синтаксически это правильное выражение.

Для ТС.
Уберите умножение из выражения работы с указателями. Ни один компилятор не должен поддерживать операцию умножения с указателями.

Нашел еще одно решение) Тупо заставил запихнуть мои флаги по конкретному адресу ОЗУ 0x20004000 и на калькуляторе рассчитал адрес зеркала в бидбенд области = 0x220C8000. Но это опять не по феншую

У вас в начале топика в корне не правильная формула расчета

д.б. примерно так:


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

Если же вы хотите задать значение "b" на этапе компиляции, то возможно вам надо расположить "a" по строго определенному адресу. Для этого изучайте директивы линковщика и компилятора.

Я бы на месте компилятора такое глотать не стал , хотя в IAR тоже работает, вернее компилится, а работает или нет не проверял.

Это, вообще говоря, не компиляторово дело, а линкерово. Компилятор и &a может только записать как «а туда затолкай адрес вон того» (особенно при extern u32 a).
Если линкер не позволяет задать ему сложные выражения (из известных на этапе линковки величин!), то ничего и не выйдет.

В режиме С++ катит и строка из корневого сообщения -- компилятор просто создаст функцию-инициализатор для b и затолкает её в таблицы на правах конструктора.

Ах, вон оно что! В Keil... А, я то - попробовал в IAR для AVR... И, кстати, - не работает и в таком, упращенном примере.

ARMовый 6-й IAR компили-т без умножения...

Все тут пишут, что умножение указателей не поддерживается... оно то, конечно, верно, но ведь ТС пытается сначала привести адрес к u32, потом выполнить все действия и привести результат к указателю.
Ситуация с константностью выражения более-менее понятна, но вот где тут операции с указателями? Мне пока не ясно.

P.S. придерживаюсь мнения, что ТС должен пректатить все эти извращения и найти более православный способ сделать то, что он хочет.

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

Ааа, ну да! Вообще-то логично, что считать должен уже линкер, который знает адрес. И он не обязан уметь делить и умножать. Согласен.

не только к Вам, а к общественности - а ведь действительно, линкер ТОЛЬКО собирает?
ни разу не приходилось разбирать obj файлы, линкер собирает из них только то, что уже явно указано в размещении, без каких-либо вычислений?

Конечно же - вычисляет. Вычисления, само-сабой, без наворотов.

я и говорю - относительные размещения
не вычисляет же выражения... компилятору - компиляторово

Хехе, а интересный же вопрос, а! Особенно вариант как у ТС, когда указатель преобразовывается в int и пошло-поехало...
И, судя по отзывам, разные компиляторы по разному ведут себя.. А как правильно?
Ну и интереснее всего тут именно роль линкера.

Сейчас подойдет товарищ из Риги и всем всё объяснит.

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

UPD

Хорош прикалываться. Не дай Бог чего

Да. Я тоже о нём подумал)))))

А что в выражении u32 * b = (u32 *)( (u32)(&a) ) вы считаете извращением? Я таким уже давно пользуюсь и успешно.
Насчет неправильной формулы - это я случайно когда писал тут вставил адрес периферии, для которой, кстати, я также через битбенд флаги всякие юзаю.




Сейчас временно сделал во так:Ну и соответственно на асме это выглядит так:

Куда меньше чем при использовании масок и т.п.

Лично я всегда думал, что изобилие в коде приведений к типу - есть признак не совсем корректного использования возможностей языка...
Нет сомнений в том, что это работает, однако же не исключено, что смена дизайна позволит существенно упростить какие-то вещи.
Мне сложно предложить что-то конкретное, т.к. я не вижу картину целиком, но мне точно не очень нравится видеть такое Ну точно же можно заставить компилятор всё это сделать автоматически. Например, если у вас в массиве структуры с полем флаг, то почему бы не писать строкой выше вычислить номер структуры, если требуется получить её из общего номера флага, например..
Это всего-лишь догадка, т.к. я пока не совсем понял, что конкретно должен сделать Ваш код. Просто идея в том, чтобы использовать возможности языка, а не просто манипулировать указателями, на всю катушку пользуясь тем, что язык и это позволяет.
Как-то так, в общем ))

P.S. Очень жаль, что не удастся следить за дискуссией дальше Ближайшие пару дней буду трястись в поезде....

Читаете что я пишу? Всякие там вычисления номера структуры и номера флага в ней раньше как-раз и использовались. А используя битбендинг все превратилось в одну строку на С. При этом использую макрос #define MB_FLAG_SET(a) (*(u32*)(MB_Addr_BB_Coils + a*4) = 1). Ну и что тут не нравится? Зря вы так боитесь приведения типов. Язык не то что "позволяет", а обязан такое позволять. Я к примеру ненавижу использовать union.

Можно использовать макроопределение такого вида (и пример применения):

Но лучше задать атрибут для структуры из битовых полей, и Keil сам будет обращаться к битам через bit-band

Да, у меня уже используется что-то подобное : А тут понадобилось обращаться к флагам именно по номеру . Еще в марте modbus поднял, тут в пятницу за час до момента Х решил ченить соптимизировать)
ViKo, я писал умножение на 32 и сдвиг на 5. Одинаково выходит, оптимизирует как надо.

Формат ELF (не знаю, что там используется в IAR и Keil, но подозреваю, что именно он) поддерживает весьма ограниченные операции над адресами (на link time) - только адрес +/- константа. Никакой другой арифметики не поддерживается