stl源码分析de练习

// StlTest1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

template <typename T>
class print {
public:
	void operator()(const T& elem) {
		cout << elem << ' ';
	}
};

void TmpObjectTest() {
	int ia[6] = { 0,1,2,3,4,5 };
	vector<int> iv(ia, ia+6);
	for_each(iv.begin(), iv.end(), print<int>());
	std::cout << std::endl;
}
//=================================================
template <typename T>
class testClass {
public:
	static const int _datai = 5;
	static const long _datal = 3L;
	static const char _datac = 'c';
};

void InClassInit() {
	std::cout << testClass<int>::_datai << std::endl;
	std::cout << testClass<int>::_datal << std::endl;
	std::cout << testClass<int>::_datac << std::endl;
}
//==============================================
class INT {
	friend ostream& operator<<(ostream& os, const INT& i);
public:
	INT(int i) :m_i(i) {};
	INT& operator++() {
		++(this->m_i);
		return *this;
	}

	const INT operator++(int) {
		INT temp = *this;
		++(*this);
		return temp;
	}

	INT& operator--() {
		--(this->m_i);
		return *this;
	}

	const INT operator--(int) {
		INT temp = *this;
		--(*this);
		return temp;
	}

	int& operator*() const {
		return (int&)m_i;
	}

private:
	int m_i;
};

ostream& operator<<(ostream& os, const INT& i) {
	os << "[" << i.m_i << "]";
	return os;
}

void OperatorOverloading() {
	INT I(5);
	cout << I++;
	cout << ++I;
	cout << I--;
	cout << --I;
	cout << *I;
}

//==================================================
int main()
{
	TmpObjectTest();
	InClassInit();
	OperatorOverloading();
    return 0;
}

　　

// StlTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
//测试 class template 拥有 static data members。

#include <iostream>
using namespace std;

template <typename T>
class testClass {
public:
	static int _data;
	static T _td;
};

int testClass<int>::_data = 1;
int testClass<int>::_td = 2;
char testClass<char>::_td = 66;

void StaticTemplateMemberTest() {
	std::cout << testClass<int>::_data << std::endl;
	std::cout << testClass<int>::_td << std::endl;
	std::cout << testClass<char>::_td << std::endl;
}

//==========================================
template <class I,class O>
struct testClass1 {
	testClass1() { std::cout << "I,O" << std::endl; }
};

template <class T>
struct testClass1<T*, T*> {
	testClass1() { std::cout <<  "T*,T*" << std::endl; }
};

template <class T>
struct testClass1<const T*, T*> {
	testClass1() { std::cout << "const T*,T*" << std::endl; }
};

void ClassPartialSpecTest() {
	testClass1<int, char> obj1;
	testClass1<int*, int*> obj2;
	testClass1<const int*, int*> obj3;
}
//============================================
class alloc1 {};

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

template <class T,class Alloc1>
void swap1(vector1<T, Alloc1>& x, vector1<T, Alloc1>& y) {
	x.swap1(y);
}

void FuncTmplPartialOrder() {
	vector1<int> x, y;
	swap1(x, y);
}
//=============================================
class alloc2{};

template <class T,class Alloc2=alloc2>
class vector2 {
public:
	typedef T value_type;
	typedef value_type* iterator;

	template <class I>
	void insert(iterator position, I first, I last) {
		std::cout << "insert()" << std::endl;
	}
};

void MemberTemplates() {
	int ia[5] = { 0,1,2,3,4 };
	vector2<int> x;
	vector2<int>::iterator ite = NULL;
	x.insert(ite, ia, ia + 5);
}
//=============================================
class alloc3{};

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

template <class T, class Sequence = Deque3<T>>
class stack3 {
public:
	stack3() { cout << "stack" << endl; }
private:
	Sequence c;
};

void LimitDefaultTemplate() {
	stack3<int> x;
}
//============================================
class alloc4 {};

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 Alloc4 = alloc4,size_t BufSiz = 0>
class deque4 {
public:
	typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
};

void NonTypeTmplParamBug() {
	cout << deque4<int>::iterator::buffer_size() << endl;
	cout << deque4<int, alloc4, 64>::iterator::buffer_size() << endl;
}

//=============================================
int main()
{
	StaticTemplateMemberTest();
	ClassPartialSpecTest();
	FuncTmplPartialOrder();
	MemberTemplates();
	LimitDefaultTemplate();
	NonTypeTmplParamBug();
    return 0;
}