c++ stringstream à ostream à chaîne

La solution la plus évidente consiste à utiliser dynamic_cast dans foo. Mais le
le code ne fonctionne toujours pas. (Votre exemple de la compilation, mais il ne fera pas ce
vous pensez qu'il devrait.) L'expression std::ostringstream() est un
temporaire, vous ne pouvez pas initialiser un non-const de référence avec une temporaire,
et le premier argument de std::operator<<( std::ostream&, char const*)
est un non-const de référence. (Vous pouvez appeler une fonction membre sur un
temporaire. Comme std::ostream::operator<<( void const* ). Donc le code
compiler, mais il ne fera pas ce que vous attendez.

Vous pouvez contourner ce problème, en utilisant quelque chose comme:

foo( std::ostringstream().flush() << "number = " << 500 );

std::ostream::flush() retourne un non-const de référence, donc il n'y a pas
d'autres problèmes. Et sur un fraîchement créé des flux, c'est un no-op.
Pourtant, je pense que vous serez d'accord que ce n'est pas la plus élégante ou intuitive
solution.

Ce que je fais habituellement dans de tels cas est de créer une classe wrapper, qui
contient sa propre std::ostringstream, et fournit basé sur un modèle
membre operator<< qui les transmet à l'
std::ostringstream. Votre fonction foo prendrait un const
la référence à la présente ou de ce que je offen n'ont qu'à appeler le destructeur
foo directement, de sorte que le code du client n'avez même pas à vous soucier de
il; elle fait quelque chose comme:

log() << "number = " << 500;

La fonction log() retourne une instance de la classe wrapper (mais voir
ci-dessous), et la version finale du destructeur de cette classe appelle votre fonction
foo.

Il y a un léger problème avec cela. La valeur de retour peut être copié,
et détruits immédiatement après la copie. Qui fera des ravages avec
ce que je viens de l'expliquer; en fait, depuis std::ostringstream n'est-ce pas
copiable, il ne sera même pas compiler. La solution ici est de mettre toutes les
logique réelle, y compris l'instance de std::ostringstream et la
destructeur de logique d'appel foo dans une autre mise en œuvre de la classe,
le public wrapper ont un boost::shared_ptr, et en avant. Ou
juste réimplémenter un peu de le pointeur partagé logique dans votre classe:

class LogWrapper
{
    std::ostringstream* collector;
    int* useCount;
public:
    LogWrapper()
        : collector(new std::ostringstream)
        , useCount(new int(1))
    {
    }

    ~LogWrapper()
    {
        -- *useCount;
        if ( *useCount == 0 ) {
            foo( collector->str() );
            delete collector;
            delete useCount;
        }
    }

    template<typename T>
    LogWrapper& operator<<( T const& value )
    {
        (*collector) << value;
        return *this;
    }
};

Remarque qu'il est facile d'étendre à d'appui en option de journalisation; juste
fournir un constructeur de la LogWrapper qui définit collector à
NULL, et de le tester dans le operator<<.

ÉDITÉ:

Une autre chose me vient à l'esprit: vous aurez probablement envie de vérifier si l'
le destructeur est appelé comme un résultat d'une exception, et de ne pas appeler
foo dans ce cas. Logiquement, j'espère que la seule exception que vous
pourrait std::bad_alloc, mais il y aura toujours un utilisateur qui
écrit quelque chose comme:

log() << a + b;

où la + est un définis par l'utilisateur de la surcharge qui en jette.

OriginalL'auteur James Kanze

Je vous suggère d'utiliser cet utilitaire struct:

struct stringbuilder
{
   std::stringstream ss;
   template<typename T>
   stringbuilder & operator << (const T &data)
   {
        ss << data;
        return *this;
   }
   operator std::string() { return ss.str(); }
};

Et l'utiliser comme:

void f(const std::string & s );

int main() 
{
  char const *const pc = "hello";

  f(stringbuilder() << '{' << pc << '}' );

  //this is my most favorite line
  std::string s = stringbuilder() << 25  << " is greater than " << 5 ;
}

Démo (avec quelques exemple) : http://ideone.com/J995r

Plus sur mon blog : Créer des chaînes à la volée juste en une seule ligne

OriginalL'auteur Nawaz

Si vous n'avez pas l'esprit à l'aide de macros fonctions, vous pouvez faire de la fonction d'enregistrement accepter const string&, et utiliser la macro suivante

#define build_string(expr) \
    (static_cast<ostringstream*>(&(ostringstream().flush() << expr))->str())

Et supposons que vous foo a la signature void foo(const string&), vous avez seulement besoin du one-liner

foo(build_string("number = " << 500))

Cela a été inspiré par James Kanze réponse sur static_cast et stringstream.flush. Sans le .flush() la méthode ci-dessus échoue avec inattendus de sortie.

Veuillez noter que cette méthode ne doit pas présenter une fuite de mémoire, comme des valeurs temporaires, que ce soit dans le pointeur en forme ou pas, sont toujours allouées sur la pile, et donc détruit lors de la restitution.

OriginalL'auteur Interarticle

Ce n'est pas possible. Comme son nom l' ostream l'indique, il est utilisé pour la sortie, pour l'écriture. Vous pouvez modifier le paramètre de stringstream&. Cette classe est la méthode str() qui renvoie une std::string pour votre utilisation.

MODIFIER je n'ai pas lu la question avec operator << retour ostream&. Donc je suppose que vous ne pouvez pas simplement écrire vos instructions dans les fonctions de la liste d'arguments, mais d'avoir à l'écrire avant.

OriginalL'auteur Constantinius