erreur: impossible de lier 'std :: basic_ostream & lt; char & gt;' lvalue à 'std :: basic_ostream & lt; char & gt; & amp; & amp;'

J'ai déjà regardé quelques questions sur ce, spécifiquement La surcharge de l'opérateur<<: ne peut pas lier une lvalue à ‘std::basic_ostream<char>&&"
a été très utile. Il m'a fait comprendre que mon problème est que je suis en train de faire quelque chose que le c++11 ne pouvez pas déduire le type de.

Je pense qu'une grande partie de mon problème est que le instancié de la classe, je travaille avec, est basé sur un modèle, mais à l'origine, obtenu à partir d'un pointeur à un non-modèle de la classe de base. C'est quelque chose que je n'ai conseillé à partir d'un autre stackoverflow.com question à propos de comment mettre de la classe de modèle d'objets dans un conteneur STL.

Mes classes:

class DbValueBase {
  protected:
    virtual void *null() { return NULL; }   //Needed to make class polymorphic
};

template <typename T>
class DbValue : public DbValueBase {
  public:
    DbValue(const T&val)  { data = new T(val); }
    ~DbValue() { if (data) delete data; }

    T   *data;

    const T&    dataref() const { return *data; } 

    friend std::ostream& operator<<(std::ostream& out, const DbValue<T>& val)
    {
        out << val.dataref();
        return out;
    }
}

Et, de l'extrait de code où l'erreur de compilation database.cc:530:90: error: cannot bind ‘std::basic_ostream<char>’ lvalue to ‘std::basic_ostream<char>&&’ se produit:

//nb:  typedef std::map<std::string,DbValueBase*>  DbValueMap;
    const CommPoint::DbValueMap&    db_values = cp.value_map();
    for (auto i = db_values.cbegin() ; i != db_values.cend() ; i++) {
        //TODO: Need to implement an ostream operator, and conversion
        //operators, for DbValueBase and DbValue<>
        //TODO: Figure out how to get a templated output operator to
        //work... 
 //    DbValue<std::string> *k = dynamic_cast<DbValue<std::string>*>(i->second);
        std::cerr << "  Database field " << i->first << " should have value " << *(i->second) << endl;
    }

Si ma sortie essaie d'imprimer i->secondil compile et s'exécute, et je vois le pointeur. Si j'essaie de sortie *(i->second)j'obtiens le message d'erreur de compilation. Lorsque le mode pas à pas dans gdb, il semble encore savoir que i->second est du type correct

(gdb) p i->second
$2 = (DbValueBase *) 0x680900
(gdb) p *(i->second)
warning: RTTI symbol not found for class 'DbValue<std::string>'
$3 = warning: RTTI symbol not found for class 'DbValue<std::string>'
{_vptr.DbValueBase = 0x4377e0 <vtable for DbValue<std::string>+16>}
(gdb) quit

Je suis en espérant que je suis en train de faire quelque chose de subtilement mal. Mais, c'est plus compliqué qu'il me semble être en mesure de le comprendre sur mon propre. Quelqu'un d'autre voir ce que les chose(s) que j'ai fait de mal ou incomplètement?

Edit:

@PiotrNycz fait donner une bonne solution proposée pour mon problème ci-dessous. Toutefois, en dépit de cours d'impression des valeurs tout en faisant de développement, le besoin réel de ces DbValue<> objets est de les faire retourner une valeur de type approprié à laquelle je peux ensuite d'alimentation de la base de données de méthodes d'opération. Je devrais l'ai mentionné que dans ma question initiale, que l'impression est de valeur, mais pas la fin de mon objectif.

source d'informationauteur cross

c++templates

3

Bien que le débogueur identifie correctement *(i->second) comme étant de type DbValue<std::string>cette détermination est faite en utilisant l'information qui est disponible uniquement lors de l'exécution.

Le compilateur sait seulement que c'est de travailler avec un DbValueBase& et doit générer son code sur cette base. Par conséquent, il ne peut pas utiliser le operator<<(std::ostream&, const DbValue<T>&) que ne pas accepter un DbValueBase ou sous-classe.

Pour l'obtention du contenu d'une DbValue<> objet à travers un DbValueBase&vous pourriez boucle dans le Visiteur motif de conception.

Un exemple de code:
```
class Visitor {
public:
    template <typename T>
    void useValue(const T& value);
};

class DbValueBase {
public:
    virtual void visit(Visitor&) = 0;
};

template <class T>
class DbValue : public DbValueBase {
pblic:
    void visit(Visitor& v) {
        v.useValue(m_val);
    }
private:
    T m_val;
};
```

Si vous voulez imprimer un objet en base de pointeur - faire de la ostream exploitant dans la classe de base:

class DbValueBase {
  protected:
    virtual ~DbValueBase() {}
    virtual void print(std::ostream&) const = 0;
    friend std::ostream& operator << (std::ostream& os, const DbValueBase & obj)
    {
       obj.print(os); return os;
    }
};

template <typename T>
class DbValue : public DbValueBase {
  public:
    void print(std::ostream& os) const 
    {
        out << dataref();
    }
};

Vous devez vous connecter pour publier un commentaire.