list类的使用与泛型编程

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

//使用模板的原因：类型不同，操作相同，就可以封装成模板
//体现泛型编程的动机--通用
template< class T >//此处class也可以被typename代替
class MyList : public std::list< T >
{
public:
	
    //重载+=，插入某条链表的末尾，表示链接
	MyList& operator += ( const MyList& rcMyList) { if( ! rcMyList.empty() ) { insert( this->end(), rcMyList.begin(), rcMyList.end());} return *this; } // leszek
    T popBack()                           { T cT = this->back(); this->pop_back(); return cT;  }
    T popFront()                          { T cT = this->front(); this->pop_front(); return cT; }
    void pushBack(const  T& rcT )     //&表引用    
	{ 
		if( sizeof(T) == sizeof(void*)) 
		{ 
			if( rcT != NULL )
			{ 
				push_back( rcT );
			} 
		} 
	} // Fix crash with Linux 64 systems. -Dong
    void pushFront( const T& rcT )        
	{ 
		if( sizeof(T) == sizeof(void*)) 
		{ 
			if( rcT != NULL )
			{
			   	push_front( rcT);
			}
	   	} 
	}
    typename std::list<T>::iterator  find( const T& rcT ) {  return std::find( this->begin(), this->end(), rcT ); } // leszek,使用了遍历
};

typedef struct PicBuffer_
{
	std::string strPic;
	int count;
}PicBuffer;

typedef MyList< PicBuffer* > PicBufferList;
//typedef typename int Int;//typename只能在模板里使用

int main()
{
   std::string str1("hello world");
   str1 = "hello world!";
   int n = str1.find("hello");   //n = 0
   int m = str1.find("hello", 5);//m = -1
   int k = str1.find("world", 6);//k = 6
   PicBuffer tPicBuffer1;
   //memset(&tPicBuffer1, 0x00, sizeof(tPicBuffer1));//含有string不能memset，会core down，可能是把string变量的地址置为0x00
   tPicBuffer1.strPic = "hello";//象这样初始化
   tPicBuffer1.count = 0;
   PicBuffer tPicBuffer2;
   //memset(&tPicBuffer2, 0x00, sizeof(tPicBuffer2));
   tPicBuffer2.strPic = "world";
   tPicBuffer2.count = 1;
   
   PicBufferList tPicBufferList;

   //下面四个只能按顺序弹回给自己,否则会出现段错误
   tPicBufferList.pushBack(&tPicBuffer1);//&表取地址
   tPicBufferList.pushBack(&tPicBuffer2);
   tPicBufferList += tPicBufferList; 
   memcpy(&tPicBuffer2, tPicBufferList.popBack(), sizeof(tPicBuffer2));
   memcpy(&tPicBuffer1, tPicBufferList.popBack(), sizeof(tPicBuffer1)); 

   //tPicBufferList.find(&tPicBuffer1);//此处编译不过去!!!（*）
   /*
   if( NULL == tPicBufferList.find(&tPicBuffer1))
   {
	   printf("Not Find!");
   }
   */
   //memcpy与snprintf的区别：memcpy可以拷贝任何类型相同的数据，因为它使用的是泛型void*，而snpintf只能使用char*
   //而snprintf的好处是能够拷贝的字符串长度
   //在window上是_snprintf
   return 0;
}

//上述typename的使用称为嵌套依赖类型名，如果去掉typename，则不是合法的 C++，不会被编译器识别，但此处是例外
//告诉 C++ C::const_iterator 是一个 type（类型）取得一个 container（容器）和这个 container
//（容器）中的一个 iterator（迭代器）的 function template（函数模板）


//如果你觉得读 std::iterator_traits<IterT>::value_type 令人讨厌，就想象那个与它相同的东西来代表它。
//所以上述代码可以写成 
//typedef std::list<T>::iterator MyIterator;
//MyIterator find( const T& rcT ) {  return std::find( this->begin(), this->end(), rcT ); }
//参考链接:http://dev.yesky.com/13/2221013.shtml

对于模板，不同的参数实例化出不同的重载函数，所以在（*）会如下报错：
main.cpp: In member function ‘typename std::list<T, std::allocator<_CharT> >::iterator MyList<T>::find(const T&) [with T = PicBuffer*]’:
main.cpp:75:   instantiated from here
main.cpp:38: error: no matching function for call to ‘find(std::_List_iterator<PicBuffer*>, std::_List_iterator<PicBuffer*>, PicBuffer* conX
即编译只对真正实例化时，才会去编译出实例的机器代码。没调用到相关的成员函数，就不会进行严格的类型检查！编译器不会报错。

因为template没有强的检查机制，因此写出来的模板，必须实例化才能验证。

另外外C++使用模板的缺点是导致程序程序编译速度极慢无比，生成的执行程序尺寸超常。

相关链接：http://blog.csdn.net/whinah/article/details/2315356 关键是要讨论如何高效利用  扬长避短等