борьба с шаблонами

[Алексей++]

а ещё один глупый вопрос

Скажем, я реализую некую работу с
1) массивом элементов T
2) массивом указателей на элемент T

шаблоны вышли одинаковыми, разница лишь T и T* и в доступе к методам элемента:

Код:

//работа с массивом элементов T
template<T>
void WorkWithArrayOfT(T* Array, DWORD dwdCount)
{
   ...
   //доступ к методу T
   Array[0].Method();
   ...
}

//работа с массивом указателей на элементы T
template<T>
void WorkWithArrayOfPointersToT(T** Array, DWORD dwdCount)
{
   ...
   //доступ к методу T
   Array[0]->Method();
   ...
}

то есть к чему я веду ? По сути, если бы не разница в доступе, то строчка

WorkWithArrayOfPointersToT<int>(...,...);

равносильна
WorkWithArrayOfT<int*>(...,...);

И вопрос: как в шаблоне сделать условный выбор оператора доступа ? Тогда оба шаблона с практически идентичным кодом можно было бы держать в одном единственном шаблоне

[Джон]

Эммм... в самом общем случае никак, и дело не в шаблоне, а в С++. Поэтому и существуют перегруженные конструкторы и ф-ции, которые работают с указателями и с копиями.
Посему и с шаблонами ты явно указываешь либо это шаблон для типа, либо на указатель типа.

А зачем тебе это надо?

[Алексей++]

и дело не в шаблоне, а в С++.

на ум пришло только такое опасное решение

Код:

template<T,const bool bPointer>
void WorkWithArrayOfT(T* Array, DWORD dwdCount)
{
   ...
   //доступ к методу T
   if(!bPointer)
   {
      ((T*)&Array[0])->Method();
   }
   else
   {
      ((T**)&Array[0])->Method();
   }
   ...
}

А зачем тебе это надо?

я же написал зачем - длинный код получился одинаковый, различие только в одной строчке с оператором доступа

[Finch]

Джон, Cушествует способ. Классика А. Александреску "Современное проектирование на С++"

Код:

  template <typename U>
      struct PointerTraits
      {
         typedef U* ParametrType;
      };
      template <typename U>
      struct PointerTraits<U*>
      {
         typedef U ParametrType;
      };


     template <typename T>
         class SomeClass
         {
            typedef typename PointerTraits<T>::ParametrType PointerType
            PointerType SomeValue;
         };

SomeValue всегда будет указателем на данные, вне зависимости, что указали при конкретизации шаблона.

Леш, этот пример можно адаптировать под твои нужды.

[Алексей++]

Finch, как-то это всё сложно для понимания , мозг разбегается ))  Что тут чего делает ?

[Finch]

Ничего сложного

Код:

  template <typename U>
      struct PointerTraits
      {
         typedef U* ParametrType;
      };

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

Код:

      template <typename U>
      struct PointerTraits<U*>
      {
         typedef U ParametrType;
      };

Это конкретизация для указателя, компилятор ее будет выбирать, если встретит указатель на элемент.
Теперь пользуемся этой возможностью

Код:

            typedef typename PointerTraits<T>::ParametrType PointerType
            PointerType SomeValue;

Более полно и конкретно описано в вышеприведденой книге.

[Алексей++]

PointerType имеет тип "typename PointerTraits<T>::ParametrType"

Код:

template<PointerType,const bool bPointer>
void WorkWithArrayOfT(PointerType* Array, DWORD dwdCount)
{
   ...
   //доступ к методу PointerType
   Array[0]->Method();
}

так ?

[Finch]

Неа.

Код:

template<typename T>
void WorkWithArrayOfT(PointerType* Array, DWORD dwdCount)
{
   typedef typename PointerTraits<T>::ParametrType PointerType
   PointerType Array;
   //доступ к методу PointerType
   Array[0]->Method();
}

[Finch]

Вру, сейчас подправлю код.

[Алексей++]

кстати, на это

Код:

  template <typename U>
  struct PointerTraits
  {
     typedef U* ParametrType;
  };
  template <typename U>
  struct PointerTraits<U*>
  {
     typedef U ParametrType;
  };

происходит ругань
error C2989: 'PointerTraits<class ?? ::U *>' : template class has already been defined as a non-template class
error C2988: unrecognizable template declaration/definition

[Finch]

А ну все, Это вошло в стандарт помоему в 99 году. Так что естественно VC6 показывает язык. У меня на g++ такое проходит и на ура.

[Алексей++]

понятненько ) Тогда оставлю изврат с bool bPointer

[Вад]

Код:

template<typename ItemType_>
void WorkWithArrayOfT(ItemType_* Array, DWORD dwdCount)
{
   ...
   //доступ к методу T
   ( (ItemType_*)&Array[0] )->Method();
   ...
}

или нет... И компилятора под рукой нет...
Ещё есть идея с порождением вспомогательного объекта с перекрытым оператором -> (типа умных указателей)

[Алексей++]

Вад, агась, я уже так и поступил. Компилятор пропускает (пост #62)

перегружать оператор неохота, если честно

[Джон]

Лёш, на самом деле всё гораздо проще. Для сокращения кода и существует перегрузка ф-ций:

Код:

template <class T> void MyFunction(T obj)
{
...
	obj.MyClassMethod();
...
}

template <class T> void MyFunction(T *pObj)
{
	T obj = *pObj;
	MyFunction(obj);
}

[Алексей++]

Джон, не могу понять, чем это мне здесь поможет...

[Джон]

Тем, что ты напишешь тело БОЛЬШОЙ ф-ции только один раз. Чего ты и добивался.

А зачем тебе это надо?

я же написал зачем - длинный код получился одинаковый, различие только в одной строчке с оператором доступа

зы Ну и ессно тем, что это безопасный код без всяких извращений.

[Джон]

Джон, Cушествует способ.

Вить, ща только просмотрел твой код, ИМХО это не то, что спрашивалось. Можешь показать пример использования с объектом и с указателем?

[Finch]

Сейчас помудрю. Кстати, твой код тоже не будет работать У него там не просто один указатель, а массив указателей.

[Джон]

Легко будет работать, надо только определить оператор = для данного типа. Если же передаётся массив указателей, то просто сделать копию с него, размер-то известен.

[Джон]

Код:

class MyClass
{
public:

	MyClass() {}
	void MyClassMethod()
	{
		int i=3;
		printf("Class 1: i=%d\n", i);
	}
};

class MyClass2
{
public:

	MyClass2() {}
	void MyClassMethod()
	{
		int i=3;
		printf("Class 2: i=%d\n", i);
	}
};

// основная ф-я с БОЛЬШИМ кодом
template <class T> void MyFunction(T *pObj, int nSize)
{
	for(int i=0; i<nSize; i++)
	{
		pObj[i].MyClassMethod();
	}
}

// перегруженая с массивом указателей
template <class T> void MyFunction(T **ppObj, int nSize)
{
	T *pObj = new T[nSize];
	memcpy(pObj, &ppObj, nSize);
	MyFunction(pObj, nSize); // вызов БОЛЬШОЙ ф-ции
}

int main()
{
        // для массива объектов
	MyClass2 obj[2];
	MyFunction(obj, 2);

        // для массива указателей
	MyClass *pObj[2];
	pObj[0] = new MyClass();
	pObj[1] = new MyClass();

	MyFunction((MyClass*)pObj, 2);

	delete pObj[0];
	delete pObj[1];

	return 0;
}

В код внесены изменения для совместимости с 6ой студией. см. ниже

[Алексей++]

Джон, ну покажи пример прямо для поста №1 Может, я просто туплю с недосыпа.

Присваивать временной переменной не хочу. Лучше уж с преобразованием из №62 оставлю

[Finch]

Вот код, который у меня полностью работает.

Код:

#include <stdio.h>

   template <typename U>
   struct PointerTraits
   {
      static void Method(U &u) {u.Method();};
   };
   template <typename U>
   struct PointerTraits<U*>
   {
      static void Method(U *u) {u->Method();};
   };

   template <typename T>
	static void WorkWithArrayOfT(T* Array, int dwdCount)
	{
   	//доступ к методу PointerType
  	   PointerTraits<T>::Method(Array[0]);
	}

class a
{
public:
   a() {};
   ~a()  {};
   void Method() {printf("class a\n");};
};


int main()
{
   a **A=new a*[10];
   for (int i =0; i<10; i++) A[i] = new a;
   WorkWithArrayOfT<a*>(A, 10);
   a B[10];
   WorkWithArrayOfT<a>(B, 10);
   return 0;
}

[Джон]

Лёщ, а это он и есть...

[Джон]

Код:

// это основная ф-я с полностью реализованым телом

//работа с массивом элементов T 
template<T> void WorkWithArrayOfT(T* Array, DWORD dwdCount)
{
   ...
   //доступ к методу T
   Array[0].Method();
   ...
}

//работа с массивом указателей на элементы T
template<T>
void WorkWithArrayOfPointersToT(T** ppArray, DWORD dwdCount)
{
	T *pArray = new T[dwdCount];
	memcpy(pArray, &ppArray, dwdCount);
	MyFunction(pArray, dwdCount); // вызов БОЛЬШОЙ ф-ции
}

Я только имя переменной изменил немного - терпеть ненавижу когда имя переменной на тим смахивает.

[Finch]

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

[Джон]

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

зы Вить, а конкретизация и не требуется. Поэтому я и сказал, что твоё решение не совсем то, что требуется. У Лёшки типичная перегрузка ф-ции с разными параметрами.

[Джон]

Да, в 6ой вторая часть не работает. Не может разрешить перегрузку в случае с массивом указателей.

[Finch]

Да кстати, у тебя зарыта мина замедленного действия . Если в классе будут динамические переменные, могут быть некоторые трудноотлавливаемые баги. Если например приложение многопоточное

[Джон]

В 6ой версии нужен явный кастинг при вызове

вместо MyFunction(pObj, 2);  ->  MyFunction((MyClass*)pObj, 2);

Так работает.