А самое главное зачем писать неправильную и более длинную конструкцию



вместо короткой и правильной

Хвала Аллаху, что у компиляторописателей голова растет не из ануса, посему на это:

компиляторрописатели IAR:
Error[Pe513]: a value of type "u16 (*)[10]" cannot be assigned to an entity of type "u16 *"

а это для разгообразия PowerCraft:
(139): operands of = have illegal types `pointer to u16' and `pointer to array 10 of u16t'

Реагируют посылкой в анус того, кто так пишет.


Разуваем глаза и смотрим на вышенаписанное.

Не соглашусь, однако.

Но всё-таки она вертится!?
Ведь результат &mass является адресом массива, хоть и с другими атрибутами, чем первый его элемент. Чтобы не париться, его всегда можно присвоить нетипизированному указателю. И это работает не только с массивами, но и с записами, юнионами, функциями и возможно ещё что упустил.
Очень интересная новость после стольких лет...

Если нужен глобальный, то объявляйте максимально возможного размера и не парьтесь. Это будет самый простой и надёжный вариант. Он гарантирует, что памяти хватит на самый большой шрифт, и при этом не использует динамического распределения памяти.
Ведь вам в любом случае нужно иметь память под самый большой шрифт, пусть она сразу и будет выделена.

Более длинная и что важно, тоже правильная конструкция:
char *p = &abc[0];
может быть применена для подчеркивания того факта, что abc это массив. Иногда такое бывает удобно при быстром чтении.

Ну ну. Сегодня шрифт такой, завтра шеф (заказчик) запросит другой. Ну хоть проверку на размерность массива вставьте!

Что значит "вертится" и "является адресом", если компиляторы ВЫВАЛИВАЕТСЯ с ошибкой и соответственно НЕ генерят никакого кода?
Кто здесь пытается вертеться, как уж на сковородке, видно невооруженным взглядом .

Это не работает. Как там было у Задорнова - "Пива нет. СОВСЕМ нет!" - СОВСЕМ не раболтает. О чем я сразу и написал увидя этo:

Именно ЭТО увидел и именно об ЭТОМ а не чем-то другом написал.

:-))) Цитата из Вашей ссылки



По моему Вы и zltigo сомневались и учебники читать отправляли.

Это смотря какой вопрос. То, что было изначально у ТС я не утверждал, что компилируется (вообще). Но то, что амперсанд можно применять ко многим объектам, включая массивы, и результат будет предсказуем, то бишь равен адресу объекта - я ещё раз повторяю. Если я уж, то сижу спокойно, в центре сковородки

Вы это к чему? Там же ниже прямо написано



Чего вы мне хотели сказать?

Вы о чём? Речь идёт о задании размера во время компиляции/линковки. Если не хватит памяти под новый шрифт, то линкер обругается, вот и проверка.

Преобразования типов нет. СОВСЕМ НЕТ! © zltigo
С сегодняшнего дня типизированные указатели не могут присваиваться к другим типизированным указателям. Аминь.

Upd.
zltigo, Вы верите, что void *p можно присвоить адрес любого типа? Даже так p = &mass. Это что, незаконно? СОВСЕМ?
Вобщем если пива нет, но очень хочется, то пиво есть

Звиняюсь, & операцию у ТС не увидел :-(

Уважаемый. Вы понимаете про что говорите? Статический массив автору был нужен для копирования тела символа. Где гарантия, что в другом шрифте, символы "влезут" в этот массив? Кто мешает использвать шрифт, с меньшим количеством используемых символов (т.е. сам шрифт может быть компактнее), но при этом сами символы крупнее. И что вам тут линкер скажет? Странное это программирование, основанное на предположениях и утверждениях "и так катит".

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

Это вы придумали такой вариант реализации системы, где шрифты подключаются на этапе сборки проекта. Откуда мне и вам знать, может они на SD карточке лежат?

А в чем грубость то? Объясните старику. Да, и не плохо бы примерчик, где линкер ругается на размер массива, в который вы собираетесь что то копировать.

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

sasamy, поддержу.

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


Фу-ты ну-ты. Я что, должен вас пожалеть? Давайте, раз вы старик, вы будете читать мои сообщения два раза, прежде чем отвечать на них, хорошо? И свои перед отправкой - тоже читайте. Потому что иначе получаются наезды не по существу.



(предвидя придирки - на mega8)

http://chitay.org/c/04/0409.htm
upd. и еще оттуда
http://chitay.org/c/11/1105.htm

http://www.keil.com/support/man/docs/armcc...ef_bcfgjjhf.htm

Хватит пытаться вертеться, о присвоении указателя на void. Речь не шла. Когда Вы пытаясь, как Вам кажется, "изящно" выкрутиться ПОДМЕНИЛИ в исходном тексте указатель на short указателем на void, я Вам сразу указал на это, Вы начали передергивать подсовывая другой заведомо глотаемый сишным компилятором вариант.

Да, тогда такие, как Вы насцав а бокал делаете вид что лично Вы пьете пиво . Все. Точка, шулер Вы наш .



Со стеком или любым другим ДИНАМИЧЕСКИМ выделением памяти проблем, совершенно нет по определению. Единственно, что выделять фиг знает какой объем памяти в стеке явно не кошерно, посему остается естественное и контролируемое на ошибки динамическое выделение памяти из heap. Другое дело, что все идет к тому, что для данного случая просто все надо делать на лету, а не бездумно трясти пальму.

Ничё не сделал, только вошёл И сразу мошенник.

Себя почитайте

Вы заявили, что амперсанд применительно к массиву без индекса является бессмысленной операцией. Я же подправил, что она осмысленная, но малость не соответствует по типу указателя. Нельзя же так относиться к мелким ошибкам ТС - бред, бред! УЖАС, УЖАС, УЖАС!

Не, для Вас, поскольку Вы даже не шулер, который таки-боится получить в реале канделябром по голове, а просто моральный урод . Я себя почитаю:

не имеет право даже быть откомпилированной.
Ибо бред. И тут уж либо так
ptr_buffer = &Buffer[0];
либо так:
ptr_buffer = Buffer;





После этого GetSmart таки сам проверил и получив, как и было обещано отлуп о компилятора
Начал жульничать, заменив как ни всем ни бывало uint_16 *ptr_buffer на void *



На что ему было сразу указано:



То, что думают компиляторы было продемонстрировано:


Дальше GertSmat, ведет себя совершенно ожидаемо и традиционно, как известной русской присказке про божью росу.
Надоело.


Приходится напоминать, что слова о бреде относились к исходнику ТС. Вот он полностью:

Могу только повторить, что кроме void main(void){ }
Все остальное или бред:
uint16_t Buffer[];
ptr_buffer = &Buffer;
value = ptr_buffer + 32;

либо, как uint16_t index_buffer; просто неразумность для ARM.
Это еще не касаясь осмысленности производимых действий и
index_buffer = 32;

Если это "мелкие ошибки", то что тогда крупные .

Я уже писал - отсутствие NAK в протоколе I2C.

Вы как истеричка
Вся соль в посте №72. Он почти неурезанный. И на этом я закончу.

"Ой".

Утверждение "&abc это адрес указателя" неправильно, но и Вы что-то странное написали.
С «у константы не может быть адреса» можно согласиться, если определиться, что под словом «константа» имеется ввиду литерал.
const int ci = 5; // тоже ведь константа

abc -- это идентификатор массива, который в выражениях в большинстве случаев автоматически приводится к указателю на его первый элемент, т.е. к величине (включая как тип, так и значение), тождественной &abc[0].
Но не во всех.

sizeof(abc) даст размер массива в байтах, тогда как sizeof(&abc[0]) даст длину указателя.

&abc даст адрес массива, что и было продемонстрировано в приведенной выдаче компилятора.
(«кстати о птичках»™, в С нет многомерных массивов, есть одномерные массивы, включая массивы других одномерных массивов).
Численно он равен адресу первого элемента, но по типу отличается. Указатель на первый элемент даёт обращение к одному элменту, указатель на массив даёт обращение к массиву.
sizeof(* &abc) также даст размер массива в байтах.

Переменная ptr_abc_0, имеющая тот же тип, что и &abc[0], при инкременте будет увеличиваться на размер (с учётом выравнивания) элемента массива.

Переменная ptr_abc, имеющая тот же тип, что и &abc, будет увеличиваться на длину массива.


Хм... А нужную-то цитату Вы и в своём сообщении привели.

Речь-то идёт не о применении & к имени массива, а о выражении, присвавающем результат переменной другого типа.


Это
тоже «всего лишь слегка не совпадает по типу», не так ли? Но любой вменяемый компилятор тоже обязан послать нафиг.

Я к тому и вёл, что ТС взял адрес массива вместо адреса нулевого элемента массива. Причём адреса оба равны. Только типом отличаются и только компилятор руганётся на это. При использовании нетипизированных указателей (например в параметре функции) или при явном приведении типа (безусловно лучше без него, но...) программа заработает так, как и хотел ТС. Человек на начальном уровне знаком с Си и только истеричка будет так реагировать на его мелкие ошибки. Нельзя же при присваивании указателя на однин тип указателю на другой тип заявлять, что выражение бессмысленное!?

ууу... тут наверно книжки не помогут - не нужно изобретать своих определений, все уже определено без вас, в том числе термин "константа"



Хотя написал некорректно, смысл в том что имя массива это константа и под нее вообще не выделяется память, память выделяется для массива - никакого адреса поэтому не получить.

Перечитал 3 (три) раза. Круто. А магическую циферку 100500 надо, естественно, ручками вычислить, перед включением нового фонта? Если забыл это сделать, или описался (нолик пропустил, по случаю жаркой погоды)? Никто, ни компилятор, ни линкер, даже не колыхнутся, вам об этом любезно сообщить. И будете долго думать, чего это программа грохается.

Мораль - никакая это не диагностика. Тем более не диагностика этапа компиляции.

Нужно использовать, например, механизм static_assert, но это только под С++.

P.S. Это не придирки.

Конечно не помогут, тут надо головой думать, а не дергать общие определения из книг.

А если подумать, то "константа" целиком и полностью подпадающая под это совершенно правильное и всеобъемлющее определение может оказаться:
- в RAM;
- в ROM;
- в регистре;
- являться частью операнда.

точно значит имеется константа имеющая некоторое value, но оно НИГДЕ не хранится, только при необходимости святым духом появляется . Так-что память выделяется, вопрос только в том, способен и обязан-ли компилятор выдавать адреса констант всегда и любых.

Бла, бла, бла - тут о массивах в С речь - это ясно ?



Тоесть вы утверждаете, что при определении массива
char abc[10];
кроме 10 * sizeof(char) выделяется память для указателя abc ? Если да - потрудитесь привести пример, если нет то мне больше не о чем с вами говорить.

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

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

Имя массива - это и есть его адрес, адрес его первого элемента. И почему ж тогда "не получить никакого адреса"? Это в классической книге основоположников C описано.

Используйте функции динамического распределения памяти: malloc, calloc, realloc, free.
Если Вы новичок в Си временно забудьте об этом и используйте статические массивы.

Строго говоря вы не правы. Выражение &Buffer имеет вполне определенный смысл. Значение его такое же как и &Buffer[0], но тип другой.



Естественно что все напечатанные адреса одинаковые.

Keil не ругается на выражение


Кроме того, выражение

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

По существу для себя уже решил объявить массив максимально возможного размера, тем более памяти достаточно (96кб). А шрифты хранятся в самой флэш, тем более что ее тоже много (1Мб). Можно хранить конечно и в SD-карте, но даже при чтении через SDIO, скорость чтения получается меньше, чем при хранении во флэш.

Ну в этом случае, надеюсь Вы действительно будете помалкивать, и думать, как я и просил. Потому, что:


32 бита памяти под указатель на abc[] видите? Или все еще будете думать, что это value берется ниоткуда?

А вы вообще в курсе о каком адресе речь ?
http://electronix.ru/forum/index.php?showt...st&p=949672

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

Вот это неграмотно. &Array и просто Array ВСЕГДА будут указывать в одно и тоже место, отличаются эти выражения только типом.

Тут надо быть аккуратным, в контексте этой цитаты и выше приведенных указателей на первый элемент массива подмечу:

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

Мне уже точно надоело . Похоже Вы читать не умеете . Именно о ТИПЕ - "Что указатель на int не является кирпичом" я, подчеркиваю я, а не вертящийся на сковородке GetSmart речь все время и вел и веду. Не приписываете мне то чего я не говорил. Выражение присваивающее указателю на int указатель на массив БЕССМЫСЛЕННО из-за разных типов. Любой вменяемый компилятор НЕ должен такое тупо и молча переваривать.
Выражения присваивающие указателю на void указатель на массив void *ptr = &buffer, или указатель на первый элемент массива void *ptr = buffer являются СОВЕРШЕННО нормальными с точки зрения компилятора и я НИ РАЗУ ничего против не говорил.


Глупейшая отмазка. На уровне страуса прячущего голову в песок .

Самое смешное, что для того чтобы в этом убедиться, не обязательно даже читать книжку. Достаточно потратить 5 минут на то, чтобы скомпилировать это выражение. g++ выдает вполне развернутое сообщение об ошибке, из которого ясно, что проблема в неправильном типе. Но гуру экспериментировать западло, это же значит надо в собственных непоколебимых знаниях усомниться.



Бессмысленно? Это на С, которому грубо говоря начихать на типы? Ну-ну. GetSmart все правильно написал, на сковордке это вы вертитесь, впадая в истерику от УЖАСНЫХ УЖАСНЫХ УЖАСНЫХ ошибок

Смотрел и на это ваше сообщение, пытаясь понять, что же вы имели в виду. Поясните подробнее.
Это я-то троль? За что!?

Хорошо быть страусом и игнорировать очевидные вещи, типа наличия выделенной памяти под указатель и приведенные мной вопли сишного компилятора, которому таки не начихать на типы. Считайте, что в своей глупости Вы меня уже убедили. Достаточно, можете не продолжать.

Я понял, откуда растет это волна негодования. Если исходить из того, что Buffer указывает на первый элемент массива, то &Buffer будет указывать вообще хз куда. т.е. это уже получится &(&Buffer[0]). Тут я соглашусь получается УЖАС - эта конструкция не имеет смысла. Но не надо забывать, что Buffer приравняли к &Buffer[0] исключительно для удобства пользователя языка, т.е. это сделано искуственно. А когда вы пишите &Buffer, компилятор не производит подстановку (Buffer > &Buffer[0]).

Да вы чушь пишите про выделение указателя. Вы понятия не имеет для чего они лишнее слово выдели, и строите нелепые предположения, что для указателя.

Мужики! Хорош.

Давайте ТС лучше поможем.

char *realloc(ptr,size);

Функция realloc изменяет размер ранее захваченного блока
памяти. Аргумент ptr указывает на начало блока. Аргумент size за-
дает новый размер блока в байтах. Содержимое блока не изменяется.

А если сделать char abc[12]; ? Или для надёжности даже char abc[16]?

А кто это - они?

В приведённом куске кода прекрасно видно, что адрес массива (указатель) грузится в R0 из флеш памяти, в которой под него, соответственно, было выделено место в размере 32 бит.

Страус увидел "лишнее слово" в памяти. Но то, что в этом слове лежит указатель (и даже компилятор назвал это слово именем массива, т.е. abc) страус видеть все еще не желает. Пусть оно будет "лишними словом" решил страус и успокоился. "лишнее слово" - и все опять в голове страуса становится просто и понятно - есть массив, если нужно из ниоткуда будет взят указатель на этот массив. Все остальное считать "нелепыми предположениями". Ну честно говоря, фиг с ним с этим страусом - это пока его проблемы. Имеющие разум да поймут.

Какая разница?

Пардон, я невнимательно прочитал.