Funkcja, która drukuje coś na std :: ostream i zwraca std :: ostream?

Question

Chcę napisać funkcję, która wyprowadza coś do ostream która jest przekazywana w, i powrócić do strumienia, jak poniżej:

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

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

byłoby wygodne, aby wydrukować wartość takiego i osadzić wywołanie funkcji w łańcuch wyjściowy operatora, tak jak w przypadku main().

To nie działa, jednak i drukuje:

$ ./a.out 
12Value: 0x6013a8 

pożądany wynik byłby ten:

Value: 12 

Jak mogę rozwiązać ten problem? Czy muszę zamiast tego zdefiniować operator<<?

AKTUALIZACJA: Wyjaśniono, jaka będzie żądana moc wyjściowa.

UPDATE2: Niektórzy ludzie nie rozumieli, dlaczego wydrukowałbym taką liczbę, używając funkcji zamiast bezpośredniego drukowania. Jest to uproszczony przykład, w rzeczywistości funkcja wypisuje obiekt złożony, a nie int.

Answer 1

Nie można naprawić funkcji. Nic w specyfikacji nie wymaga kompilatora do oceny wywołania funkcji w wyrażeniu w dowolnej kolejności w odniesieniu do niektórych niepowiązanych operatorów w tym samym wyrażeniu. Więc bez zmiany kodu wywołującego, nie można dokonać MyPrint() oceniać po std::cout << "Value: "

lewej do prawej zamówienie jest upoważniona do wyrażenia składające się z wielu kolejnych < < operatorów, tak, że będzie działać. Punktem zwrotnym operatora jest zwracanie strumienia, gdy operatory są powiązane, LHS każdego z nich jest dostarczane przez ocenę operatora po lewej stronie.

Nie można osiągnąć tego samego z bezpłatnymi wywołaniami funkcji, ponieważ nie mają one LHS.MyPrint() zwraca obiekt równy std::cout, podobnie jak std::cout << "Value: ", więc skutecznie robisz std::cout << std::cout, który drukuje tę wartość szesnastkową.

Ponieważ sygnał wyjściowy jest:

Value: 12 

"prawo" rzeczą do zrobienia jest rzeczywiście zastąpić operatorowi < <. To często oznacza, że ​​trzeba albo zrobić z niego przyjaciela, czy to zrobić:

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

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

Jeśli nadrzędnym operator<< dla swojej klasie nie jest właściwe, na przykład dlatego, że istnieje wiele formatów, które mogą chcesz wydrukować, a ty chcesz napisać inną funkcję dla każdego, wtedy powinieneś albo zrezygnować z pomysłu na łańcuchy operatorów i po prostu wywołać funkcję, albo napisać wiele klas, które biorą twój obiekt jako parametr konstruktora, każdy z innym przeciążeniem operatora.

Answer 2

Chcesz mieć klasę myprint z przyjacielem operatora < <:

class MyPrint 
{ 
public: 
    MyPrint(int val) : val_(val) {} 
    friend std::ostream& operator<<(std::ostream& os, const MyPrint& mp) 
    { 
     os << mp.val_; 
     return os; 
    } 
private: 
    int val_; 
}; 

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

Ta metoda wymaga, aby wstawić obiekt do strumienia myprint swojego wyboru. Jeśli naprawdę potrzebujesz możliwość zmiany, które strumień jest aktywny, można to zrobić:

class MyPrint 
{ 
public: 
    MyPrint(int val, std::ostream& os) : val_(val), os_(os) {} 
    friend std::ostream& operator<<(std::ostream& dummy, const MyPrint& mp) 
    { 
     mp.os_ << mp.val_; 
     return os_; 
    } 
private: 
    int val_; 
    std::ostream& os_ 
}; 

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

Answer 3

Po pierwsze, nie ma powodu, aby nie przechodzić w ostream poprzez odniesienie raczej niż przez wskaźnik:

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

Jeśli naprawdę nie chcesz używać std::ostream& operator<<(std::ostream& os, TYPE), można to zrobić:

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

Answer 4

w Twoim przypadku odpowiedź brzmi oczywiście:

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

Jeśli to nie wystarczy, proszę wyjaśnić, jakie dane wyjściowe mają zostać wyświetlone.

Answer 5

Nie ma sposobu, aby robić to, czego spodziewaliśmy się tam ze względu na celu funkcje są oceniane.

Czy jest jakiś szczególny powód, dla którego trzeba napisać bezpośrednio do ostream takiego? Jeśli nie, wystarczy, że MyPrint zwróci ciąg znaków. Jeśli chcesz użyć strumienia w MyPrint, aby wygenerować wynik, po prostu użyj strumienia i zwróć wynik.

Answer 6

Masz dwie opcje. Pierwszy z nich, za pomocą tego, co już jest:

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

Drugi, który jest bardziej C++ - jak, jest zastąpienie MyPrint() z odpowiednim std::ostream& operator<<. Jest już jeden dla int, więc zrobię jedną tylko odrobinę bardziej złożona:

#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; 
} 

Answer 7

Po zmianie wskaźnik odniesienia, można to zrobić:

#include <iostream> 

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

int main(int, char**) { 
    MyPrint(11, std::cout << "Value: ") << std::endl; 

    return 0; 
} 

Składnia MyPrint jest zasadniczo rozwinięty operator<<, ale z dodatkowym argumentem.