Fonction qui imprime quelque chose à std::ostream et retourne std::ostream?

Vous ne pouvez pas régler la fonction. Rien dans la spécification nécessite un compilateur pour évaluer un appel de fonction dans une expression dans un ordre particulier à l'égard de certains indépendants de l'opérateur dans la même expression. Ainsi, sans changer le code appelant, vous ne pouvez pas faire MyPrint() évaluer après std::cout << "Value: "

De gauche à droite est obligatoire pour les expressions composées de plusieurs consécutives << les opérateurs, de sorte que ce sera le travail. Le point de l'opérateur<< renvoyer le flux de données est que lorsque les opérateurs sont enchaînés, le membre de GAUCHE de chacun est fourni par l'évaluation de l'opérateur à sa gauche.

Vous ne pouvez pas réaliser la même chose avec la gratuit des appels de fonction parce qu'ils n'ont pas de GAUCHE. MyPrint() retourne un objet est égale à std::cout, et donc ne std::cout << "Value: ", de sorte que vous êtes en fait un std::cout << std::cout, qui est l'impression que valeur hex.

Depuis la sortie désirée est:

Value: 12

la "bonne" chose à faire est en effet de remplacer l'opérateur<<. Cela signifie que vous devez soit faire un ami, ou de le faire:

class WhateverItIsYouReallyWantToPrint {
    public:
    void print(ostream &out) const {
        //do whatever
    }
};

ostream &operator<<(ostream &out, const WhateverItIsYouReallyWantToPrint &obj) {
    obj.print(out);
}

Si une substitution de operator<< pour votre classe n'est pas approprié, par exemple parce qu'il y a de multiples formats que vous pouvez l'imprimer, et vous voulez écrire une fonction différente pour chacun, alors vous devez soit renoncer à l'idée de l'opérateur de chaînage et il suffit d'appeler la fonction, ou bien écrire plusieurs classes prendre votre objet en tant que paramètre du constructeur, chacun avec différentes surcharge de l'opérateur.

Vous avez deux options. La première, en utilisant ce que vous avez déjà est:

std::cout << "Value: ";
MyPrint(12, &std::cout);
std::cout << std::endl;

L'autre, qui est plus similaire à C++, est de remplacer MyPrint() avec le std::ostream& operator<<. Il y a déjà un pour int, donc je vais faire un juste un peu plus complexe:

#include <iostream>

struct X {
    int y;
};

//I'm not bothering passing X as a reference, because it's a
//small object
std::ostream& operator<<(std::ostream& os, const X x)
{
    return os << x.y;
}

int main()
{
    X x;
    x.y = 5;
    std::cout << x << std::endl;
}

Tout d'abord, il n'y a aucune raison de ne pas passer dans le ostream par référence plutôt que par un pointeur:

std::ostream& MyPrint(int val, std::ostream& out) {
  out << val;
  return out;
}

Si vous ne voulez vraiment pas à utiliser std::ostream& operator<<(std::ostream& os, TYPE), vous pouvez le faire:

int main(int argc, char** argv){
    std::cout << "Value: ";
    MyPrint(12, std::cout) << std::endl;
    return 0;
}

Dans votre cas, la réponse est évidemment:

 std::cout << "Value: " << 12 << std::endl;

Si ce n'est pas assez bon, expliquer ce qu'est sortie que vous voulez voir.