STL文件组成(加<>的目的是为了更好的说明其文件特性)
1：<climits>内中包含limits.h文件，在limits.h文件内，定义了每种内置类型的bit，字节，最大最小数等,部分内容如下。
#define CHAR_BIT 8 /* number of bits in a char */
#define SCHAR_MIN (-128) /* minimum signed char value */
…
#define INT_MIN (-2147483647 - 1) /* minimum (signed) int value
#define INT_MAX 2147483647 /* maximum (signed) int value */
其中还包括#include <yvals.h>，这个文件是Microsoft需要的文件，具体内容和STL有关
#if defined(__cplusplus)
#define _STD_BEGIN namespace std {
#define _STD_END }
#define _STD ::std::
就是定义std宏。
这个文件中还定义vc编译器需要的环境变量，库（在其他文件内声明#include <use_ansi.h>），_Lockit类， _Mutex类，线程等
VC7.1中使用的STL依然是P.J. Plauger的STL库，如下是摘抄climits文件内的版权说明,本来偶还认为从VC7.0开始，就是用自己开发的STL库，原来还是使用的P.J.Plauger版本的STL库，不知道VC8.0有没有改变
/*
* Copyright (c) 1992-2002 by P.J. Plauger. ALL RIGHTS RESERVED.
* Consult your license regarding permissions and restrictions.
V3.13:0009 */
2：<utility>,定义STL中pair模版类和相关的函数，我们常用的make_pair函数就是在这个文件中定义，其原型为
template<class _Ty1,
class _Ty2> inline
pair<_Ty1, _Ty2> __cdecl make_pair(_Ty1 _Val1, _Ty2 _Val2)
{ // return pair composed from arguments
return (pair<_Ty1, _Ty2>(_Val1, _Val2));
}
可见是返回pair的一个临时对象（当然可以直接返回值优化掉，不用担心），根据文件最后的注释，发现这个pair是1994年HP定义的版本STL（好老啊）
文件中还包括#include <iosfwd>，
3: <cstdio>,内部包括stdio.h文件，并在cstdio中声明using ::size_t;等，同时文件也包括#include <yvals.h>，microsoft定义的一个文件，里面有很多宏定义，决定如何STL使用，在后面的很多文件内都包含此文件，将不在一一列出。
4：<cstring>,内部包含string.h文件，此文件内定义的是操作字符串的函数集，在此文件内，大部分宏的声明与stdio.h文件内的宏声明相同。不知道为什么ms要如此做，这里声明了我们常用的strcmp,strstr,memcpy等函数
5：<iosfwd>,内部包括#include <cstdio>，#include <cstring>，#include <cwchar>，#include <xstddef>，内部声明模版fpos类（TEMPLATE CLASS fpos (from <streambuf>)）并声明streampos，其原形为
typedef fpos<mbstate_t> streampos; // 其中mbstate_t为int类型
typedef streampos wstreampos;，
之后声明模版类char_traits(TEMPLATE STRUCT char_traits (FROM <string>)), 然后有char和wchar的两个特化char_traits，最后声明各种i/o操作的类，根据iosfwd的名字我们不难推断出来（fwd是forword的缩写），这个文件是为了提前声明io操作的文件，以方便编译使用。
6：<cwchar>,内部包含wchar.h文件，主要定义了关于操作宽字符的函数，宏，类型等
7：<xstddef>，定义一些宏，主要是异常宏的声明，内部包含stddef.h文件，此文件中主要定义一些公共宏，函数和类型
8：<xutility>文件内#include <climits>，#include <utility>，这个文件比较长，主要声明的是迭代器相关类// TEMPLATE CLASS iterator
template<class _Category,
class _Ty,
class _Diff = ptrdiff_t,
class _Pointer = _Ty *,
class _Reference = _Ty&>
struct iterator
{ // base type for all iterator classes
typedef _Category iterator_category;
typedef _Ty value_type;
typedef _Diff difference_type;
typedef _Diff distance_type; // retained
typedef _Pointer pointer;
typedef _Reference reference;
};
还有一些对比函数比如lexicographical_compare，fill，equal，mismatch，copy_backward等函数
9：<iterator>迭代器类中主要包含文件就是#include <xutility>，此类中定义迭代器类front_insert_iterator，back_insert_iterator，insert_iterator等
10：<memery>类包含#include <iterator>，#include <xmemory>，memery类中定义大量操作内存的函数，大部分函数都是STL内部调用。不过这里面有一个我们非常熟悉的模版类auto_ptr
// TEMPLATE CLASS auto_ptr
template<class _Ty>
class auto_ptr;
struct auto_ptr_ref
{ // proxy reference for auto_ptr copying
auto_ptr_ref(auto_ptr<_Ty>& _Right)
: _Ref(_Right)
{ // construct from compatible auto_ptr
}
auto_ptr<_Ty>& _Ref; // reference to constructor argument
};
template<class _Ty>
class auto_ptr
{ // wrap an object pointer to ensure destruction
public:
typedef _Ty element_type;
explicit auto_ptr(_Ty *_Ptr = 0) _THROW0()
: _Myptr(_Ptr)
{ // construct from object pointer
}
auto_ptr(auto_ptr<_Ty>& _Right) _THROW0()
: _Myptr(_Right.release())
{ // construct by assuming pointer from _Right auto_ptr
}
auto_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()
: _Myptr(_Right._Ref.release())
{ // construct by assuming pointer from _Right auto_ptr_ref
}
template<class _Other>
operator auto_ptr<_Other>() _THROW0()
{ // convert to compatible auto_ptr
return (auto_ptr<_Other>(*this));
}
template<class _Other>
operator auto_ptr_ref<_Other>() _THROW0()
{ // convert to compatible auto_ptr_ref
return (auto_ptr_ref<_Other>(*this));
}
template<class _Other>
auto_ptr<_Ty>& operator=(auto_ptr<_Other>& _Right) _THROW0()
{ // assign compatible _Right (assume pointer)
reset(_Right.release());
return (*this);
}
template<class _Other>
auto_ptr(auto_ptr<_Other>& _Right) _THROW0()
: _Myptr(_Right.release())
{ // construct by assuming pointer from _Right
}
auto_ptr<_Ty>& operator=(auto_ptr<_Ty>& _Right) _THROW0()
{ // assign compatible _Right (assume pointer)
reset(_Right.release());
return (*this);
}
auto_ptr<_Ty>& operator=(auto_ptr_ref<_Ty>& _Right) _THROW0()
{ // assign compatible _Right._Ref (assume pointer)
reset(_Right._Ref.release());
return (*this);
}
~auto_ptr()
{ // destroy the object
delete _Myptr;
}
_Ty& operator*() const _THROW0()
{ // return designated value
return (*_Myptr);
}
_Ty *operator->() const _THROW0()
{ // return pointer to class object
return (&**this);
}
_Ty *get() const _THROW0()
{ // return wrapped pointer
return (_Myptr);
}
_Ty *release() _THROW0()
{ // return wrapped pointer and give up ownership
_Ty *_Tmp = _Myptr;
_Myptr = 0;
return (_Tmp);
}
void reset(_Ty* _Ptr = 0)
{ // destroy designated object and store new pointer
if (_Ptr != _Myptr)
delete _Myptr;
_Myptr = _Ptr;
}
private:
_Ty *_Myptr; // the wrapped object pointer
};
通过源代码分析，我们可以看到auto_ptr并没有什么神秘的，他定义一个代理对象保存其指针对象（当然也可以不这么做），并且通过源代码我们就可以清楚认识到对象所有权的转移，如果使用boost的shared_ptr（使用引用计数机制）就不会有对象所有权的转移，这里唯一需要解释的是在一些类的定义前面有这么一句template<class _Other>，在函数前使用template<class _Other>的目的就是可以使auto_ptr接受（处理）不同于原类型的指针或者auto_ptr对象，这种限制在类的继承体系中十分有用，具体参考2。