Сработает.
Выделится в памяти константный массив символов (строка) и присвоится на неё указатель.

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

А если прочитать данный пример повнимательнее? Или еще лучше - почитать букварь?
Во-первых, не в любом случае, а во-вторых - было явно указано: "Иногда и так бывает полезно. Хотя, это не общий случай.". Читайте внимательно прежде чем делать категоричные заявления.
А где в примере было неявное определение типа?

Это, всего-лишь потому, что p[] - указаеть-константа, адрес которой известен компилятору, а *p - указатель-переменная, из которой нужно ещё забрать адрес.
Тут сравнение немного неуместно, это совсем разные вещи. Через указатели обращение всегда занимает больше ресурсов, чем напрямую к переменной.
Попробуйте подкинуть массиву переменный индекс, и у Вас код также развернётся в более чем 2 инструкции. В этом случае, обращение будет практически эквивалентно обращению через указатель.

Хотелось бы не голословные ругательства, а конкретные примеры.
Пример, при котором обращение к данным по указателю, объявленному вашим способом (не к абстрактному, а именно *p="AAA") быстрее, чем к массиву.
Пример, при котором такое объявление удобнее. Мне в голову приходит только вариант, когда указатель потом меняется, но тогда доступ к прежним данным будет потерян.
Указатель вместо массива, очевидно.
Проверил:

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

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

Про "указатель не выделяет памяти" я и написал, что поверю на слово. Если ошибаюсь с механизмом, поправьте. Запись char *p="ABC"; выделяет в ОЗУ 4 байта со значениями 'A', 'B', 'C', '\0', но создает туда не постоянную ссылку (как при объявлении массива), а только переменную, p.
Поэтому массив (строку) и стоит объявлять как массив, а не как указатель. Его нельзя переназначить, то есть на случайное присвоение компилятор уже будет ругаться и мешать потерять единственную ссылку на данные. Ну и скорость обращения к данным в массива больше.

Вот так вот, независимо ни от чего?

Особые извращенцы могут и вручную адреса считать, как на ассемблере. Но какой смысл, если для стандартных задач в языке есть стандартные решения. Если считаете иначе - попробуйте все-таки аргументировать свою позицию, а не просто пытаться поймать меня на незнании предмета.
Есть примеры, при котором выгоднее объявлять массив указателем-переменной?

Опять же, не совсем правильное сравнение.
Адрес str компилятору известен на этапе компиляции, а из p его ещё нужно забрать.
Вы снова привели сравнение по типу обращения к переменной напрямую и через указатель, для чего-то доказывая, что указатели - плохо, а массивы - хорошо, подбирая какие-то варианты, где с указателем код становится жирнее. Хорошо, ни кто не спорит, но не всегда можно обойтись без указателей. for тоже, в некоторых случаях, можно заменить while-ом, но не всегда, т.к. это, также, как и переменная с указателем - разные вещи.
Даже моему коту понятно, что при p-указателе, кострукция p[i] развернётся х.з. во что. Нужно просто понимать что ты пишешь и подбирать более оптимальные варианты реализации задуманного.

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

Есть конечно. Когда массив - константная строка, которая никогда не изменится.
В случае с данные в массиве str Вы сможете дальше в программе поменять. Т.е. Вы выделили себе массив определённого размера (в данном случае, без числа в скобках - размер строки), с которым дальше собираетесь работать, проинициализированный какой-то строкой.
Но если Вам не нужно этого, зачем выделять лишнюю память в ОЗУ под массив и мучить компилятор, заставляя его при инициализации копировать всю строку в этот массив, при том, что экземпляр строки уже где-то есть (вероятнее всего он во флеши) ?
Достаточно просто получить адрес этой строки в указатель :и дальше работать с ним :
Если не хотите случайно потерять ссылку на строку, либо не собираетесь дальше использовать этот указатель для других строк, то объявите указатель константой :В таком случае, если компилятор будет сильно умным, есть вероятность, что он даже память не будет выделять под указатель, а просто будет заменять его сразу на адрес строки.

я же приводил дизассемблерный код: второй вариант сработает быстрее, и его в некоторых случаях лучше использовать. Например, при копировании строк (strcpy), но это не объявление массива. Впрочем, если надо обрабатывать данные строго последовательно, это лучше, но и то, я бы записал как

Зависит от компилятора. В avr-gcc и, вроде, cvavr, для размещения в ПЗУ есть специальный модификатор - PROGMEM, flash или как-то так. А уже для работы с существующей строкой можно использовать как указатель, так и прямой адрес (вот как это выглядит в avr-gcc)
А вот указатель как раз скорее зарезервирует память под данные, доступ к которой легко потерять. Сами бы проверили в отладчике, что и где хранится
Так в чем преимущество? Зачем полагаться на то, что "компилятор будет сильно умным", если можно ему явным образом указать?
Я не доказывал преимущества массивов во всех случаях. Я доказывал только то, что объявление строки через массив лучше, чем через указатель.

Ни от чего это не зависит. Строка в массив откуда то копируется (пусть даже байтами по-очереди, командами в ряд), а значит она занимает память. И причём тут PROGMEM ? Речь совсем не о том, где размещается строка. А о том, что она уже где-то есть.

Вы, по всей видимости, меня не поняли. Не надо ни на кого полагаться, это я для примера сказал, если ссылку не хотите терять.
Преимущество в том, что Вы под строку, которая никогда не будет меняться, занимаете ещё драгоценное ОЗУ, объявляя массив. А зачем он Вам в этом случае ? Вам только строка нужна, которая итак уже где-то лежит. Дак почему бы её оттуда и не забирать ?

Объявление строки, с присваиванием указателя на неё ничем не отличается от присваивания её массиву. Строка не объявляется через чего-то, она объявляется в виде текста, обрамлённого кавычками. Когда Вы пишете в коде "Строка", она уже объявлена ,и под неё уже выделено место. Единственное, когда Вы объявляете ещё и массив, она тупо копируется в него.
У меня начинается складываться впечатление о Вашей некомпетентности в этой области. Очень надеюсь, что ошибаюсь.

Зачем мне проверять очевидные вещи ? Что Вы вообще прицепились к этим областям хранения ? Речь не о том, что и где лежит - это уже другая тема, к которой Вы потихоньку перебираетесь, уходя от основной темы разговора

Если она объявлена как размещенная в ПЗУ, автоматически копироваться в ОЗУ она не будет, и не займет там ни одного байта.

Вот именно. Объявление массива не создает лишних переменных. То есть запись char str[]="AAA"; занимает 4 байта, а запись char *p="AAA"; - 6 байт (для AVR, где указатель двухбайтный).
Если, например, мне нужна скорость и критична разница в пару тактов, я размещу строку в ОЗУ, зная, что в начале программы она будет скопирована из флеша. В обычном же случае пусть будет во flash.
Объявление массива само по себе места не занимает, как и объявление переменной. Место резервируется под данные. В случае указателя, отдельно резервируется место и под строку (причем, по умолчанию, в ОЗУ), и под ее адрес.

Знаете, у меня закрадываются схожие сомнения на ваш счет. Впрочем тут мы можем сравнить компетентность друг друга. Есть записи
Все они так или иначе создают строку длиной 8 байт. Как считаете, сколько байт ОЗУ занимает каждый из вариантов и сколько тактов нужно для получения элемента по переменному индексу? Если дополните этот список вариантами расположения строки, будет только лучше.
Потому что, как показало это обсуждение, эти вещи не очевидны. А от какой темы я ухожу? Пока что я общаюсь на тему "преимущества объявления строки как массива перед указателем".

Давайте сделаем вот как. Что бы мы общались "на одной волне", Вы скинете мне весь свой набор (компиль, ИДЕ, ..). Ибо я под АВР никогда не программил и понятия не имею ни поведения Вашего компилятора, ни тем более количество тактов, требуемых для определённых действий. А в угадайку играть не хочется.
Скиньте, плз, в личку ссылочки для скачивания. Там же потом может и продолжим этот интересный разговор. А то так всю тему зафлудим этими спорами.

Скажу только то, что знаю точно. char rstr[] = "RAM str"; займёт минимум 8 байт флеши, не считая команд копирования + минимум 8 байт ОЗУ под массив. О чём я и твержу, что для строки бессмысленно выделять в ОЗУ память, если она и так заняла флешь и можно оттуда её выдёргивать, потратив всего-лишь пару байтов на указатель. Да и тот, также, можно закинуть в флешь.

Ну, 8 байт флеши уйдет на одну строку, обсуждение у нас о прочих расходах.
Насколько я понял из анализа дизассемблированного кода, все глобальные переменные и явно инициализированные заполняются сразу после старта программы, до входа в main в едином цикле, так что именно на копирование из flash в ОЗУ память не тратится, только лишних 8 - 10 тактов. Именно при старте на это никто внимания не обратит.
Запись char str[]="AAA"; выделяет в ОЗУ 4 байта памяти, которые будут при старте заполнены из flash. Адрес начала хранится не в переменной, а подставляется компилятором. То есть запись char x = str[1]; эквивалентна char x= *((char*)(0x60+1)), где 0x60 - адрес в ОЗУ, где компилятор разместил массив. То есть расход по ОЗУ - 8 байт, по ПЗУ - 8 байт (не считая само обращение), скорость доступа я уже приводил, 6 тактов. Это немного быстрее, чем работа напрямую с flash и проще для новичков. Но большой расход ОЗУ.
Запись PROGMEM const char str[]="AAA"; выделяет 4 байта ПЗУ, заполненные текстом. Обращение к такой строке идет через специальные команды strcpy_P, memcpy_P, pgm_read_byte и т.д. (если интересно, см. avr-libc). Сама по себе эта запись не занимает в ОЗУ ни одного байта. Запись char x = pgm_read_byte(&str[1]) эквивалентна pgm_read_byte(0x60+1), где 0x60 - адрес в ПЗУ (все-таки, гарвардская архитектура, приходится явно указывать тип памяти), на самом деле он вряд ли будет такой маленький, но для примера это не важно. Скорость доступа около 7 тактов. Обычно именно этот вариант оптимален, но иногда лень подключать pgmspace.h и вспоминать тамошние функции.
Запись char *p = "AAA"; выделяет в ОЗУ 4 байта памяти для строки (также, как для массива) и 2 байта для указателя, записывая туда при старте адрес тех 4 байт. Фактически, она эквивалентна char str[]="AAA"; char *p = str; только адрес str компилятору неизвестен. По скорости около 11 тактов, по объему тоже все плохо, дизассемблерный код я приводил.
Запись char *p = PSTR("AAA"); должна бы создавать массив только в ПЗУ, давая указатель на него, но макрос PSTR работает только в функциях, так что этот вариант неработоспособен и рассматривать его не стоит.
Запись PROGMEM const char *p = "AAA"; компилятором понимается (warning не в счет), но по сути бесполезна - массив создается в ОЗУ, а его адрес записывается в flash. Зачем может понадобиться такое извращение я без понятия. Компилятор, видимо, тоже, поскольку собирается игнорировать модификатор PROGMEM.
Вот как я понимаю распределение памяти и скорости для разных вариантов и на основании чего не рекомендую обхявлять строку как char *p="...";

Народ помогите!!! не получается вывести на LCD строку в Протеусе:

sprintf(text,"%s","Hello");
lcd_puts(text);

и так пробовал:
sprintf(text,"%s\n","Hello");
sprintf(text,"%4s\n","Hello");
sprintf(text,"%4s","Hello");
sprintf(text,"%.4s","Hello");
sprintf(text,"%6.4s","Hello");




главное sprintf(text,"%d",123); работает, не могу понять где косячу

скорее всего проблема в описании массива text - каков его размер?
о чем вы спорите, о каких волнах идет речь? записи char *s и char s[] полностью идентичны по всем формальным критериям! это даже не совсем разные записи одного и того же. а то, что в определенный момент вы инициализируете указатель адресом какой-то строки, это дело третье.

unsigned char text[32];

Спасибо всем кто мысленно болел заменя, я разобрался