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

//-------------------------------
Функция НекийМетод()
    Перем п1,п2,п3;
	//# ClassBegin Класс1;
	Я().МетодПредкаКласса1(п1,п2,п3);
	//# ClassEnd Класс1;

	//# ClassBegin Класс2;
	Я().МетодПредкаКласса2(123,456,п1,п2,п3);
	//# ClassEnd Класс2;

	Возврат обрботкаРезультатов(п1,п2,п3);

КонецФункции //НекийМетод
 

Но не сработало. В ходе танцев с бубном оказалось, что:
1. //# ClassBegin, //# ClassEnd - нужно писать именно таким образом, с пробелом!
2. Выражение из документации "Текст одного класса обязательно должен идти одним куском" следует понимать так, что код класса Класс1 идет только между ClassBegin и ClassEnd, при чем только между первыми. Я по наивности думал, что "один кусок" означает недопустимость конструкции

//# ClassBegin Класс1;
...
//# ClassBegin Класс2;
...
//# ClassEnd Класс2;
...
//# ClassEnd Класс1;

 

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

Правильно ли я все понял?

ИМХО, в таком виде реализация неудобна. Удобнее было бы сделать это как-то так:
поскольку в выражениях //#if, //#elif допустимы не только условия определенности/неопределенности символа, но и сравнения, можно добавить символ classname, автоматом получающий имя компилируемого класса. Тогда определение множества классов в одном модуле реализуется вполне логично

//#if classname = "Класс1"
...
//#elif classname = "Класс2"
...
и т.п.
 

P.S.
Кстати, я счас примерно так и сделал

	Если типЗначенияСтр(Я())="Класс1" Тогда
	Я().МетодПредкаКласса1(п1,п2,п3);

	ИначеЕсли типЗначенияСтр(Я())="Класс2" Тогда
	Я().МетодПредкаКласса2(123,456,п1,п2,п3);
	КонецЕсли

 

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

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

Но есть пара вопросов .

1. если я правильно понял, препроцессор счас работает только на факт определения символа. Значения никакого у символа нет?
2. Все операции сравнения соответственно тоже только сравнивают факт определения символа. Т.е. //#if sym1=sym2 означает что оба sym1 и sym2 одновременно определены либо оба неопределены, а не сравнение их значений.

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

3. Посмотрев реализацию дефайна и парсера выражений в #if, я пришел к выводу, что символ препроцессора может включать не только обычные для идентификаторов буквенно-цифровые символы, но и иные - все кроме скобок и операторов. Т.е. можно, например, задефайнить такое: ааа:ббб+ввв.

4. Соответственно, моя идея об //#if classname="класс1" в свете всего вышесказанного - несостоятельна.
Однако, в таком случае можно сделать иное: при компиляции сформировать символ, состоящий из имени класса (с, возможно, неким префиксом), и потом тестировать на него.

Вот добавление в реализацию CComponentClass::FirstInit, которое должно реализовать эту функциональность. Как префикс выбран символ @. Проверить не могу

{CString tClassName="@";
tClassName=tClassName+m_NameOfInstance;
pHierarchy->m_SymbolOfPreprocessor[className]=NULL;
try
	  {
		CPreprocessor::Preprocess(true, ModuleString, pHierarchy->m_SymbolOfPreprocessor, CMapStringToString(), FullFileName);
	  }
	  catch (CPreprocessor::ExeptionPreprocessor &ex)
	  {
		::ShowMsg("В модуле класса: %s (%s)", mmBlackErr, m_NameOfInstance, FullFileName);
		::ShowMsg(ex.GetErrorString(), mmBlackErr);

		if (!ex.GetCodeString().IsEmpty())
		{
			::ShowMsg("(%d) %s", mmBlackErr, ex.GetNumString(), ex.GetCodeString());
		}
		pHierarchy->m_SymbolOfPreprocessor.RemoveKey("_NOW_PREPARE_CLASS");
		pHierarchy->m_SymbolOfPreprocessor.RemoveKey(tClassName);
		return NULL;
	  }
	pHierarchy->m_SymbolOfPreprocessor.RemoveKey(tClassName);
}
 

Нет, это не функциональное программирование. Это действительно полиморфизм, точнее наоборот, попытка его обеспечения. Я пытаюсь унифицировать работу с некоторыми типами, привести таксказать к общему интерфейсу. Фишка в том, что некоторые методы у предков различаются (изменять/дополнять реализацию предков я не могу, к тому же туда и встроенные 1Совские типы входят). Конечно, в традициях полиморфизма надо на каждого зверя свою обертку сделать, а классы с обобщенными алгоритмами (которые реализуются одним модулем) наследовать от оберток, но блин это ж и лишняя иерархия, и лишние обработки.

В принципе конечно вариант.
Жалко только, что в таком виде (а тут явно будут ф-ции с одинаковыми названиями) оно точно синтакс-контроль не пройдет  .

И лишняя иерархия остается. Вот если б можно было наряду с множественным наследованием некую "многомодульность реализации" использовать  . Кстати, #include в модулях не действуют? Только в defcls?

А почему пройдет? На всяк случай уточню - я имею ввиду конфигуратор. То что оно в предприятии загрузится как надо - это понятно.
А так: фактически в модуле 2 ф-ции с одинаковым именем, конфигуратор ничего про препроцессор не знает, соответственно и ругается "Процедура или функция с указанным именем уже определена в текущем модуле" (тока что проверил). Может конечно я от жизни отстал, и последние vis1cpp или подобные плугины к опенконфу позволяют проверять синтаксис и в таких случаях (у меня vis1cpp 1.0.0.7)?

Хвастаться конечно не хорошо, но все же...
Вот у меня в 1Class нет таких подпорок как ClassBegin/ClassEnd.
У меня просто перед обработкой препроцессором текста модуля класса, движком сразу взводятся символы getclass и getclass_ИмяКласса, а дальше все рулится с помощью //@if, например

Процедура Трям()
//@if getclass_ПервыйКласс
    Сообщить("Трям");
//@elif getclass_Второй | getclass_Sample
    Сообщить("Трям-пам");
//@elif !getclass
    Сообщить("Обработка");
//@else
    Сообщить("Пам-трям");
//@endif 

Почему бы и в 1С++ так не сделать?