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

А почему вы решили, что буква - это unsigned char? До вас все считали, что буква это как раз char, даже специально так тип назвали (загляните в словарь).

Поэтому надо больше читать тематической литературы. Разница есть.

P.S. Ну а я пока тоже завязываю - с таким апломбом вы и сами разберетесь.

Ладно, на прощание .

Вот что-бы глюки "не ловить" и не переопределяйте тип естественный для символьных строк и кучи библиотечных функций с ними работающих.

Насколько я мог заметить Вам вообще многое, что без разницы , но это не есть объестивная реальность. #define и typedef по разному обрабатываются - один препроцессором, а второй компилятором. Компилятор (или дополнительные утилиты типа lint) могут дополнительно заниматься котролем типов, а препроцессор - нет. Кроме того попробуйте ответить на вопрос есть-ли разница между, например, типами переменных bt и bd:

если:

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

За...ца - универсальный интерфейс, через него можно делать всё, что угодно. ©

*ad – ссылка,
bd – char.
Угадал?

Вообщем попотел, но с траблом разобрался. Короче проделал следующие эксперементы:

uint8 *x=10; - глобальная

void funkc(void)
{
uint8 z;
z=x;
….

Смотрю, что в отладчике. Оказывается что что по адресу x лежит адрес не указывающий на адрес расположения 10 (указывал на первый байт после основного кода). A вот так всё OK.

const uint8 *x=10; - глобальная

Та же трабла была и в следующем примере:

const unsigned char *men0[] = {
"1111",
"2222",
"3333",
"4444"
};

и в этом:

unsigned char const *men0[] = {
"1111",
"2222",
"3333",
"4444"
};

и в этом:

unsigned char *men0[] = {
"1111",
"2222",
"3333",
"4444"
};
Т.е. строки в памяти имелись, но массив ссылок на них не ссылался.
А вот с такой конструкцией всё заработало:

unsigned char *const men0[] = {
"1111",
"2222",
"3333",
"4444"
};

Короче вместо того, чтобы потратить 10 минут на чтение двух глав - про const и про указатели вы потратили кучу времени на метод Монте-Карло, но так ничего и не поняли. А ведь вам подсказывали:

Вас затмило ваше сияние и это вы нечего не поняли . Как раз то, способ передать параметр в функцию ничего не решает. Я использую вот такой: и с ним всё работает:

uint8 menu_(unsigned char *const*t);

Решающим оказывается определение массива ссылок.

Насколько я понял ситуацию, в тех случаях когда код не работал, компилятор создавал не статические ссылки а динамические. Причём, даже динамические ссылки можно инициализировать, и по идеи компилятор должен был это сделать, ан нет, он этого не сделал. Мало того, он даже не выдал ни одного предупреждения о том, что он этого не сделал, и сложилось ложное впечатление о работоспособности кода, хотя на самом деле это было не так.

Не увидел ни одной ссылки (для справки - в С нет ссылок, они есть в С++). Решающим оказалось, что у вас получились инициализированные неконстантные указатели на константные объекты. Они инициализируются перед запуском функции main(). Если бы вы обдумали упомянутый намек, вы бы сделали массив константных указателей на константные объекты. И они бы были проинициализированны на этапе компиляции.Не знаю кого затмевает, но у меня подобные конструкции работают как ожидается, и компилятор делает все, что от него хочу Может он сделал именно то, что вы попросили, только вы этого не заметили?

Хорошо указатели. Так в том то и дело, что я хотел этого добится

, и добился без посторонней помощи. Привожу пример.

uint8 *const men0[] = {
"1.Настройка времени
"2222",
"3333",
"4444"
};

Где то в функции ставлю следующую конструкцию.

x=*men0[0];

Смотрю дебагер.
x=*men0[0];
00001A08 E59F0068 LDR R0, [PC, #+104] ;[0x1А78] =men0 (0x2978)
00001A0С E5000000 LDR R0, [R0, #+0]

По адресу 0x1A78:

00001A78 00002978

По адресу 00002978 лежит строка.
Так что, адрес 0x1A78 лежит совсем не в изменяемой области памяти, и является ни чем другим, как константой.