วิธีการโอเวอร์โหลดโอเปอเรเตอร์ << สำหรับ ostream อย่างถูกต้องหรือไม่

ฉันกำลังเขียนไลบรารีเมทริกซ์ขนาดเล็กใน C ++ สำหรับการดำเนินการเมทริกซ์ อย่างไรก็ตามคอมไพเลอร์ของฉันบ่นซึ่งก่อนหน้านั้นไม่ได้ รหัสนี้ถูกวางไว้บนหิ้งเป็นเวลา 6 เดือนและในระหว่างที่ฉันอัพเกรดคอมพิวเตอร์ของฉันจากเดเบียนจำหลักเป็นเลนนี่ (g ++ (เดเบียน 4.3.2-1.1) 4.3.2) แต่ฉันมีปัญหาเดียวกันในระบบ Ubuntu ที่มี g ++ เดียวกัน .

นี่คือส่วนที่เกี่ยวข้องของคลาสเมทริกซ์ของฉัน:

namespace Math
{
    class Matrix
    {
    public:

        [...]

        friend std::ostream& operator<< (std::ostream& stream, const Matrix& matrix);
    }
}

และ "การใช้งาน":

using namespace Math;

std::ostream& Matrix::operator <<(std::ostream& stream, const Matrix& matrix) {

    [...]

}

นี่เป็นข้อผิดพลาดที่คอมไพเลอร์กำหนด:

matrix.cpp: 459: ข้อผิดพลาด: 'std :: ostream & Math :: matrix :: โอเปอเรเตอร์ << (std :: ostream &, const Math :: Matrix &) ต้องใช้อาร์กิวเมนต์หนึ่งตัว

ฉันสับสนเล็กน้อยจากข้อผิดพลาดนี้ แต่แล้ว C ++ ของฉันอีกครั้งได้รับสนิมเล็กน้อยหลังจากทำ Java จำนวนมากใน 6 เดือน :-)

friendคุณได้ประกาศฟังก์ชั่นของคุณเป็น มันไม่ได้เป็นสมาชิกของชั้นเรียน คุณควรลบออกMatrix::จากการใช้งาน friendหมายความว่าฟังก์ชันที่ระบุ (ซึ่งไม่ใช่สมาชิกของคลาส) สามารถเข้าถึงตัวแปรสมาชิกส่วนตัวได้ วิธีที่คุณใช้งานฟังก์ชั่นนั้นเป็นเหมือนวิธีการMatrixเรียนที่ผิด

เพียงแค่บอกคุณเกี่ยวกับความเป็นไปได้อื่น: ฉันชอบใช้คำจำกัดความของเพื่อนสำหรับสิ่งนั้น:

namespace Math
{
    class Matrix
    {
    public:

        [...]

        friend std::ostream& operator<< (std::ostream& stream, const Matrix& matrix) {
            [...]
        }
    };
}

ฟังก์ชันจะถูกกำหนดเป้าหมายโดยอัตโนมัติในเนมสเปซที่ล้อมรอบMath(แม้ว่าคำจำกัดความจะปรากฏภายในขอบเขตของคลาสนั้น) แต่จะไม่สามารถมองเห็นได้เว้นแต่คุณจะเรียกโอเปอเรเตอร์ << ด้วยวัตถุเมทริกซ์ซึ่งจะทำให้การค้นหา บางครั้งสามารถช่วยในการโทรที่ไม่ชัดเจนเนื่องจากไม่สามารถมองเห็นได้สำหรับประเภทอาร์กิวเมนต์อื่นที่ไม่ใช่เมทริกซ์ Math::Matrix<TypeA, N>เมื่อมีการเขียนคำจำกัดความของคุณยังสามารถดูโดยตรงกับชื่อที่กำหนดไว้ในเมทริกซ์และเมทริกซ์ตัวเองโดยไม่ต้องมีคุณสมบัติตามชื่อที่มีบางส่วนคำนำหน้ายาวอาจจะเป็นและให้พารามิเตอร์แม่แบบเช่น

ในการเพิ่มคำตอบ Mehrdad

namespace Math
{
    class Matrix
    {
       public:

       [...]


    }   
    std::ostream& operator<< (std::ostream& stream, const Math::Matrix& matrix);
}

ในการดำเนินงานของคุณ

std::ostream& operator<<(std::ostream& stream, 
                     const Math::Matrix& matrix) {
    matrix.print(stream); //assuming you define print for matrix 
    return stream;
 }

สมมติว่าเรากำลังพูดถึงการโอเวอร์โหลดoperator <<สำหรับคลาสทั้งหมดที่ได้รับจากstd::ostreamเพื่อจัดการกับMatrixคลาส (และไม่ให้มากเกินไป<<สำหรับMatrixคลาส) มันเหมาะสมกว่าที่จะประกาศฟังก์ชันโอเวอร์โหลดนอกเนมสเปซคณิตศาสตร์ในส่วนหัว

ใช้ฟังก์ชั่นเพื่อนเฉพาะในกรณีที่ฟังก์ชั่นไม่สามารถทำได้ผ่านอินเทอร์เฟซสาธารณะ

Matrix.h

namespace Math { 
    class Matrix { 
        //...
    };  
}
std::ostream& operator<<(std::ostream&, const Math::Matrix&);

โปรดทราบว่าตัวดำเนินการเกินพิกัดจะประกาศนอกเนมสเปซ

Matrix.cpp

using namespace Math;
using namespace std;

ostream& operator<< (ostream& os, const Matrix& obj) {
    os << obj.getXYZ() << obj.getABC() << '\n';
    return os;
}

ในทางกลับกันหากฟังก์ชั่นโอเวอร์โหลดของคุณไม่จำเป็นต้องมีเพื่อนเช่นต้องการเข้าถึงสมาชิกส่วนตัวและสมาชิกที่ได้รับความคุ้มครอง

math.h

namespace Math {
    class Matrix {
        public:
            friend std::ostream& operator<<(std::ostream&, const Matrix&);
    };
}

คุณจำเป็นต้องแนบคำนิยามฟังก์ชั่นที่มีบล็อก namespace using namespace Math;แทนเพียง

Matrix.cpp

using namespace Math;
using namespace std;

namespace Math {
    ostream& operator<<(ostream& os, const Matrix& obj) {
        os << obj.XYZ << obj.ABC << '\n';
        return os;
    }                 
}

ใน C ++ 14 คุณสามารถใช้เทมเพลตต่อไปนี้เพื่อพิมพ์วัตถุใด ๆ ที่มี T :: print (std :: ostream &) const; สมาชิก.

template<class T>
auto operator<<(std::ostream& os, T const & t) -> decltype(t.print(os), os) 
{ 
    t.print(os); 
    return os; 
} 

ใน C ++ 20 Concepts สามารถใช้ได้

template<typename T>
concept Printable = requires(std::ostream& os, T const & t) {
    { t.print(os) };
};

template<Printable T>
std::ostream& operator<<(std::ostream& os, const T& t) { 
    t.print(os); 
    return os; 
}