fonctions virtuelles avec un type de retour non vide

Question

Considérons le schéma d'héritage et de composition suivant.

// Exemple de programme

#include <iostream> 
#include <valarray> 

using namespace std; 

class TapProcessing 
{ 
    public: 
      TapProcessing(){}; 
      virtual ~TapProcessing(){}; 

      virtual void getWeights(valarray<double> &weights) {}; 
      virtual void getPrecisionWeights (valarray<double> &precWeights) {}; 
      virtual const uint &getTapIndex(const uint index) const 
      { 
       valarray<uint> a; 
       a.resize(10); 
       return a[index]; 
      }; //const {return 0;}; 
      virtual const uint &getTapIndexLow(const uint index) const 
      { 
       valarray<uint> a; 
       a.resize(10); 
       return a[index]; 
      }; //const {return 0;};; 
      virtual const uint &getTapIndexHigh(const uint index) const 
      { 
       valarray<uint> a; 
       a.resize(10); 
       return a[index]; 
      }; //const {return 0;}; 

}; 

class StepPrecisionTapProcessing : public TapProcessing 
{ 
    public: 
     StepPrecisionTapProcessing() { _tapIndex.resize(10, 3); } 
     ~StepPrecisionTapProcessing() {}; 

     void getWeights(valarray<double> &weights) { return weights.resize(10);} 
     virtual const uint &getTapIndex(const uint index) const {return _tapIndex[index]; } 

    private: 
      valarray<uint> _tapIndex; 

}; 

class HighPrecisionTapProcessing : public TapProcessing 
{ 
    public: 
     HighPrecisionTapProcessing() 
     { 
      _tapIndexLow.resize(10, 4); 
      _tapIndexHigh.resize(10, 5); 
     } 
     ~HighPrecisionTapProcessing() {}; 

     void getPrecisionWeights (valarray<double> &precWeights) { return precWeights.resize(10); }; 
     virtual const uint &getTapIndexLow(const uint index) const {return _tapIndexLow[index]; } 
     virtual const uint &getTapIndeHigh(const uint index) const {return _tapIndexHigh[index]; } 

    private: 
      valarray<uint> _tapIndexLow; 
      valarray<uint> _tapIndexHigh; 

}; 

class Generator 
{ 
    public: 
      Generator(bool isPrecision) 
      { 
       if (isPrecision) {_tp = new HighPrecisionTapProcessing(); 
       } 
       else { _tp = new StepPrecisionTapProcessing(); } 
      } 

      ~Generator() { delete _tp; } 

      const uint &getTapIndex(const uint index) const {return _tp->getTapIndex(index); } 
      const uint &getTapIndexLow(const uint index) const {return _tp->getTapIndexLow(index); } 
      const uint &getTapIndexHigh(const uint index) const {return _tp->getTapIndexHigh(index); } 

    private: 
      TapProcessing *_tp; 
}; 



int main() 
{ 
    Generator *G = new Generator(true); 
    uint index = 5; 

    cout<<"High tap index is = "<<G->getTapIndexHigh(index)<<endl; 

    delete G; 
    return 0; 
} 

Quand je lance principale, je reçois la sortie suivante,

haut indice du robinet est = 0

ici si la déclaration de getTapIndeHigh dans la classe dérivée remplace la déclaration dans la classe de base, nous verrons une valeur de 5 dans la sortie plutôt que 0. Pourquoi l'implémentation de la classe dérivée n'est pas prioritaire base celle de la méthode de classe pour les méthodes virtuelles non-nulles?

Answer 1

Le problème vient de ces lignes ...

 virtual uint getTapIndex(uint index) {}; 
     virtual uint getTapIndexLow(uint index) {}; 
     virtual uint getTapIndexHigh(uint index) {}; 

Ils décrivent une fonction qui renvoie une uint, fournit une implémentation, mais ne retourne pas vraiment une valeur.

S'il existe une implémentation de base sensée, alors il est bon de la fournir. Cependant, ici, il semble que vous voulez une méthode pure virtual, rendant votre classe abstract. Vous voulez que toutes les classes dérivées implémentent une valeur. par exemple.

 virtual uint getTapIndex(uint index) =0; // require derived classes to implement 
     virtual uint getTapIndexLow(uint index) { return 0 } // can be overridden, but defaults to returning zero. 
     virtual uint getTapIndexHigh(uint index) = 0; // require derived classes to implement.