Использование шаблонов, c++ Опции

[klem4]

Есть хедер type.h, вот его содержимое :

//Структуры для хранения данных и ключей в массиве
# ifndef _DATA    // защита от повторного  включения этого файла
# define _DATA    // в другой
# include <iostream.h>
# ifdef  _NUMBER //ключ - число (типа int, long, float и т.д.)
//шаблоны позволяют использовать один и тот же код
//для различных типов данных и ключей
template <class Key,class Data>
struct Record
	{Key key;
	 Data data;
	//перегрузка операций > и < для сравнения ключей структур
	 int   operator > ( Record & b) {return key > b.key;}
	 int  operator < ( Record & b) 	{return key < b.key;}
	 int  operator <= ( Record & b) 	{return key <= b.key;}
	 int  operator == ( Record & b) 	{return key == b.key;}
   // перегрузка операции = для ключа
	 void operator = (Key n){key=n};
   //печать ключа
	 void PrnKey (){ cout << key<<' ';}
	};
//обмен
template <class Key,class Data>
inline   void  swap(Record<Key,Data> & a,Record<Key,Data> & b )
	{Record<Key,Data> t;
	 t=a;a=b;b=t;
	}
//обмен, если 1-ый ключ > 2-го
template <class Key,class Data>
inline   void  IfMoreThenSwap(Record<Key,Data> & a,Record<Key,Data> & b )
	{if (a > b) { Record<Key,Data> t; t=a;a=b;b=t;}
	}
// сравнение ключей
template <class Key,class Data>
inline   int  compare (Record<Key,Data> & a,Record<Key,Data> & b )
	{return a>b?1:a==b?0:-1;
	}
# elif defined _STR_N //ключ - строка длиной LEN_STR
# include <string.h>
//в программе перед  # include <type.h> определять  const LEN_STR = число;
typedef char Key[LEN_STR+1];  //+1 для хранения признака конца строки - '\0'
template <class Data> struct Record
	{Key key;
	 Data data;
	//перегрузка операций > и < для сравнения ключей структур
	 int   operator > ( Record & b)
			{return _fstrcmp(key,b.key)>0;
			}
	 int  operator < ( Record & b)
			{return _fstrcmp(key,b.key)<0;
			}
	 int  operator <= ( Record & b)
			{return _fstrcmp(key,b.key)<=0;
			}
	 int  operator == ( Record & b)
			{return _fstrcmp(key,b.key) == 0;
			}
	 void operator = ( char *s); //запись ключа в структуру типа Record
	 void PrnKey() { char *w=key; cout << w <<' ';}
   }
template <class Data>
	 int  compare ( Record<Data> & a, Record<Data> &  b)
			{return _fstrcmp(a.key,b.key);}
template <class Data>
 void  Record<Data> :: operator = ( char *s)
  {
   int j=0;
   for(;j<LEN_STR && *s !='\0';j++) key[j] =*s++;
   key[j]='\0';
  }
# elif defined _CHAR_PTR    //ключ - строка  Си
# include <string.h>
 // т.к. С++ не допускает перегрузки операций для встроенных типов
 // создадим обертку для char * в виде структуры
typedef struct Key { char * key_ptr;};
template <class Data> struct Record
	{Key key;    //ключ
	 Data data;  //данные
	 //перегрузка операций > и < для сравнения ключей структур
	 int  operator > ( Record & b)
			{return _fstrcmp(key.key_ptr,b.key.key_ptr)>0;
			}
	 int  operator < ( Record & b)
			{return _fstrcmp(key.key_ptr,b.key.key_ptr)<0;
			}
      //запись ключа в структуру типа Record	 
 void operator = (char *s) { key.key_ptr =s;} 
	 void PrnKey() { cout << key.key_ptr <<' ';}
	}//struc Record
	template <class T>
	inline   int  compare (Record<T> &  a,Record<T> & b )
	{return  _fstrcmp(a.key.key_ptr,b.key.key_ptr;)
	}
# endif //типа ключа 
//функции обмена для строк
//если ключ - строка длиной LEN_STR или указатель на char
# if defined _STR_N || defined _CHAR_PTR
//обмен
template <class Data>
inline   void  swap(Record<Data> & a,Record<Data> & b )
	{Record<Data> t;
	 t=a;a=b;b=t;
	}
//обмен, если 1-ый ключ > 2-го
template <class Data>
inline   void  IfMoreThenSwap(Record<Data> & a,Record<Data> & b )
	{if (a > b) { Record<Data> t; t=a;a=b;b=t;}
	}
# endif // строк
# endif //защиты от повторного использовани 

Вот то что написано в методичке (как надо работать с этим хэдером)

Первые два этапа выполняются на небольшом массиве, задаваемом программно в наиболее общем случае так :
Record <тип ключа, тип данных> ИмяМ%u

Сообщение отредактировано: volvo - 3.11.2006 12:08

[volvo]

.b - это вообще от куда взялось ?

Формальный параметр?

(Кстати, этот оператор надо бы перегружать вот так:

int operator > (const Record &b) {return key > b.key;}

- на всякий случай, чтобы объект по ссылке ни в коем случае не изменился, а то знаем мы этих любознательных экспериментаторов... )

Хм... Шаблон для вывода массивов...
Переопределяй для начала операцию вывода в ostream для Record-а:

// В любом месте ПОСЛЕ описания struct Record { ... }
template <class Key, class Data>
ostream&
operator << (ostream &os, Record<Key, Data> &r) {

  os << r.key << ", " << r.data << endl;
  return os;
}

// И в основной программе распечатывай весь свой массив:
int main() {
  Record<int, int> a[] = {{10, 10}, {12, 15}};

  long n = sizeof(a) / sizeof(a[0]);
  for(int i = 0; i < n; ++i)
	cout << (a[i]); // Вызывается переопределенная выше операция
  
  return 0;
}

P.S. На MinGW точно работает - проверил... Не уверен, что TC++ сможет это проглотить...