在派生类

Question

我有一个模板类层次结构，我必须从一个声明：

的抽象类派生一个类

template<typename T>
virtual T findValue(const std::size_t , const std::size_t ) const noexcept = 0;

但是在派生类中，我的findValue方法具有不同的签名：

template<typename T>
T findValue(const std::size_t i, const std::size_t j, 
                      const std::size_t rBlock, const std::size_t cBlock
                     ) const noexcept ;

那么使派生类不抽象的最佳方法是什么？

当然我可以定义：

private:
 template<typename T>
  T findValue(const std::size_t r, const std::size_t c) const noexcept override 
{ return T(0) ;  } 

但我不喜欢这个！那么有什么更好的方法可以做到这一点并使用派生类（当然不是抽象的）

修改 在template <>之上的所有函数中，不是对方法引用类：

template <typename T>

class BlockCompressedMatrix :
                              public SparseMatrix<T>
{


   public: 


      virtual T& operator()(const std::size_t , const std::size_t) noexcept override = 0 ;

      virtual const T& operator()(const std::size_t , const std::size_t) const noexcept override = 0 ;

      virtual void print() const noexcept override = 0;


   protected:

     virtual std::size_t findBlockIndex(const std::size_t, const std::size_t ) const noexcept = 0 ;

     virtual T findValue(const std::size_t , const std::size_t ) const noexcept = 0;



};

，派生就是这样的！ （本编译）

# include "BlockCompressedMatrix.H"

namespace mg {
               namespace numeric {
                                    namespace algebra {

template <typename T>
class Block 
            : public BlockCompressedMatrix<T>

{
      public:

        Block(const std::size_t n) 
        {
            ba_.resize(n);
        }


        T& operator()(const std::size_t , const std::size_t ) noexcept override ;
        const T& operator()(const std::size_t , const std::size_t )const  noexcept override ;
        void constexpr print() const noexcept override ;    

      private:

      using SparseMatrix<T>::dummy ;
      std::vector<T> ba_ ;

      std::size_t findBlockIndex(const std::size_t , const std::size_t ) const noexcept override {return 0;} ;
      T findValue(const std::size_t , const std::size_t ) const noexcept override {return T(0);} ;



};

template <typename T>     
T& Block<T>::operator()(const std::size_t i, const std::size_t j) noexcept {
      dummy = ba_[0];
      return dummy ;
}

template <typename T>     
const T& Block<T>::operator()(const std::size_t i, const std::size_t j)const  noexcept {
      dummy = ba_[0];
      return dummy ;
}

template <typename T>
void constexpr Block<T>::print() const noexcept 
{
     std::cout << "Hello !" << std::endl; 

}