Aslında bu soru, "doğru" yolu operator<< uygulamak için mi ?bir this bir şey gibi görüyorum okuma:

friend bool operator<<(obj const& lhs, obj const& rhs);

böyle bir şey için tercih

ostream& operator<<(obj const& rhs);

Ama tam olarak neden bir ya da diğer kullanmalıyım göremiyorum.

Benim kişisel durum:

friend ostream & operator<<(ostream &os, const Paragraph& p) {
    return os << p.to_str();
}

Ama muhtemelen yapabilirim:

ostream & operator<<(ostream &os) {
    return os << paragraph;
}

Ne gerekçesi bu karar baz gerekir?

Not:

 Paragraph::to_str = (return paragraph) 

burada bir paragraf dize.

Sorun burada 14 ** makalenin yorumunuzu.

Bu makalede, sorunları doğru bool ilişkiyi tanımlayan operatörleri sahip olan biri hakkında.

Operatör:

• Eşitlik ==! =
• İlişki < ><= >=

Bu operatörler aynı türden iki nesne karşılaştırmak gibi bir bool döndürür. Genellikle en kolay sınıf bir parçası olarak, bu işleçler tanımlamak için. Bu otomatik olarak bir sınıf türü Paragraf nesneleri birbirine (hatta birbirlerinin özel üye) incelemek, böylece kendisi arkadaşım olduğu için.

Bu otomatik dönüşüm eğer üye fonksiyonları tek oluşturduğu otomatik dönüştürülmesi için izin verirken, aynı tip değil, eğer her iki taraf da dönüştürmek sağlar gibi bu dikili işlevleri yapmak için bir neden daha. Gerçekten otomatik dönüşüm ilk etapta (genellikle) olmasını istemiyorum gibi, bu kağıt adam bir argüman buluyorum. Ama eğer bu istediğiniz bir şey olursa (tavsiye etmem) o zaman karşılaştırıcı dikili yapmak avantajlı olabilir.

Akış operatörleri:

• operatör << çıktı
• operatör ^< . giriş

Akış operatörleri (yerine ikili vardiya) olarak bu kullandığınızda ilk parametre bir akış. Akış nesnesi erişimi (değiştirmek için değil, sizin) hakkınız olduğundan bu sınıf için harici olmalılar üye operatörleri olamaz. Böylece sınıf arkadaşları ya da sizin için akış yapacak bir ortak yöntem erişimi olması da gerekir.

Stream işlemleri birlikte zincir, aynı zamanda bu nesneler bir akış nesnesi için bir başvuru döndürmek için gelenekseldir.

#include <iostream>

class Paragraph
{
    public:
        explicit Paragraph(std::string const& init)
            :m_para(init)
        {}

        std::string const&  to_str() const
        {
            return m_para;
        }

        bool operator==(Paragraph const& rhs) const
        {
            return m_para == rhs.m_para;
        }
        bool operator!=(Paragraph const& rhs) const
        {
            // Define != operator in terms of the == operator
            return !(this->operator==(rhs));
        }
        bool operator<(Paragraph const& rhs) const
        {
            return  m_para < rhs.m_para;
        }
    private:
        friend std::ostream & operator<<(std::ostream &os, const Paragraph& p);
        std::string     m_para;
};

std::ostream & operator<<(std::ostream &os, const Paragraph& p)
{
    return os << p.to_str();
}


int main()
{
    Paragraph   p("Plop");
    Paragraph   q(p);

    std::cout << p << std::endl << (p == q) << std::endl;
}