转换函数

class转换为其他类型

class Fraction{
public:
Fraction(int num,int den=1):m_numerator(num) ,m_denominator(den){}
operator double() const{ // 不能有参数,不能有返回类型,通常加const不会改变值
return (double)(m_number / m_denominator);
} // 将Fraction转换为double 认为合理都行
Fraction operater+(const Fraction& f){
return Fraction(...);
}
private:
int m_numerator;
int m_denominator;

}

Fraction f(3,5);
double d = 4+f; //调用operator double()将f转为0.6




template<class Alloc>
class vector<bool,Alloc> // 模版的偏刻画
{
public:
typedef __bit_reference reference;
protected:
reference operator[](size_type n){
return *(begin()+diffenece)
}
}

non-explicit-one-argument actor

class Fraction{
public:
explict Fraction(int num,int den=1):m_numerator(num) ,m_denominator(den){} //这就叫one-argument
operator double() const{ // 不能有参数,不能有返回类型,通常加const不会改变值 (1)
return (double)(m_number / m_denominator);
} // 将Fraction转换为double 认为合理都行 (2)
Fraction operater+(const Fraction& f){
return Fraction(...);
}
private:
int m_numerator;
int m_denominator;

}
Fraction f(3,5);
double d = f + 4;//调用的是non-exlicit ctor将4转换为Fraction,再调用operator
//(1)(2)共存的话会ambiguous

explicit-one-argument ctor

加上explicit就可以避免非隐调用,就不能从double 转为class

Pointer-like classes,关于智能指针

Auto-ptr 2.0之前

template<class T>
class shared_ptr{
public:
T& operator*() const{
return *px;
}
T* operator->() const{
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();
px->method(); // 等同于上一行 连续调用

Pointer-like classes,关于迭代器

template<class T>
struct __list_node{
void* prev;
void* next;
T data;
};

template<class T,class Ref,class Ptr>
struct __list_iterator{
typedef __list_iterator<T,Ref,Ptr> self;
typedef Ptr pointer;
typedef Ref reference;
typedef __list_node<T>* link_type;
link_type node;
bool operator==(const self& x) const{return node == x.node;}
bool operator!=(const self& x) const (return node != x.node;)
reference operator*() const{return (*node).data;}
pointer operator->() {return &(operator*());}
//使用的是上一个函数
self& operator++() {node =(link_type)((*node).next); return *this;}
self operator++(int) {self tmp = *this; ++*this;return tmp;}


}

function-like classes,所谓仿函数

template <class T>
struct identity{
const T&
operator()(const T& x) const {return x;}
};

template <class Pair>
struct select{
const typename Pair::first_
}

namespace

互不干扰,使用时::

class template

template<typename T>

fuction template

template <class T> 使用的时候不需要指明,会自己推导,不会比操作符重载。

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()){}
pair(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)
};

specialization