极客班

1.conversion function,转换函数

	class Fraction
	{
	public:
		Fraction(int num, int den=1)					//non-explicit-one-argument-ctor
			: m_numerator(num), m_denominator(den) {}
		
		operator double() const {
			return (double) (m_numerator / m_denominator);
		}
	private:	
		int m_numerator;	//分子
		int m_denominator;	//分母
	};
	Fraction f(3,5);
	double d = 4+f;			//调用operator double将 f 转为 0.6

2.non-explicit-one-argument-ctor

</pre></p><p><span style="white-space:pre">	</span><pre name="code" class="cpp">	class Fraction
	{
	public:
		Fraction(int num, int den=1)
			: m_numerator(num), m_denominator(den) {}
		Fraction operator+ (const Fraction& f) {
			return Fraction(...);
		}
	private:
		int m_numerator;
		int m_denominator;
	};
	Fraction f(3,5);
	Fraction d2 = f+4;	//调用 non-explicit ctor 将 4 转为 Fraction(4,1)
						//然后调用operator+

3.conversion function vs. non-explicit-one-argument-ctor

	class Fraction
	{
	public:
		Fraction(int num, int den=1)
			: m_numerator(num), m_denominator(den) {}
		operator double() const {
			return (double) (m_numerator / m_denominator);
		}
		Fraction operator+ (const Fraction& f) {
			return Fraction(...);
		}
	private:
		int m_numerator;		
		int m_denominator;		
	};
	Fraction f(3,5);
	Fraction d2 = f+4;	//[Error]ambiguous 歧义

4.explicit-one-argument-ctor

	class Fraction
	{
	public:
		explicit Fraction(int num, int den=1)
			: m_numerator(num), m_denominator(den) {}
		operator double() const {
			return (double) (m_numerator / m_denominator);
		}
		Fraction operator+ (const Fraction& f) {
			return Fraction(...);
		}
	private:
		int m_numerator;		
		int m_denominator;		
	};
	Fraction f(3,5);
	Fraction d2 = f+4;	//由于构造函数有explicit, 4不能转换成Fraction,所以失败

</pre><p>5.pointer-like classes,关于智能指针</p><p><span style="white-space:pre"><span style="white-space:pre"></span></span></p><pre name="code" class="cpp">	template <class T>
	class shared_ptr
	{
	public:
		T& operator*()
		{ return *px; }
		T* operator->()
		{ return &px; }
		shared_ptr(T* p) :px(p) {}
	private:
		T *px;
		long* pn;
	....
	};
	struct Foo
	{
		void method(void) {}
	};
	{
		shared_ptr<Foo> sp(new Foo);
		Foo f(*sp);
		sp->method();
	}

6.member template,成员模板

	template <class T1, class T2>
	struct pair {
		typedef T1 first_type;
		typedef T2 second_type;
		
		T1 first;
		T2 second;
		
		pair()
			: first(T1()), second(T2()) {}
		pari(const T1& a, const T2& b)
			: first(a), second(b) {}
			
		template <class U1, class U2>
		pair(const pair<U1, U2>& p)
			: first(p.first), second(p.second) {}
	};
	      T1      T2            U1        U2
	pair<Base1, Base2>p1(pair<Derived1, Derived2>)

7.specialization,模板特化

	template <class Key>
	struct hash {};
	
	template<>
	truct hash<char> {
		size_t operator()(char x) cosnt { return x; }
	};	
	template<>
	struct hash<int> {
		size_t operator()(int x) const { return x; }
	};
	template<>
	struct hash<long> {
		size_t operator()(long x) const { return x; }
	};

8.template template parameter,模板模板参数

	template<template T,
			template <typename T>
				class Smartptr
			>
	class XCls
	{
	private:
		Smartptr<T> sp;
	public:
		XCls() : sp(new T) {}
	};