C++ STL — 第2章 介绍C++和标准库

语言特性：

1. Templates模板

template < class  T>
inline  const  T& max( const  T& a,  const  T& b)
{
    return  a < b ? b : a;
}

无类型的模板参数

bitset<32> bit32;
bitset<52> bit51;

默认模板参数

template < class  T,  class  container=vector<T> >
class  MyClass;

MyClass< int > x;   // equal to MyClass<int, vector<int> >

typename作用

//作为模板形惨
template < typename  T>
class  MyClass;

//使用嵌套依赖类型,typename后面的是类型名称而不是成员函数或变量
template < class  T>
class  MyClass {
    //ptr is a pointer to type T::SubType
    typename  T::SubType * ptr;
};

模板成员member template

class  MyClass {
    template < class  T>
    void  f(T);
};

template < class  T>
class  MyClass {
private :
    T value;
public :
    void  assign( const  MyClass<T>& x)
    {
        value = x.value;
    }
    //x 必须和*this拥有同样的类型
};

void  f()
{
    MyClass< double > d;
    MyClass< int > i;
    d.assign(d);   //ok
    d.assign(i);   //error
}

template < class  T>
class  MyClass {
private :
    T value;
public :
    template < class  X>
    void  assign( const  MyClass<X>& x)
    {
        value = x.getValue;
    }
    T getValue()  const
    {
        return  value;
    }
};

void  f()
{
    MyClass< double > d;
    MyClass< int > i;
    d.assign(d);   //ok
    d.assign(i);   //ok
}

template < class  T>
class  MyClass<T> {
public :
    template < class  U>
    MyClass( const  MyClass<U> &other);
};

void  f()
{
    MyClass< double > d;
    MyClass< double > d2(d);  //call内置的拷贝构造函数
    MyClass< int > i(d);  //call 模板构造函数
}

嵌套模板类

template < class  T>
class  MyClass {
    ...
    template < class  T2>
    class  NestedClass;
};

2. 初始化基础类型

int  i1;  //没有初始化
int  i2 =  int ();  //初始化为0

template < class  T>
void  f()
{
    //保证了如果T是基础类型，一定初始化为0
    T t = T();
};

3. 异常处理

class  Error;
void  f()
{
    if (exception)
    {
        throw  Error();
    }
}

int  main()
{
    try  {
        f();
    }  catch  ( const  Error& e) {
        //处理异常
    }
}

4. 命名空间namespace

//避免名字冲突  引入命名空间
namespace  FSU {
    class  MyClass;
    void  f();

    namespace  HTTP {
        class  HTTPHandle;
    }
}

//使用namespace  ：：
int  main()
{
    FSU::MyClass myClass;
    FSU::f();
    FSU::HTTP::HTTPHandle handle;
}

//使用namespace另一种方法
//using namespace FSU;
using  FSU::MyClass;    //推荐使用这种办法

5. bool类型

//只有两个值 true和false
//0 is false , and other is true
bool  flag =  true ;

6. explicit关键字

class  Stack
{
    //避免隐式转换
    explicit  Stack( int  size);
};

Stack stack1(50);   //ok
Stack stack2 = 50;   //error

7. C++ 类型转换

//static_cast
float  f;
cout <<  static_cast < int >(f) << endl;  //print f as int type
f( static_cast <string>( "string" ));  //call f() for string type

//dynamic_cast
class  Car;   //Car 至少有一个虚函数，抽象基类
class  BlueCar :  public  Car {};
class  RedCar :  public  Car {};

void  f(Car* pCar)
{
    BlueCar* pBlueCar =  dynamic_cast <BlueCar*>(pCar);
    if (pBlueCar == NULL) {
        //pBlueCar 不是指向BlueCar的对象
    }
}

//const_cast
//消除const限定
const  int  a = 9;
const  int * pA = &a;
int * b =  const_cast < int *>(pA);
*b = 99;

//reinterpret_cast 在编译期处理，可能不安全
//最常在函数指针类型之间的转换
typedef  void  (*FuncPtr)();
FuncPtr funcPtrArray[10];
int  doSomething();
funcPtrArray[0] = &doSomething;  //error,函数返回值不匹配
funcPtrArray[0] =  reinterpret_cast <FuncPtr>(&doSomething); //ok

8. static const member 的初始化

class  MyClass {
public :
    static  const  int  i = 9;  //only inteter can
};

//定义式
const  int  MyClass::i;   //不用再初始化了

9. 大O复杂度

常量	O(1)	runtime决定于元素的数目
对数	O( log(n) )	对数曲线
线性	O(n)	线性增长
n-log-n	O( n*log(n) )
平方	O(n*n)	平方