模板特化

#include <cstdio>
#include <iostream>
#include <stdexcept>

template<typename T>
class my_vector{
private:
     T * array;
     unsigned size;
     unsigned block_size;
public:
    my_vector(unsigned bsz):array((T*)malloc(sizeof(T)*block_size),size(0),
                              block_size(size){
                              }
    ~my_vector(){
         if(array){
               free(array);
         }
    }
    
    void push_back(const T& v) throw (std::runtime_error){
           if(size==block_size){
                  block_size*=2;
                  T *new_array=realloc(array,block_size*sizeof(T));
                  if(new_array!=NULL){
                        array=new_array;
                  }
                  
                  else{
                         free(array);
                         array=NULL;
                         throw std::runtime_error("Out of memory.");
                  }
           }
           array[size++]=elem;
    }
    
    T& operator[] (unsigned i) {return array[i];}
    const T& operator[] (unsigned i) const{return array[i];}
    
    //告诉我们占了多少内存
    unsigned get_mem_size() const{return block_size*sizeof(T);}
};


template<>
class my_vector<bool>{
private:
       int *array;
       unsigned size;
       unsigned block_size;
       //一个段(segment)即一个整数值,段大小为一个整数值所能容纳的最多布尔值
       const static unsigned seg_size;
public:
       my_vector(unsigned bsz):array((int*)malloc(sizeof(int)*bsz),size(0),
                                                       block_size(bsz){
                                                       }
       
       ~my_vector(){
              if(array){
                    free(array);
              }
       }
       
       void push_back(bool elem) throw (std::runtime_error){
               if(size==block_size){
                     block_size*=2;
                     int *new_array=(int*)realloc(array,sizeof(int)*block_size);
                     if(new_array){
                           array=new_array;
                     }
                     
                     else{
                          free(array);
                          array=NULL;
                          throw std::runtime_error("Out of memory.");
                     }       
               }
               
              set(size++,elem);
      }
      
      void set(unsigned i,bool elem){
             if(elem){
                   array[i/seq_size] |=(0x1 << (i%seq_size));
             }
             
             else{
                   array[i/seq_size] &=~(0x1 << (i%seq_size));
             }
      }
      
      bool operator[] (unsigned i) const{
             return array[i/seq_size] & (0x1 << (i%seq_size))!=0;
      }
      
      unsigned get_mem_size() const{
            return block_size* sizeof(int);
      }
};

const unsigned my_vector<bool>::seq_size =sizeof(int)*8;