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

[Dimka]

Алгоритм sort реализован ещё в C десятки лет назад.

Функция qsort определена в stdlib.h

Код: (C++)

void qsort(void *base, size_t nelem, size_t width, int (*fcmp)(const void *, const void *));

Пример из help к Turbo C++ 3.0:

Код: (C++)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int sort_function(const void *a, const void *b);

char list[5][4] = { "cat", "car", "cab", "cap", "can" };

int main(void)
 {
  int x;
  qsort((void *)list, 5, sizeof(list[0]), sort_function);
  for (x = 0; x < 5; x++)
    printf("%s\n", list[x]);
  return 0;
 }

int sort_function(const void *a, const void *b)
 {
  return( strcmp((char *)a,(char *)b) );
 }

Функция сравнения должна возвращать отрицательное число, 0 или положительное число для a<b, a=b и a>b соответственно.

[Вад]

Алексей1153++, проще всего определить независимую функцию (как вариант: статический метод класса) сравнения двух указателей, которая сравнивает то, на что они указывают. Можно отдельным функтором оформить. В качестве параметра передавать, соответственно, функцию или экземпляр функтора.
Не думаю, что переопределение операции сравнения для указателей является лучшим вариантом.

В общем, я бы сделал что-то вроде:

Код:

template<typename Type_>
bool compare_val_by_ptr( Type_* left, Type_* right )
{
	return (*left) < (*right);
}

//...
std::vector<int*> vec;
std::sort(vec.begin(), vec.end(), compare_val_by_ptr<int>);

(если подумать, то, наверное, можно и покрасивее)

[Алексей++]

Вад, ну я для указателей и не переопределял, а только для класса myDWORDp )

--------
я там в структуре подправил, не то имел в виду )

[Антон (LogRus)]

я бы сделал вот так

Использование Boost Pointer Container Library: http://blog.alno.name/2009/04/using-boost-ptr-containers/

[Алексей++]

как сделать шаблон для генерации типов, инкапсулирующих "простые" типы ?


нужно, чтобы получилось нечто вроде (но это спотыкается на объявлении переменных)

Код:

template<class T,T defaultVal,const char* TXTname>
class X
{
	T m_par;

	public:

	X()
	{
		m_par=defaultVal;
	}

	const T& (operator=) (const T& src)
	{
		m_par=src;
		return m_par;
	}

	operator T&()
	{
		return m_par;
	}

	const char* GetTextName()
	{
		return TXTname;
	}
};

//объявление
X<int,0,"параметр1"> m_1;
X<CString,"0","параметр2"> m_2;
X<BYTE,0,"параметр3"> m_3;

//работа с объектом должна происходить точно так же, как будто работаем просто с мембером m_par, например :
void F()
{
	CString t;
	t=m_2;
	m_2=t;
	m_2="1111111";
}

компилятор пишет

 недопустимое выражение в качестве аргумента шаблона для 'TXTname'

[Dimka]

Параметры шаблона должны быть константами, не могущими изменяться в runtime - аналог макросов, а ты объявляешь указатель char *, для представления которого нужна переменная с хранящимся внутри неё адресом.

Кроме того, твой объект не умеет работать с другими такими объектами. Например, ещё надо добавить что-то типа:

Код: (C++)

const X<T>& (operator=) (const X<T>& src)
{
        m_par=src;
        return m_par;
}

Или я не понимаю, как этим пользоваться "прозрачно".

[Алексей++]

как таки задать строку ещё на этапе компиляции ? Или только через конструктор придётся ?

А про const X<T>& - это точно , не подумал )) Но если бы в коде встретилась необходимость, дошло бы

[Dimka]

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

Код: (C++)

template<const char *s>
class X {/*...*/};

/* Строковая константа обязательно в глобальной области видимости
   (или namespace), которая не удаляется при завершении какой-нибудь
   функций (даже main). */
char s[] = "Test";

int main()
{
  X<s> x;
}

[Алексей++]

попробую. Хотя мне это не нравится, лучше затолкну название через конструктор

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

[Алексей++]

а возможно ли сделать в шаблоне условную компиляцию по типу T ? Навроде

if(тип T == CString)
{
   T=T.Left(10);
}
else
{
}

[Вад]

Ну, скажем, у Александреску есть такой вариант, построенный на специализации шаблона:

Код:

template <int v>
struct IntToType
{
    enum {value = v };
};

template <class T, class U> 
struct SameType
{
    enum { result = false };
};

template <class T> 
struct SameType<T, T>
{
    enum {result = true };
};

// ... 
void Foo(Type& T, IntToType<true>)
{
   T=T.Left(10);
}

void Foo(Type&, IntToType<false>)
{
}

void Foo(Type& T)
{
    Foo(T, IntToType<SameType<Type, CString>::result>());
}

Сделал на коленке, не проверял работоспособность Но принцип примерно такой

[Антон (LogRus)]

Алексей1153++, возможно
читаем Вандервуда 15.2 Type Functions
===============
15.2.2 Determining Class Types
With the following type function we can determine whether a type is a class type:

Код:

// traits/isclasst.hpp 

template<typename T> 
class IsClassT { 
  private: 
    typedef char One; 
    typedef struct { char a[2]; } Two; 
    template<typename C> static One test(int C::*); 
    template<typename C> static Two test(…); 
  public: 
    enum { Yes = sizeof(IsClassT<T>::test<T>(0)) == 1 }; 
    enum { No = !Yes }; 
}; 

This template uses the SFINAE (substitution-failure-is-not-an-error) principle of Section 8.3.1 on page 106. The key to exploit SFINAE is to find a type construct that is invalid for function types but not for other types, or vice versa. For class types we can rely on the observation that the pointer-to-member type construct int C::* is valid only if C is a class type.

The following program uses this type function to test whether certain types and objects are class types:

Код:

// traits/isclasst.cpp 

#include <iostream> 
#include "isclasst.hpp" 

class MyClass { 
}; 

struct MyStruct { 
}; 

union MyUnion { 
}; 

void myfunc() 
{ 
} 

enumE{e1}e; 

// check by passing type as template argument 
template <typename T> 
void check() 
{ 
    if (IsClassT<T>::Yes) { 
        std::cout << " IsClassT " << std::endl; 
    } 
    else { 
        std::cout << " !IsClassT " << std::endl; 
    } 
} 

// check by passing type as function call argument 
template <typename T> 
void checkT (T) 
{ 
    check<T>(); 
} 

int main() 
{ 
    std::cout << "int: "; 
    check<int>(); 

    std::cout << "MyClass: "; 
    check<MyClass>(); 

    std::cout << "MyStruct:"; 
    MyStruct s; 
    checkT(s); 

    std::cout << "MyUnion: "; 
    check<MyUnion>(); 

    std::cout << "enum:    "; 
    checkT(e); 

    std::cout << "myfunc():"; 
    checkT(myfunc); 
}

The program has the following output:

Код:

int:      !IsClassT 
MyClass:  IsClassT 
MyStruct: IsClassT 
MyUnion:  IsClassT 
enum:     !IsClassT 
myfunc(): !IsClassT 

[Вад]

А, я думал, требуется вообще раздельная компиляция. Так-то ничто не мешает просто использовать SameType при ветвлении.

[Алексей++]

Вад, ага, вроде то что то похожее на правду, вот в таком виде подошло:

Код:

template <int v>
struct TypesIsSAME
{
    enum {value = v };
};

template <class T, class U> 
struct IsTypesSame
{
    enum { result = false };
};

template <class T> 
struct IsTypesSame<T, T>
{
    enum {result = true };
};

template<class T>
class X
{
	void Foo(TypesIsSAME<true>)
	{
	   m_par=m_par.Left(10);
	}

	void Foo(TypesIsSAME<false>)
	{
		m_par*=1;
	}
public:
	void Foo()
	{
		TypesIsSAME< IsTypesSame<T, CString>::result > isSame_CString;
		Foo(isSame_CString);
	}



	T m_par;
};

а как не только один тип отличить, а вообще что то вроде свича по типам сделать ? )) (Это не нужно сейчас, но интересно)

LogRus, ещё не вник, щас разбираюсь в написанное )

[Алексей++]

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

TypesIsSAME< IsTypesSame<T, ТИП>::result > isSame_ТИП;

, только придётся каждую нестандартную функцию делать в двух видах - наполненную и пустую

[Вад]

а как не только один тип отличить, а вообще что то вроде свича по типам сделать ? )) (Это не нужно сейчас, но интересно)

Поскольку программирование в шаблонах чисто функциональное (то есть, там нельзя просто сформировать последовательность действий, в том числе циклы и ветвления), придётся использовать списки типов и построение рекурсивной иерархии типов. Подробно можно почитать про списки типов у того же Александреску, там довольно внятно разбирается

Впрочем, если нужно разделять "один тип - одно действие", и ветвление выполняется в runtime, то достаточно модифицировать подход с SameType.

Код:

template <class Type>
struct TypeToType
{
};


// ... 
template<class T>
void Foo(Type&, TypeToType<T>){}

void Foo(Type& T, TypeToType<CString>)
{
   T=T.Left(10);
}

void Foo(Type&, TypeToType<CMyClass>)
{
}

void Boo(Type& T)
{
    Foo(T, TypeToType<Type>());
}

и - да, придётся делать пустую реализацию, если нужен default.

[Алексей++]

и - да, придётся делать пустую реализацию, если нужен default.

причём, для каждого использованного типа )

[Антон (LogRus)]

Алексей1153++, используй буст

Впрочем, если нужно разделять "один тип - одно действие", и ветвление выполняется в runtime, то достаточно модифицировать подход с SameType.

фишка в том что переход выполняется в compile time (точнее выкидывается весь не нужный код), т.к. выражение константно

так всё я запутался

[Алексей++]

LogRus, давай распутаю ))

[Вад]

LogRus, да, ты прав.
Точнее, если Type разный - значит, Boo принадлежит шаблону (или является шаблонной функцией), и будет скомпилировано ровно столько реализаций, сколько нужно, для каждого Type, на самом верхнем уровне вызова

[Алексей++]

имеется такой код

Код:

	class defaultClass
	{
	};


	template<class T=defaultClass>
	class A
	{
		T m_t;
	};

можно ли сделать defaultClass безымянным, что-то вроде

Код:

	template<class T=class{}>
	class A
	{
		T m_t;
	};

?

[Алексей++]

ещё вопрос: покажите пример переопределения аллокатора. Не могу даже просто унаследовать, запутался в лабиринтах типов:

Код:

		class A
		{
		};

		template<class T>
		class CMyAl:public std::allocator<T>
		{
			
		public:
			template<class _Other>
			struct rebind
			{
				typedef CMyAl<_Other> other;
			};
			

			/*
			...
			*/
		};

		typedef std::map<int,A,std::less<int>,CMyAl<A> > td_map;

		td_map Amap;

ошибка

Код:

error CMyAl<T>::CMyAl(const CMyAl<T> &) throw(): невозможно преобразовать параметр 1 из 'CMyAl<T>' в 'const CMyAl<T> &'
...
...

[lapulya]

Он же тебе говорит, хочу копирующий конструктор, так сделай его

Код:

	CMyAl(const CMyAl<T> & p) throw() {}
	CMyAl() throw() {}

ЗЫ (Важно!!!)
Да, до кучи... надо 2 раза подумать, прежде чем наследоваться от классов stl, дело в том, что они не имеют виртуальных деструкторов!!!

[lapulya]

Алексей1153++,

можно ли сделать defaultClass безымянным, что-то вроде

зачем?

[Алексей++]

lapulya, да мне пофиг на его деструкторы ) Свой сделаю. А насчёт копирующего - где это написано, я вот так и не понял бы сам

Или предлагаешь не наследоваться, а вообще полностью весь код аллокатора содрать и переписать ?

зачем?

занадом )) Ну я уже понял, что нельзя

[Dimka]

да мне пофиг на его деструкторы ) Свой сделаю.

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

[lapulya]

Алексей1153++, ну для начала, как сказал димка, можно получить утечки. Потом речь идет обо ВСЕХ классах stl (кроме ексепшена вроде), а нетолько об аллокаторе.

Я бы не наследовался (смысла большого нет), если ты пишешь свой аллокатор, то функции выделения и освобождения памяти ты и так перепишешь, а все остальное там только служебное (конструкторы и деструкторы).

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

[Алексей++]

да мне пофиг на его деструкторы ) Свой сделаю.

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

слова, слова... На примере бы показал ) Над чем трясётесть то

Ну, то есть, наследоваться не стОит, а просто скопировать интерфейс и переписать ?

[Dimka]

Алексей1153++, и когда ты матчасть выучишь...

Ну попробуй запусти нижеследующее. Не знаю, что быстрее случится: core dump или ты Ctrl-C нажать успеешь...

Код: (C++)

class A
{
private:
 int *data;
public:
 A():
  data(new int[1000000])
 {
 }
 ~A()
 {
  delete[] data;
 }
};

class B:
 public A
{
private:
 int *anotherData;
public:
 B():
  A(), anotherData(new int[1000000])
 {
 }
 ~B()
 {
  delete[] anotherData;
 }
};

int main()
{
 for(;;)
 {
  A *a = new B();
  delete a;
 }
 return 0;
}

В этом вся разница между виртуальным и невиртуальным деструкторами в суперклассе.

[Алексей++]

Дык я знаю разницу между виртуальным и не виртуальным деструктором, только к данному случаю то это какое отношение

А  "Ctrl-C" - это о чём ? У мну в студии нет такого сочетания )