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

[Джон]

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

Ну эт ты загнул. Бездоказательно. Чем этот метод отличается от любого другого метода перегрузки ф-ций? И потом, "мой" работает и на 6ой тоже.

зы "Твой" всё-равно возьму на заметку. Я с 6ой уже давно не работаю и уже наверное не буду, разве проекты старые подправить придётся. Я тоже про нечто подобное подумал, но не додумал реализацию.
Правда ещё не знаю, где такое применять буду, но как говорится век живи, век учись, дураком помрёшь.
По любому - спасибо.

[Finch]

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

[Алексей++]

это всё не то. Я, наверное, просто объяснить не могу никак, что мне надо (( А надо:

Код:

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

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

то есть задача решена, если X - абсолютно одинаков в обоих шаблонах. Пока этого нету, кроме как решения в лоб в №62

[Алексей++]

фсё, я упал спать, дитё вроде заснуло, и мне пора )

[Джон]

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

Бывает, время то позднее. Пора спать. Завтра очередной поход - собирать урожай яиц, принесённых беспокойным зайцем. ДетЯм радость...

Как у вас там празднуется? Даже и не знаю что говорится, нуу типа с Песахом... и ещё этой - звездой. в общем.

[Finch]

Леш, а можно узнать, чем тебе решение в посте №80 не нравится?

[Джон]

это всё не то. Я, наверное, просто объяснить не могу никак, что мне надо (( А надо:

Час от часу не легче. Лёш, просто вместо точек напиши что у тебя такое Х?

[Finch]

Джон, кстати когда у Вас то Пасха начнется?

[Алексей++]

Finch, №80 - это пост Джона Там два шаблона с разным кодом. Если ты имел в виду №82, то он не компилится тоже

[Алексей++]

это всё не то. Я, наверное, просто объяснить не могу никак, что мне надо (( А надо:

Час от часу не легче. Лёш, просто вместо точек напиши что у тебя такое Х?

X - это некое выражение, возвращающее ссылку на объект, неважно, как он был указан в шаблоне - int или int*

[Finch]

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

[Джон]

Там два шаблона с разным кодом.

Лёш, там просто второй шаблон вызывает первый.

[Джон]

Да, я пример в #80 уже подправил. Там ещё 6ка ругнулась на имя конструктора, но это не принципиально.

[Джон]

X - это некое выражение, возвращающее ссылку на объект, неважно, как он был указан в шаблоне - int или int*

Пока вся разница заключается в передачи в ф-ю либо массива объектов, либо массива указателей.
Повторяю вопрос ОТКУДА БЕРЁТСЯ ЭТОТ Х В ОБОИХ СЛУЧАЯХ? Код покажи.

[Джон]

Джон, кстати когда у Вас то Пасха начнется?

Короче у нас вчера какой-то Карфрайтаг был - праздник (в смысле выходной). А завтра и в понедельник соответственно пасхальное воскресенье и пасхальный понедельник. Но в деталях я не разбираюсь, а народ - кто что говорит. А разбираться я в очередной раз не хочу, ибо опять забуду.

[Джон]

Так всё я тоже пошёл спать.

Лёш, когда проснёшься - внимательно изучи ситуацию. ИМХО ты сам запутался и попытался нас запутать. СУдя по уточнённой задачи тело ф-ций у тебя в обоих случаях одинаково, отличаются они только параметрами, поэтому действует перегрузка ф-ций. Никакой перегрузки оператора у тебя не наблюдается. Просто в одном случае тебе твой объект Х надо получить из массива объектов, а в другом из массива указателей. Короче меня интересует в обоих ф-ях код

T X =

[Алексей++]

Джон, не должно и не может быть никаких вызовов одного шаблона из другого тут

Код:

//работа с массивом элементов T
template<T>
void WorkWithArrayOfT(T* Array, DWORD dwdCount)
{
}

Например,

1) сортируем МАССИВ CString

Код:

CString Arr[10];

WorkWithArrayOfT<CString>(Arr,10);

2) сортируем МАССИВ УКАЗАТЕЛЕЙ на CString.

Код:

CString* Arr[10];
for(DWORD dwd=0; dwd<10; dwd++)
{
   Arr[dwd]=new CString;
}

WorkWithArrayOfT<CString*>(Arr,10);

В первом случае критерий сравнения (внутри шаблона)

Код:

T* t1=&Arr[0];
T* t2=&Arr[1];
if( *t1 < *t2)
{
  ...
}

Во втором случае

Код:

T* t1=&Arr[0];
T* t2=&Arr[1];
if( **t1 < **t2)
{
  ...
}

вот и видим, что длиннбщий код отличается всего одной строчкой.

А один шаблон для обоих случаев:

Код:

//работа с массивом элементов T
template<T,const bool bTisPointer>
void WorkWithArrayOfT(T* Array, DWORD dwdCount)
{
  T* t1=&Arr[0];
  T* t2=&Arr[1];

  bool bCriteria=false;
  if(!bTisPointer)
  {
    if( *t1 < *t2 )
//  if( *((T*)&t1) < *((T*)&t2))
    {
       bCriteria=true;
    }
  }
  else
  {
    if( *((T**)&t1) < *((T**)&t2))
    {
       bCriteria=true;
    }
  }

  if(bCriteria)
  {
  }
  else
  {
  }
}

//сортировка теперь выглядит так

//1)массив
WorkWithArrayOfT<CString,false>(Arr,10);

//2)массив указателей
WorkWithArrayOfT<CString*,true>(Arr,10);

[Dimka]

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

Спрашивается, что это за тип, у которого гарантированно определён или задекларирован метод? Это некий класс, возможно, абстрактный.

Шаблон, поскольку тип параметра неизвестен и не предопределён, хорош для передачи только данных. Это простые типы, структуры без методов или объекты, от которых внутри параметризированного класса не требуется никакого поведения (пример - все контейнеры: векторы, списки и т.п.). Все операции над такими элементами (например, сортировка) осуществляются без использования методов таких элементов, а с использованием внешних по отношению к элементам функций. И это будет хороший дизайн.

[Алексей++]

dimka, обязательные свойства класса T для этого шаблона: должны быть определены операторы "=" и "<" . Но именно для класса экземпляра, а не для указателя на класс.
Но дело вообще говоря не в подходе, мне тоже не очень нравится приведение к T* или T**, но два раза писать длинный одинаковый шаблон не хочется ) Проще оговорить в описании шаблона элементарные правила пользования

[Алексей++]

кстати, о птичках. Бой бубен для указателей не работает

Всё таки придётся два шаблона делать Некрасиво

[Dimka]

два раза писать длинный одинаковый шаблон не хочется ) Проще оговорить в описании шаблона элементарные правила пользования

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

Два раза писать и не надо. Достаточно определить интерфейс для элемента массива и (если нужно) фабрику элементов массива. После чего реализовывать эти интерфейсы в каждом конкретном случае.

[Алексей++]

dimka, всё теория, теория... А на примере ?

Достаточно определить интерфейс для элемента массива

например, для типа DWORD

[Dimka]

например, для типа DWORD

Тип DWORD относится к тому, о чём я сказал:

Шаблон, поскольку тип параметра неизвестен и не предопределён, хорош для передачи только данных. Это простые типы, структуры без методов или объекты, от которых внутри параметризированного класса не требуется никакого поведения (пример - все контейнеры: векторы, списки и т.п.). Все операции над такими элементами (например, сортировка) осуществляются без использования методов таких элементов, а с использованием внешних по отношению к элементам функций. И это будет хороший дизайн.

Исходный вопрос:

//работа с массивом элементов 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();
   ...
}

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

[Алексей++]

метод не нужен, нужно выражение, возвращающее в обоих шаблонах ссылку на объект класса

[Джон]

Лёш, я согласен с Димкой. У тебя на данном этапе отстутствует конструктивная формулировка задачи. В самом началае ты привёл задание с двумя ф-ми, одна из которых получает в качестве параметра массив указателей, а дургая массив объектов. Ну и в чём проблема. Всё было вроде бы понятно. Потом ты говоришь, что тебе нужна только одна ф-я (один шаблон) с массивом объектов. Теперь ты снова возвращаешься к  двум шаблонам. Такое ощущение, что ты пытаешься это решить "как-нибудь лишь бы получилось".  Это больше похоже на попытки решить концептуальную проблему средствами одного конкретно взятого языка, на одной конкретно взятой системе. Со всеми вытекающими отсюда последствиями.

Если всё-таки #109, то ничего некрасивого в этом нет. Это классический способ перегрузки ф-ций с разными параметрами. Чего ты голову морочишь? Сравни:

Код:

int MyFunc(int nParam)
{
    return nParam*nParam;
}

int MyFunc(CString stParam)
{
    int nParam = _tstoi(stParam);
    return MyFunc(nParam);
}

[Алексей++]

Джон, с задачей всё предельно просто:

шаблон №1 сортирует элементы массива. То есть он их переставляет.
шаблон №2 сортирует массив указателей на элементы массива. То есть он изменяет массив указателей, не затрагивая массив с элементами.

Видим, что делается абсолютно одно и тоже. Разница только в сравнении элементов:
T* t1=Array[0];
T* t2=Array[1];

#1) T есть "класс элемента" , тупо сравниваем *t1<*t2
#2) T есть "указатель на экземпляр класса элемента" , нужно бы сравнить сравниваем **t1<**t2 , чего, естественно компилятор не даст сделать


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

Пример для того же DWORD - покажите ?

[Вад]

Алексей1153++, а может, стоит посмотреть в сторону реализации std::sort в STL? Она что хошь сортирует.

[Алексей++]

Вад, не, не то это. Массив указателей по возрастанию того, на что указывают, сортирует ?

---------
я ж это... вы не подумайте, что я вот вдруг решил всем моск вынести непонятной проблемой, которую я себе создал. Спишем всё на студию№6 , так как Финч же предложил решение, только оно тут не компилится.

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

[Вад]

Алексей1153++, сортирует, конечно. Какую функцию сравнения передашь 3м аргументом - так и отсортирует. Я к тому, что реализация сортировки - типовое такое решение для обобщённого алгоритма. Откуда ему знать, как ты хочешь элементы сравнивать?

[Алексей++]

Вад, я понял, мне нужно просто определить структурку для указателя, скажем

Код:

srtuct myDWORDp
{
  DWORD* m_p;
  
  bool (operator<)(const myDWORDp& m)
  {
     return *m_p < *m.m_p;
  }
}

и массив таких указателей и передать на сортировку