Всех с наступившим!!!
Решил написать функцию вывода строки в массив да так чтобы можно было эту строку брать как из SRAM так и из FLASH а поскольку указатели на FLASH и SRAM это разные вещи, то и типы указателей должны быть разные.
решил сделать тип void чтобы тип можно было задать при вызове функции с приведением типа.

вот код функции

прблема в том что компилятор не может сделать ++ для указателя типа void.
если создать отдельную переменную типа char *pS; то все нормально.

т.о. вопрос ? как сделать ++ указателю типа void без отдельной переменной, если возможно.

И еще вопрос. Если нужен передавать параметр типа bool
то можно как-то использовать
#if
#endif
т.е. напрмер

или может так :

Есть еще вариант передавать два указателя, для Flash и SRAM и ненужный передавать 0
Или может еще каким образом поступают при такой задаче, просьба поделиться опытом ...

Всё, что Вы хотите легко реализуется перегружаемыми функциями в С++, а ещё элегантнее - шаблонной функцией.
Давно так делаю и очень доволен.
А если делать на С, то надо дополнительно передавать идентификатор типа и внутри универсальной функции делать приведение. Тогда и операция ++ будет работать.

Попробовал sprintf() но сгенеренный код получился в 2 раза больше по времени выполнения.
это если я Вас правильно понял всмысле перегружаемых.
а что такое шаблонная функция ?
В С я новичок, поэтому может какие термины еще не знаю
а разве

Это не приведение типа ? вот на такой вариант компилятор говорит:
Error[Pe852]: expression must be a pointer to a complete object type

как правильно написать чтобы ++ работал?

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

В Си++ все это можно организовать, но все равно код раздуется до размеров двух процедур с разными типами данных.

Так что не убивайте время попусту преобразуйте VOID к переменной конкретного типа и все будет в порядке. Не бойтесь большого количества переменных в теле функции, шелуху компилятор сам откинет.





вот франмент варианта кода переделанной функции

ну в данном конкретном случае думаю код не очень увеличиться
я думал это как раз через #if сделать, т.е. передаем указатель и смысл этого указателя S_F типа SRAM или FLASH.

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

дает ошибку при компиляции ???

sdelay tak :

c = *(((char*)pStr)++);

po moemu dolzno poyti .
Po idee dlya togo chto izmenit adres (inkrementirovat ego na odnu stupen posredstvom ++) C dolzen znat razmer tipa dannix dlja kotorogo vi sozdali ukazatel. Tak kak void* v sebe nichego razmernogo ne neset , kompailer vidaet osibku potomu chto ne znaet na kakoe znachenie uvelicit ukazatel. Dopustim esli tip dannix - byte , to address uvelichivaetsja na odin , esli short int to na dva . Poetomu increment vozmozen tolko posle castinga void na yavnij tip (v vasem sluchae - char), chto mi i pitaemsja delat posredstvom manipulyacii skobkami.

Это второе что мне пришло в голову но:
Error[Pe137]: expression must be a modifiable lvalue
работает только

вместо 1 можно переменную
но это не совсем то что мне нужно.
... а по логике вроде должно работать, может логика неправильная ?

А компилятор какой? У IAR для AVR есть модификатор __generic для указателей.


и передавайте в эту функцию хоть char*, хоть __flash char*, компилятор разберётся (и сделает необходимые преобразования типов при передаче параметров).

возможно:

Впрочем, ничего страшного в использовании отдельной (auto) переменной нет - на то есть оптимизация.
Если эта переменная нигде больше не используется то и память под неё не будет выделяться, а регистры для вычислений (++) в любом случае будут использоваться.
Можно немного помочь оптимизатору указав для этой переменной модификатор register.

Все директивы препроцессора (которые с #) обрабатываются ещё _до_ компиляции. С помощью #if, #ifdef и т.п. можно выбрать какой кусок текста будет компилироваться а какой - нет, но эти директивы обрабатывает именно препроцессор, на вход собственно компилятору попадает _текст_ после препроцессора, т.е. в данном примере или строка flashcpy() или Sramcpy().

Сообщение отредактировал SSerge - Jan 3 2006, 16:14

[quote name='&-rey' date='Jan 3 2006, 22:50' post='75872']...я думал это как раз через #if сделать, т.е. передаем указатель и смысл этого указателя S_F типа SRAM или FLASH.
[quote]

Я думаю, Вы не совсем понимаете назначение директив условной компиляции. С помощью #if и других # вы не сделаете код гибче, Вы только сможете задать конкретный тип для входной переменной на этапе генерации кода.

[quote name='&-rey' date='Jan 3 2006, 22:50' post='75872']...но для полного понимания проблемы в будущем все таки почему

дает ошибку при компиляции ??? [/quote]

Я уже объяснил Вам выше, что структура указателя для SRAM и FLASH разная. Наверное, компилятор думает как я :-)

OK, v principe kompayler prav )), on ne mozet preobrazovat naverno tip ukazatelja .

Poprobuyte po drugomu - esli v svoej funkcii budete ispolzovat tolko kak char* to perepisite parametri funkcii vmesto void* na char* , tipa togo chto SSerge porekomendoval.

Да компилятор IAR, постоянно забываю указывать

так действительно работает, Спасибо.

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

Тут я малость промахнулся, это аналог *++pStr а не *pStr++ как требовалось.
Нуууу..., тогда так

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

Выражение var++ эквивалентно var = var+1, НО:
Тут есть один тонкий момент - выражения в левой и правой части оператора присваивания вычисляются по-разному. В "С" они называются lvalue и rvalue.
В правой части вычисляется значение выражения (rvalue), при этом если в выражении есть имена переменных, т.е. символические имена для некоторых ячеек памяти, то используются значения этих переменных, числа, хранящиеся в соответствующих ячейках памяти.
При вычислении выражения в левой части (lvalue) на самом деле вычисляется адрес ячейки памяти куда следует поместить результат вычисления выражения в правой части.
Так вот (char*)pStr не может быть lvalue - нет такой ячейки памяти где бы оно хранилось.
Ситуация в точности такая-же как и для выражения (2*2)++;

P.S. Ну вот, пока объяснял, сам понял :-))

Наверное, всё-таки, не по времени выполнения, а по объёму, да и то при полном отсутствии оптимизации.
Почему-то никто не говорит (или я пропустил), что void* надо приводить не только к char*, но и к __flash char*. На это и указывает сообщение компилятора о незавершенном типе.
Основная ошибка в том, что в функции на момент исполнения нет информации о том, какого типа указатель был приведен к void*.
Решения было три:
- тип __generic;
- информация о типе указателя как аргумент в функции;
- два указателя.

Спасибо SSerge за обяснения, мне как раз это счас очень нужно для понимания процесса.
а что такое [-1] ?
обещаю что никогда не применю это знание во вред ))

вот что получено в результате: