Effective C++: 防止template的膨胀.

2019独角兽企业重金招聘Python工程师标准>>>

假如我们用一个模板类封装一个矩阵的数据，如果矩阵的大小改变，该模板类又会再次实例化出来一个，这样显然造成了代码的膨胀。

为了防止这样让我们来看代码吧:

 #include <iostream>
#include <memory>

template<typename T>
class MatrixBase{
 private:
  std::shared_ptr<T*> square_;
  
  protected:
   template<typename Ty>
   void set_data_ptr(std::shared_ptr<Ty*> ptr_);
   
   public:
    
    MatrixBase()=default;
    
    virtual ~MatrixBase();
};

template<typename T>
template<typename Ty>
void MatrixBase<T>::set_data_ptr(std::shared_ptr<Ty*> ptr_)
{
 this->square_ = ptr_;
}

template<typename T>
template<typename Ty>
MatrixBase<T>::MatrixBase(std::shared_ptr<Ty*> ptr_)
              :square_(ptr_)
{
 //constructor.
}

template<typename T>
MatrixBase<T>::~MatrixBase()
{
 std::cout<<"in Base"<<std::endl;
 this->square_.reset();
}

template<typename T>
class SquareMatrix : private MatrixBase<T>{
 private:
  int size_;
  
  class Deleter{
   public:
    template<typename Ty>
    void operator()(Ty** ptr, const int& N)
    {
     std::cout<<"delete !"<<N<<std::endl;
     if(ptr != nullptr){
      
      for(int i=0; i<N; ++i){
       std::cout<<"start"<<i<<std::endl;
       delete[] ptr[i];
      }
      
      std::cout<<"before end! "<<std::endl;
      delete[] ptr;
      std::cout<<"end"<<std::endl;
     }
    }
  };
  
  public:
   
   SquareMatrix(const int& sz_);
   
   ~SquareMatrix()=default;
};

template<typename T>
SquareMatrix<T>::SquareMatrix(const int& sz_)
                :size_(sz_)
{
 T** temp_ptr = new T*[this->size_];
 for(int i=0; i<this->size_; ++i){
  temp_ptr[i]=new T[2];
 }
 
 auto Delete = std::bind(Deleter(), std::placeholders::_1, this->size_);
 this->set_data_ptr(std::shared_ptr<T*>(temp_ptr, Delete));//这里的this->是必须的因为在编译阶段
                     //并不知道MatrixBase的模板参数类型，因此也就无法知道MatrixBase中有什么内容
                     //我们通过this->告诉编译器有这么个函数，但是也可以通过MatrixBase::set_data_ptr.
 
 temp_ptr = nullptr;
}

int main()
{
 SquareMatrix<int> s(2);
 
 return 0;
}

 我们来看看普通(非模板类)的private继承关于this->的区别:

 #include <iostream>

class Base{
 private:
  int x=0;
  
  public:
   Base()=default;
   
   virtual ~Base()=default;
   
   protected:
    void print()const;
};

void Base::print()const
{
 std::cout<<"x: "<<x<<std::endl;
}

class Inherit : private Base{
 private:
  int y;
  
  public:
   Inherit();
   
   ~Inherit()=default;
};

Inherit::Inherit()
{
 print(); //这里可以写成this->print(),也可以不写. 
}

int main()
{
 Inherit i;
 
 return 0;
}

转载于:https://my.oschina.net/SHIHUAMarryMe/blog/648158