#include <stdio.h>
#include <vector>

int main(int argc, char *argv[])
{
        std::vector<int> vec;

        vec.push_back(2);

        return 0x0;
}

# gcc -v -o test test.cpp -lstdc++
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/4.8.5/lto-wrapper
Target: x86_64-redhat-linux
Configured with: ../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-bootstrap --enable-shared --enable-threads=posix --enable-checking=release --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-linker-hash-style=gnu --enable-languages=c,c++,objc,obj-c++,java,fortran,ada,go,lto --enable-plugin --enable-initfini-array --disable-libgcj --with-isl=/builddir/build/BUILD/gcc-4.8.5-20150702/obj-x86_64-redhat-linux/isl-install --with-cloog=/builddir/build/BUILD/gcc-4.8.5-20150702/obj-x86_64-redhat-linux/cloog-install --enable-gnu-indirect-function --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux
Thread model: posix
gcc version 4.8.5 20150623 (Red Hat 4.8.5-44) (GCC) 
COLLECT_GCC_OPTIONS='-v' '-o' 'test' '-mtune=generic' '-march=x86-64'
 /usr/libexec/gcc/x86_64-redhat-linux/4.8.5/cc1plus -quiet -v -D_GNU_SOURCE test.cpp -quiet -dumpbase test.cpp -mtune=generic -march=x86-64 -auxbase test -version -o /tmp/ccF9VG8N.s
GNU C++ (GCC) version 4.8.5 20150623 (Red Hat 4.8.5-44) (x86_64-redhat-linux)
        compiled by GNU C version 4.8.5 20150623 (Red Hat 4.8.5-44), GMP version 6.0.0, MPFR version 3.1.1, MPC version 1.0.1
GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include-fixed"
ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../x86_64-redhat-linux/include"
#include "..." search starts here:
#include <...> search starts here:
 /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5
 /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/x86_64-redhat-linux
 /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/backward
 /usr/lib/gcc/x86_64-redhat-linux/4.8.5/include
 /usr/local/include
 /usr/include
End of search list.
GNU C++ (GCC) version 4.8.5 20150623 (Red Hat 4.8.5-44) (x86_64-redhat-linux)
        compiled by GNU C version 4.8.5 20150623 (Red Hat 4.8.5-44), GMP version 6.0.0, MPFR version 3.1.1, MPC version 1.0.1
GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
Compiler executable checksum: 51b2dcccf6085e5bfbbf3932e5685252
COLLECT_GCC_OPTIONS='-v' '-o' 'test' '-mtune=generic' '-march=x86-64'
 as -v --64 -o /tmp/ccaJ99rj.o /tmp/ccF9VG8N.s
GNU assembler version 2.27 (x86_64-redhat-linux) using BFD version version 2.27-43.base.el7_8.1
COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/4.8.5/:/usr/libexec/gcc/x86_64-redhat-linux/4.8.5/:/usr/libexec/gcc/x86_64-redhat-linux/:/usr/lib/gcc/x86_64-redhat-linux/4.8.5/:/usr/lib/gcc/x86_64-redhat-linux/
LIBRARY_PATH=/usr/lib/gcc/x86_64-redhat-linux/4.8.5/:/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../:/lib/:/usr/lib/
COLLECT_GCC_OPTIONS='-v' '-o' 'test' '-mtune=generic' '-march=x86-64'
 /usr/libexec/gcc/x86_64-redhat-linux/4.8.5/collect2 --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o test /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../lib64/crt1.o /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/4.8.5/crtbegin.o -L/usr/lib/gcc/x86_64-redhat-linux/4.8.5 -L/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../.. /tmp/ccaJ99rj.o -lstdc++ -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/lib/gcc/x86_64-redhat-linux/4.8.5/crtend.o /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../lib64/crtn.o

#ifndef __STL_CONFIG_H
# define __STL_CONFIG_H

// Flags:
// * __STL_NO_BOOL: defined if the compiler doesn't have bool as a builtin
//   type.
// * __STL_HAS_WCHAR_T: defined if the compier has wchar_t as a builtin type.
// * __STL_NO_DRAND48: defined if the compiler doesn't have the drand48 
//   function.
// * __STL_STATIC_TEMPLATE_MEMBER_BUG: defined if the compiler can't handle
//   static members of template classes.
// * __STL_STATIC_CONST_INIT_BUG: defined if the compiler can't handle a
//   constant-initializer in the declaration of a static const data member
//   of integer type.  (See section 9.4.2, paragraph 4, of the C++ standard.)
// * __STL_CLASS_PARTIAL_SPECIALIZATION: defined if the compiler supports
//   partial specialization of template classes.
// * __STL_PARTIAL_SPECIALIZATION_SYNTAX: defined if the compiler 
//   supports partial specialization syntax for full specialization of
//   class templates.  (Even if it doesn't actually support partial 
//   specialization itself.)
// * __STL_FUNCTION_TMPL_PARTIAL_ORDER: defined if the compiler supports
//   partial ordering of function templates.  (a.k.a partial specialization
//   of function templates.)
// * __STL_MEMBER_TEMPLATES: defined if the compiler supports template
//   member functions of classes.
// * __STL_MEMBER_TEMPLATE_CLASSES: defined if the compiler supports 
//   nested classes that are member templates of other classes.
// * __STL_TEMPLATE_FRIENDS: defined if the compiler supports templatized
//   friend declarations.
// * __STL_EXPLICIT_FUNCTION_TMPL_ARGS: defined if the compiler 
//   supports calling a function template by providing its template
//   arguments explicitly.
// * __STL_LIMITED_DEFAULT_TEMPLATES: defined if the compiler is unable
//   to handle default template parameters that depend on previous template
//   parameters.
// * __STL_NON_TYPE_TMPL_PARAM_BUG: defined if the compiler has trouble with
//   function template argument deduction for non-type template parameters.
// * __SGI_STL_NO_ARROW_OPERATOR: defined if the compiler is unable
//   to support the -> operator for iterators.
// * __STL_DEFAULT_CONSTRUCTOR_BUG: defined if T() does not work properly
//   when T is a builtin type.
// * __STL_USE_EXCEPTIONS: defined if the compiler (in the current compilation
//   mode) supports exceptions.
// * __STL_USE_NAMESPACES: defined if the compiler has the necessary
//   support for namespaces.
// * __STL_NO_EXCEPTION_HEADER: defined if the compiler does not have a
//   standard-conforming header <exception>.
// * __STL_NO_BAD_ALLOC: defined if the compiler does not have a <new>
//   header, or if <new> does not contain a bad_alloc class.  If a bad_alloc
//   class exists, it is assumed to be in namespace std.
// * __STL_SGI_THREADS: defined if this is being compiled for an SGI IRIX
//   system in multithreaded mode, using native SGI threads instead of 
//   pthreads.
// * __STL_WIN32THREADS: defined if this is being compiled on a WIN32
//   compiler in multithreaded mode.
// * __STL_PTHREADS: defined if we should use portable pthreads
//   synchronization.
// * __STL_UITHREADS: defined if we should use UI / solaris / UnixWare threads
//   synchronization.  UIthreads are similar to pthreads, but are based 
//   on an earlier version of the Posix threads standard.
// * __STL_LONG_LONG if the compiler has long long and unsigned long long
//   types.  (They're not in the C++ standard, but they are expected to be 
//   included in the forthcoming C9X standard.)
// * __STL_THREADS is defined if thread safety is needed.
// * __STL_VOLATILE is defined to be "volatile" if threads are being
//   used, and the empty string otherwise.
// * __STL_USE_CONCEPT_CHECKS enables some extra compile-time error
//   checking to make sure that user-defined template arguments satisfy
//   all of the appropriate requirements.  This may result in more
//   comprehensible error messages.  It incurs no runtime overhead.  This 
//   feature requires member templates and partial specialization.
// * __STL_NO_USING_CLAUSE_IN_CLASS: The compiler does not handle "using"
//   clauses inside of class definitions.
// * __STL_NO_FRIEND_TEMPLATE_CLASS: The compiler does not handle friend
//   declaractions where the friend is a template class.
// * __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE: The compiler does not
//   support the use of a function pointer type as the argument
//   for a template.
// * __STL_MEMBER_TEMPLATE_KEYWORD: standard C++ requires the template
//   keyword in a few new places (14.2.4).  This flag is set for
//   compilers that support (and require) this usage.


// User-settable macros that control compilation:
// * __STL_USE_SGI_ALLOCATORS: if defined, then the STL will use older
//   SGI-style allocators, instead of standard-conforming allocators,
//   even if the compiler supports all of the language features needed
//   for standard-conforming allocators.
// * __STL_NO_NAMESPACES: if defined, don't put the library in namespace
//   std, even if the compiler supports namespaces.
// * __STL_NO_RELOPS_NAMESPACE: if defined, don't put the relational
//   operator templates (>, <=. >=, !=) in namespace std::rel_ops, even
//   if the compiler supports namespaces and partial ordering of
//   function templates.
// * __STL_ASSERTIONS: if defined, then enable runtime checking through the
//   __stl_assert macro.
// * _PTHREADS: if defined, use Posix threads for multithreading support.
// * _UITHREADS:if defined, use SCO/Solaris/UI threads for multithreading 
//   support
// * _NOTHREADS: if defined, don't use any multithreading support.  
// * _STL_NO_CONCEPT_CHECKS: if defined, disables the error checking that
//   we get from __STL_USE_CONCEPT_CHECKS.
// * __STL_USE_NEW_IOSTREAMS: if defined, then the STL will use new,
//   standard-conforming iostreams (e.g. the <iosfwd> header).  If not
//   defined, the STL will use old cfront-style iostreams (e.g. the
//   <iostream.h> header).

// Other macros defined by this file:

// * bool, true, and false, if __STL_NO_BOOL is defined.
// * typename, as a null macro if it's not already a keyword.
// * explicit, as a null macro if it's not already a keyword.
// * namespace-related macros (__STD, __STL_BEGIN_NAMESPACE, etc.)
// * exception-related macros (__STL_TRY, __STL_UNWIND, etc.)
// * __stl_assert, either as a test or as a null macro, depending on
//   whether or not __STL_ASSERTIONS is defined.


#endif /* __STL_CONFIG_H */

// Local Variables:
// mode:C++
// End:

#include <iostream>
using namespace std;

template <typename T>
class testClass{
public:                    //纯粹为了方便测试，使用public
	static int _data;
};

//为static data members 进行定义（配置内存），并设置初值
int testClass<int>::_data = 1;
int testClass<char>::_data = 2;


int main(int argc, char *argv[])
{
	cout<<testClass<int>::_data<<endl;
	cout<<testClass<char>::_data<<endl;
	
	testClass<int> obji1, obji2;
	testClass<char> objc1, objc2;
	
	cout<<obji1._data<<endl;
	cout<<obji2._data<<endl;
	cout<<objc1._data<<endl;
	cout<<objc2._data<<endl;
	
	obji1._data = 3;
	objc2._data = 4;
	
	cout<<obji1._data<<endl;
	cout<<obji2._data<<endl;
	cout<<objc1._data<<endl;
	cout<<objc2._data<<endl;
	
	return 0x0;
}

# gcc -o test test.cpp -lstdc++
test.cpp:11:5: error: specializing member ‘testClass<int>::_data’ requires ‘template<>’ syntax
 int testClass<int>::_data = 1;
     ^
test.cpp:12:5: error: specializing member ‘testClass<char>::_data’ requires ‘template<>’ syntax
 int testClass<char>::_data = 2;
     ^

//为static data members 进行定义（配置内存），并设置初值
template <> int testClass<int>::_data = 1;
template <> int testClass<char>::_data = 2;

#include <iostream>
using namespace std;


//一般化设计
template <class I, class O>
struct testClass
{
  testClass() {cout<<"I, O"<<endl; }
};

//特殊化设计
template <class T>
struct testClass<T *, T*>
{
  testClass() {cout<<"T *, T*"<<endl; }
};

//特殊化设计
template <class T>
struct testClass<const T *, T*>
{
  testClass() {cout<<"const T *, T*"<<endl; }
};


int main(int argc, char *argv[])
{
	testClass<int, char> obj1;
	testClass<int *, int *> obj2;
	testClass<const int *, int *> obj3;
	
	return 0x0;
}

#include <iostream>
using namespace std;

class alloc{
};

template <class T, class Alloc = alloc>
class vector{
public:
	void swap(vector<T, Alloc> &){
		cout<<"swap()"<<endl;
	}
};

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER                     //只为说明，非本程序内容
template<class T, class Alloc>
inline void swap(vector<T, Alloc> &x, vector<T, Alloc> &y){
	x.swap(y);
}
#endif                                                       //只为说明，非本程序内容


//以上节录自stl_vector.h，灰色部分系源代码中的条件编译，非本测试程序内容
int main(int argc, char *argv[])
{
	vector<int> x, y;
	
	swap(x, y);
	
	return 0x0;
}

#include <iostream>
using namespace std;

template <class T>
class vector{
public:
	template <class TT> 
	void test(TT a, TT b) {
		cout << a << ' ' << b << endl; 
	}
};


int main(int argc, char *argv[])
{
	vector<int> vec;
	
	vec.test<int>(3, 4);
	
	return 0x0;
}

//file: test.cpp
//测试 class template之内是否可再有template (members)

#include <iostream>
using namespace std;

class alloc{
};

template <class T, class Alloc = alloc>
class vector{
public:
	typedef T value_type;
	typedef value_type * iterator;
	
	template <class I>
	void insert(iterator position, I first, I last){
		cout<<"insert()"<<endl;
	}
};

int main(int argc, char *argv[]){
	int ia[5] = {0,1,2,3,4};
	
	vector<int> x;
	vector<int>::iterator ite;
	
	x.insert(ite, ia, ia + 5);
	
	return 0x0;
}

//file: test.cpp
//测试template 参数可否根据前一个template参数而设定默认值
//ref. C++ Primer 3/e, p.816

#include <iostream>
using namespace std;

class alloc{
};

template <class T, class Alloc = alloc, size_t BufSize = 0>
class deque{
public:
	deque(){cout<<"deque"<<endl;}
};

//根据前一个参数值T，设定下一个参数Sequence的默认值为deque<t>
template <class T, class Sequence = deque<T> >
class stack{
public:
	stack(){cout<<"stack"<<endl;}
	
private:
	Sequence c;
};


int main(int argc, char *argv[]){

	stack<int> x;
	
	return 0x0;
}

//file: test.cpp
//测试class template可否拥有non-type template参数
//ref. C++ Primer 3/e, p.825

#include <iostream>
#include <cstddef>             //for size_t 
using namespace std;

class alloc{
};

inline size_t __deque_buf_size(size_t n, size_t sz)
{
	return n != 0 ? n : (sz < 512 ? size_t(512 / sz) : size_t(1));
}

template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator{
	typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
	typedef __deque_iterator<T, const T&, const T*, Bufsiz> const_iterator;
	
	static size_t buffer_size(){
		return __deque_buf_size(BufSiz, sizeof(T));
	}
};


template <class T, class Alloc = alloc, size_t BufSiz = 0>
class deque{
public:
	//Iterators
	typedef __deque_iterator<T, T&, T*, Bufsiz> iterator;
	
	
};

int main(int argc, char *argv[]){

	cout<<deque<int>::iterator::buffer_size() <<endl;
	cout<<deque<int, alloc, 64>::iterator::buffer_size()<<endl;
	
	return 0x0;
}

# gcc -o test test.cpp -lstdc++
test.cpp:20:50: error: ‘Bufsiz’ was not declared in this scope
  typedef __deque_iterator<T, const T&, const T*, Bufsiz> const_iterator;
                                                  ^
test.cpp:20:56: error: template argument 4 is invalid
  typedef __deque_iterator<T, const T&, const T*, Bufsiz> const_iterator;
                                                        ^
test.cpp:32:38: error: ‘Bufsiz’ was not declared in this scope
  typedef __deque_iterator<T, T&, T*, Bufsiz> iterator;
                                      ^
test.cpp:32:44: error: template argument 4 is invalid
  typedef __deque_iterator<T, T&, T*, Bufsiz> iterator;
                                            ^
test.cpp: In function ‘int main(int, char**)’:
test.cpp:39:20: error: ‘deque<int, alloc, 0ul>::iterator’ is not a class or namespace
  cout<<deque<int>::iterator::buffer_size() <<endl;
                    ^
test.cpp:40:31: error: ‘deque<int, alloc, 64ul>::iterator’ is not a class or namespace
  cout<<deque<int, alloc, 64>::iterator::buffer_size()<<endl;

# ifdef __STL_EXPLICIT_FUNCTION_TMPL_ARGS
#   define __STL_NULL_TMPL_ARGS <>
# else
#   define __STL_NULL_TMPL_ARGS
# endif

// in <stl_stack.h>

template <class T, class Sequence = deque<T> >
class stack{
	friend bool operator== __STL_NULL_TMPL_ARGS(const stack&, const stack&);
	friend bool operator< __STL_NULL_TMPL_ARGS(const stack&, cont stack&);
	
	...
};

template <class T, class Sequence = deque<T> >
class stack{
	friend bool operator== <> (const stack&, const stack&);
	friend bool operator< <> (const stack&, cont stack&);
	
	...
};

//file: test.cpp
//测试__STL_NULL_TMPL_ARGS in <stl_config.h>
//ref. C++ Primer 3/e, p.834: bound friend function template

#include <iostream>
#include <cstddef>             //for size_t
using namespact std;

class alloc{
};

template <class T, class Alloc = alloc, size_t BufSiz = 0>
class deque{
public:
	deque(){
		cout<<"deque"<<endl;
	}
};

//以下声明如果不出现，GCC也可以通过；如果出现，GCC也可以通过。这一点和
//C++ Primer 3/4 p834的说法有出入。书上说一定要有这些前置声明
/*
template <class T, class Sequence>
class stack;

template <class T, class Sequence>
bool operator==(const stack<T, Sequence>& x, const stack<T, Sequence> &y);

template <class T, class Sequence>
bool operator<const stack<T, Sequence>& x, const stack<T, Sequence> &y);
*/


template <class T, class Sequence = deque<T> >
class stack{
	//写成这样是可以的
	friend bool operator== <T> (const stack<T> &, const stack<T> &);
	friend bool operator< <T> (const stack<T> &, const stack<T> &);
	
	//写成这样也是可以的
	friend bool operator== <T> (const stack &, const stack &);
	friend bool operator< <T> (const stack &, const stack &);
	
	//写成这样也是可以的
	friend bool operator== <> (const stack &, const stack &);
	friend bool operator< <> (const stack &, const stack &);
	
	//写成这样就不可以
	friend bool operator== (const stack &, const stack &);
	friend bool operator< (const stack &, const stack &);
	
public:
	stack(){
		cout<<"stack"<<endl;
	}
	
private:
	Sequence c;
};

template <class T, class Sequence>
bool operator==(const stack<T, Sequence>& x, const stack<T, Sequence> &y)
{
	return cout<<"operator=="<<'\t';
}

template <class T, class Sequence>
bool operator<const stack<T, Sequence>& x, const stack<T, Sequence> &y)
{
	{
	return cout<<"operator<"<<'\t';
}


int main(int argc, char *argv[])
{
	stack<int> x;                //deque stack
	stack<int> y;                //deque stack 
	
	cout<<(x == y)<<endl;        //operator ==
	cout<<(x < y) <<endl;        //operator <
	
	stack<char> y1;              //deque stack 
	//cout<<(x == y1) <<endl;    //error: no match for ...
	//cout<<(x < y1) <<endl;     //error: no match for ...
	
	return 0x0;
}