строка -> код

Ты сам ответил на свой вопрос.

"заставить компилятор интерпретировать" нельзя.

смешно. но вы, наверное, не поняли суть вопроса.

в макроопределениях есть возможность конвертировать после раскрытия параметр в строку. я об операторе #
(типа #define macro(data) #data ----> "data").

вопрос.
есть ли возможность сделать обратное.
например:
#define macro(data) new ???data
где-то в программе:
{
char* szdata = "CLASS";
CLASS* pclass = macro(szdata) //----> CLASS* pclass = new CLASS;
}

Заметь, что в примере с макроопределениями волшебства не происходило, просто текст указанный в скобках обрамлялся кавычками:
#define macro(data) #data ----> "data"

Во втором же примере ты хочешь чуда: чтобы компилятор (я правильно понял, компилятор? т.е. на compiled-time) раскрывал значение переменной:
macro(szdata) ----> CLASS* pclass = new CLASS;

Так не бывает. Кроме того не вижу в этом смысла. Можешь сделать через макрос:

Но зачем? Если ты определяешь класс во время компиляции, то чего бы его не определять явно.

Если ты хочешь, чтобы создавался объект определенного класса во время выполнения программы, то причем тут компилятор? Здесь в общем случае нужна фабрика с набором if-ов, но будут создаваться объекты только определенных классов да и то, по-хорошему, с общим интерфейсом:

Набор if-ов можно заменить ассоциативным массивом или switch-ом c хешом от строки, можно ввести авторегистрацию классов, но суть останется той же.

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

#define macro(data) new ???data

где-то в программе:
{
char* szdata = "CLASS";
/*здесь он проверяет переменную szdata и убирает первую и вторую кавычки: подставляется только текст*/
CLASS* pclass = macro(szdata) //----> CLASS* pclass = new CLASS;
}

--почему я не определяю класс явно.
потому, что не известно, какие классы и сколько (все они наследуют от одного предка). конечно, можно использовать if'ы и т. п. просто возник вопрос, есть ли средства у проепроцессора.

Ты сам себя запутал. Ты подошел к решению задачи не с того угла и пытаешься катить квадратное и тащить круглое.
Что конкретно тебе надо получить? Не на уровне создания объекта а выше.

Что значит "не известно, какие классы и сколько"?
char* szdata = "CLASS"; <- здесь же ты пишешь известное имя
откуда взяться неизвестным?

Что значит "проверяет переменную szdata" ?
Ты видишь разницу между записью
CLASS* pclass = macro(szdata)
и
CLASS* pclass = macro("CLASS")

О! Хочешь решение?

Так ты наверняка запутаешь вероятного противника :D

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

CLASS_ {...};
CLASS_1 : public CLASS_ {...};
CLASS_2 : public CLASS_ {...};
CLASS_3 : public CLASS_ {...};

class MOM
{public:
CLASS_** m_pObjMas;//массив указателей на производные от CLASS_
...
};

возник вопрос: есть ли способ без if' ов в конструкторе MOM заполнить
MOM::m_pClassMas произвольным числом указателей на произвольные объекты, производные от CLASS_.
в частности, можно ли это сделать на этапе препроцессирования.

--что касается проверки фактического аргумента макорса при его раскрытии. почему вы не считаете возможным существование процесса, противоположного применению оператора # в макросе.
если может действовать оператор #, то и "мой гипотетический" :) оператор "снятия кавычек" также имеет право на существование. компилятору этот процесс не должен доставить особого труда.

[QUOTE=smax13]--неизвестно, в каком порядке эти классы будут появляться и сколько всего.
[/QUOTE]
Так не бывает! Это не магия, а программирование.

[QUOTE=smax13]
возник вопрос: есть ли способ без if' ов в конструкторе MOM заполнить
MOM::m_pClassMas произвольным числом указателей на произвольные объекты, производные от CLASS_.
в частности, можно ли это сделать на этапе препроцессирования.
[/QUOTE]
На этапе предпроцессинга, компиляции и линковки НИКАКИЕ инициализации не осуществляются! Ничего заполнить на перечисленных этапах нельзя. Может ли трактор на этапе сборки на конвеере пахать землю?

[QUOTE=smax13]--что касается проверки фактического аргумента макорса при его раскрытии. почему вы не считаете возможным существование процесса, противоположного применению оператора # в макросе.
если может действовать оператор #, то и "мой гипотетический" :) оператор "снятия кавычек" также имеет право на существование. компилятору этот процесс не должен доставить особого труда.[/QUOTE]
macro(szdata)
что-то я здесь не вижу кавычек... какие кавычки надо убрать?

[QUOTE=smax13]компилятору нужно только эти кавычки убрать.
[/QUOTE]
[QUOTE=smax13]
char* szdata = "CLASS";
/*здесь он проверяет переменную szdata и убирает первую и вторую кавычки: подставляется только текст*/
CLASS* pclass = macro(szdata) //----> CLASS* pclass = new CLASS;
[/QUOTE]
--почему я не определяю класс явно.
потому, что не известно, какие классы и сколько (все они наследуют от одного предка). конечно, можно использовать if'ы и т. п. просто возник вопрос, есть ли средства у проепроцессора.[/QUOTE]
Как компилятор уберет кавычки, если это переменная-строка и она может поменяться во время выполнения программы, т. е. во время компиляции ее содержимое неизвестно? Даже если каким-то чудом были бы для этого средства, это были бы ну никак не средства препроцессора.
Вот например:

Скажу больше: информация обо всех именах (переменных, типов...) после компиляции теряется (за некоторыми исключениями).
Такое возможно только в интерпретируемых языках, и во многих из них это реализовано.
Если ты под szdata имел в виду строку-константу, которая точно не изменится, используй (как сказал Green) макроопределения:
#define CLASSNAME CLASS
...
CLASS *pclass = new CLASSNAME;
или
#define CREATEOBJECT(var) CLASS *var = new CLASS
...
int main ()
{
CREATEOBJECT (pclass);
// Это заменится на CLASS *pclass = new CLASS;
};

to Green.

--в программровании бывает, вспомните хотя бы SomeFunc(...);

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

гипотетически.
#define macro(data) new <some operator>data;

char* sztype_name = "CLASS";
CLASS* pclass = macro(sztype_name);

-он раскрывает макрос и видит <some operator>,
CLASS* pclass = new <some operator>sztype_name;

-ищет в тексте имя фактического аргумента макроса (sztype_name);
-определяет (или уже знает, т. к. используется <some operator>), что это строка,
-(дописывет в текст то, что в кавычках строки) или делает, что-то другое -- не знаю.

ВОПРОС. существует ли подобный <some operator>.
я ничего не слышал - вот и спрашиваю.

to Cheburator
компилируйте debug-версию. если на MVCPP вся отладочная информация в .pdb.

[QUOTE=smax13]
ВОПРОС. существует ли подобный <some operator>.
я ничего не слышал - вот и спрашиваю.
[/QUOTE]
Нет не существует, но можно сделать, см. мой пример с CreateObject.

[QUOTE=smax13]
to Cheburator
компилируйте debug-версию. если на MVCPP вся отладочная информация в .pdb.[/QUOTE]
Ну на то она и ОТАДОЧНАЯ информация, что используется только отладчиком.

ок.
жаль, что нет.
спасибо.

Повторяю еще раз: ну чем тебе не нравится

При смене класса менять придется только строку #define macro (при условии что класс производный от CLASS).
Ну если уж тебе нужен полный лексический (и даже синтаксический) анализатор, попробуй так:

А в файле myfile.h пиши что душе угодно.

[QUOTE=cheburator]
Ну если уж тебе нужен полный лексический (и даже синтаксический) анализатор, попробуй так:

А в файле myfile.h пиши что душе угодно.[/QUOTE]
И этот человек говорил о "хорошем и выработанном годами принципе модульного программирования" ? :D

Я бы за такое не бил бы по рукам, а отрезал их вовсе... как рудимент.

P.S. Без обид, это была шутка (см. смайлик), но подобный стиль программирования, действительно, не очень хороший.

[QUOTE=Green]И этот человек говорил о "хорошем и выработанном годами принципе модульного программирования" ? :D[/QUOTE]
Ну, лично я с крыши небоскреба прыгать не собираюсь, но если кому-то это сильно надо - я проинструктирую его как это можно сделать :)