Est-ce possible d'obtenir fonte automatique de type défini par l'utilisateur à l'aide de std :: string Cout?

Question

Comme dans la question, si je définis un opérateur de chaîne dans ma classe:

class Literal {
  operator string const () {
    return toStr ();
  };

  string toStr () const;
};

et puis je l'utilise:

Literal l1 ("fa-2bd2bc3e0");
cout << (string)l1 << " Declared" << endl;

avec un explicite tout casting va bien, mais si je retire la (chaîne) le compilateur dit qu'il a besoin d'un opérateur coulé déclaré dans std :: string. Devrait-il pas jeté mon type automatiquement? RESOLU:. Je surcharge operator << (ostream & os, const littérales et l)

Answer 1

Non .. std :: string devrait avoir un constructeur qui se littérales comme argument.

Ce que vous pouvez faire est l'opérateur de surcharge << pour votre classe littérales et l'avoir jeté et insérer dans le flux là-dedans.

ostream &operator <<(std::ostream &stream, const Literal &rhs)
{
    stream << (string) rhs;
    return stream;
}

Answer 2

Réponse courte: Continuez à utiliser un plâtre ou toStr(), ou écrire votre propre fonction de operator<<. (Je préférerais l1.toStr() à (string)l1.)

Réponse longue: Cela pourrait fonctionner si la bibliothèque standard avait une fonction

std::ostream& operator<<( std::ostream&, std::string const& );

Ce qu'il fait presque, mais pas sur le plan technique. Les deux ostream et string sont vraiment typedefs de instanciation de modèle. Et il y a une fonction de modèle pour insérer un dans l'autre.

// This is somewhat simplified.  For the real definitions, see the Standard
// and/or your complying implementation's headers.
namespace std {
  typedef basic_string<char> string;
  typedef basic_ostream<char> ostream;

  template <typename CharT>
  basic_ostream<CharT>& operator<<(
    basic_ostream<CharT>&, 
    basic_string<CharT> const&);
}

Ainsi, lorsque vous utilisez cout << str où le type de str est std::string, il peut comprendre d'utiliser cette fonction de modèle, avec CharT = char.

Mais C ++ ne vous permet pas d'avoir la figure du compilateur à la fois une conversion de type implicite (de Literal à string) et d'en déduire les paramètres du modèle de fonction de modèle (de CharT = char) sur le même appel.