C++ en utilisant la fonction de gabarit, définir un constructeur ayant une variable de classe ostream dans la fonction principale

Question

J'ai défini la classe de gabarit dans le fichier .h, cela inclut la définition d'un constructeur ayant une classe ostream. Je ne noue pas comment utiliser le constructeur en main.

À l'origine, je veux avoir la somme des codes ASCII du flux d'entrée, je dois le faire avec la classe modèle, au lieu de l'écrire pour chaque type de variables.

.h

#ifndef SPYOUTPUT_H 
#define SPYOUTPUT_H 
#include <iostream> 
using namespace std; 
template <class T> 
class SpyOutput { 
    int Count, CheckSum; 
    ostream* spy; 
public: 
    int getCheckSum(); 
    int getCount(); 

    ~SpyOutput(); 
    SpyOutput(ostream* a); 
    SpyOutput & operator << (T val); 
} 
#endif 

.cpp

template <class T> 
SpyOutput<T>::SpyOutput(std::ostream* a) { 
    spy = a; 
    Count = 0; 
    CheckSum = 0; 
} 

template <class T> SpyOutput<T>::~SpyOutput() {} 

template <class T> SpyOutput<> & SpyOutput<T>::operator << (T val) { 
    stringstream ss; 
    ss << val; 
    string s; 
    s = ss.str(); 
    *spy << s; 
    Count += s.size(); 
    for (unsigned int i = 0; i < s.size(); i++) { 
     CheckSum += s[i]; 
    } 
    return *this; 
} 

template <class T> 
int SpyOutput<T>::getCheckSum() { 
    return CheckSum; 
} 

template <class T> 
int SpyOutput<T>::getCount() { 
    return Count; 
} 

main.cpp

#include "SpyOutput.h" 
#include <iostream> 
#define endl '\n' 

int main() 
{ 
    double d1 = 12.3; 
    int i1 = 45; 
    SpyOutput spy(&cout); // error agrument list of class template is missing 
    /* 
    template <class T> SpyOutput<T> spy(&cout); // not working error 
    SpyOutput<ostream> spy(&cout); 
    // not working error having error on operator <<not matches with these oprands 
    */ 

    spy << "abc" << endl; 
    spy << "d1=" << d1 << " i1=" << i1 << 'z' << endl; 

    cout << "count=" << spy.getCount() << endl; 
    cout << "Check Sum=" << spy.getCheckSum() << endl; 
    return 0; 
} 

Answer 1

Vous mixez utilisation du modèle de classe avec le modèle de fonction. Si je comprends bien, vous voulez créer un wrapper autour de cout qui aura operator<< à utiliser avec n'importe quel autre type. En ce moment, vous déclarez une classe qui est modélisée pour tout autre type.

La différence est que ce moment vous devez créer enrubanneuse pour int et char et float et ainsi de suite ... et utiliser par exemple d'emballage approprié lors de l'impression (ce qui serait fastidieux au mieux).

Pour l'utiliser comme une solution de remplacement pour cout changement votre classe à la classe non basé sur un modèle et juste faire operator<< un modèle comme ceci:

#ifndef SPYOUTPUT_H 
#define SPYOUTPUT_H 

#include <iostream> 

class SpyOutput { 
    int Count, CheckSum; 
    std::ostream* spy; 
public: 
    int getCheckSum(); 
    int getCount(); 

    ~SpyOutput(); 
    SpyOutput(std::ostream* a); 
    template <class T> 
    SpyOutput & operator << (T val) { 
     // here copy the implementation from .cpp 
     // so that template is instantiated for 
     // each type it is used with 
    } 
} 
#endif