Geekban极客班C++ 第四周

转换函数

operator double() const { 
      return (double)m_numerator / m_denominator; 
    }//转换函数

Fraction f(3,5);
double d=4+f;

operator double() const为转换函数，将对象的类型转换为double。
在执行d=4+f，编译器先寻找是否重载了+符合表达式的要求，若没有在找是否有转换函数，改变f的类型。

non-explicit-one-argument ctor

one-augument只要一个实参就够了

class Fraction
{
public:
    Fraction(int num, int den=1):m_numerator(num), m_denominator(den){}
    Fraction operator+(const Fraction& f) {} 
}

Fraction d2=f+4;

执行d2=f+4时，编译器发现operator+,但是函数里的参数是Fraction对象，看能否将4转为Fraction对象，找到了Fraction( , )，转为Fraction(4,1)。

explicit-one-argument ctor

explict明确的，只让其拥有构造函数的功能

pointer-like classes,智能指针

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){}
};
share_ptr<Foo> sp(new Foo)//创建一个新的指针
Foo f(*sp);//返回得到*px
sp->method();//返回得到px，其中->符号要继续作用，等同于px->method()

智能指针其内部一定带着一个一般的指针
一定要operator * ->

模板偏特化

两种偏特化：1.个数的偏，2：范围的偏

template<typename T,typename Alloc=...>//两个模板参数
class vector
{
..
}
template<typename Alloc=...>//一个模板参数
class vector<bool,Alloc>//将一个模板参数定为bool

范围的偏：若T为任意类型，可将其设为指针，指向任意类型

template<typename T>
class C {};//不是指针调用这
template<typename T>
class C <T*> {}//是指针调用这

variadic templates模板参数可变化

void print(){}
template<typename T,typename... Types>
void print(const T& firstArg,const Types&...args)//接受一个参数，和一包参数
{
   cout<<firstArg<<endl;
   print(args...);//递归
}

print(7.5,"hello",bitset<16>(377),42);

执行过程：接受一个参数7.5，接受剩下的一包参数，再次调用print(),接受一个参数“hello”,和剩下的一包参数，再次递归调用print。当调用至最后一个参数时，将0传入，调用失败,另写一个不要参数的print()。

…就是一个所谓的pack
用于template parameters,就是模板参数包
用于function parameter types,就是函数参数类型包
用于function parameters,就是函数参数包

ranged-base for

for(decl:coll)//decl变量，coll容器
{
   statement
   }

编译器从容器中一个个取出数据。

vectoer<double> vec;
....
for( auto elem : vec){
   cout<<elem<<endl;
}
for( auto& elem: vec){
   elem*=3;
}//传引用，将值乘以3

reference的常见用途

reference通常不用于声明变量，而用于参数类型和返回类型的描述。

double imag(const double& im){...}
double imag(const double  im){...}

上述两个函数不能同时存在。再调用时，编译器不知该调用哪个函数。
const是函数声明的一部分