控制模板实例化

1. 可以显示的告诉编译器对某种类型进行实例化，比如：

#include "sorted.h"
#include "integer.h"

//Explicit instantiation:
template class sorted<integer>;

int main()
{
	....
	return 1;
}

2. 加入对于某种类型模板不适用，就需要对这种类型进行模板特例化，从而遇到这种类型时，编译器给他匹配正确的方法。比如sorted的bubblesort方法中需要用“>”对元素进行比较，但是如果元素是char*，就不适用了，比如：

sorted.h

#ifndef SORTED_H_
#define SORTED_H_

#include <stdlib.h>
#include <string>
#include <time.h>
#include "Tstash.h"
#include "set.h"

template<class T>
class sorted : public tstash<T>
{
	void bubblesort();
public:
	sorted() : tstash(no){}
	int add(T* element)
	{
		tstash<T>::add(element);
		bubblesort();
		return 0;
	}
};

template<class T>
void sorted<T>::bubblesort()
{
	for (int i = count(); i > 0; i--)
	{
		for (int j = 1; j < i; j++)
		{
			if (*storage[j - 1] > *storage[j])
			{
				T* t = storage[j - 1];
				storage[j - 1]  = storage[j];
				storage[j] = t;
			}
		}
	}
}

template<class T>
class sortedSet : public set<T>
{
	sorted<T> Sorted;
public:
	void add(T& e)
	{
		if (contains(e)) return;
		set<T>::add(e);
		Sorted.add(new T(e));
	}
	T& operator[](int index)
	{
		assert(index >= 0 && index < length());
		assert(Sorted[index]);
		return *Sorted[index];
	}
	int length()
	{
		return Sorted.count();
	}
};

template<int upper_bound>
class urand
{
	int map[upper_bound];
	int recycle;
public:
	urand(int Recycle = 0);
	int operator()();
};

template<int upper_bound>
urand<upper_bound>::urand(int Recycle /* = 0 */) : recycle(Recycle)
{
	memset(map, 0, upper_bound * sizeof(int));
	time_t t;
	srand((unsigned)time(&t));
}

template<int upper_bound>
int urand<upper_bound>::operator ()()
{
	if (!memchr(map, 0, upper_bound))
	{
		if (recycle)
		{
			memset(map, 0, sizeof(map) * sizeof(int));
		}
		else
		{
			return -1;
		}
	}
	int newval;
	while(map[newval = rand() % upper_bound]);
	map[newval]++;
	return newval;
}

#endif

special.cpp

#include "sorted.h"
#include <iostream>
using namespace std;

template<>
class sorted<char> : public tstash<char>
{
	void bubblesort();
public:
	sorted() : tstash(no){}
	int add(char* element)
	{
		tstash<char>::add(element);
		bubblesort();
		return 0;
	}
};

void sorted<char>::bubblesort()
{
	for (int i = count(); i > 0; i--)
	{
		for (int j = 1; j < i; j++)
		{
			if (strcmp(storage[j], storage[j - 1]) < 0)
			{
				char* t = storage[j - 1];
				storage[j] = storage[j - 1];
				storage[j - 1] = t;
			}
		}
	}
}

char* words[] = {"is", "running", "big", "dog", "a"};
const int wsz = sizeof(words) / sizeof(words[0]);

int main()
{
	sorted<char> sc;
	for (int k = 0; k < wsz; k++)
	{
		sc.add(words[k]);
	}
	for (int l = 0; l < sc.count(); l++)
	{
		cout << sc[l] << endl;
	}


	system("pause");
	return 1;
}