C++ - ostream, amici e spazi dei nomi

Question

Tutto andava bene finché non ho spostato i miei oggetti in uno spazio dei nomi. E ora il compilatore afferma che i miei attributi di colore sono privati.

Pensavo che il punto principale degli amici fosse condividere le informazioni incapsulate con quelle di un amico di classe.

Color.h

friend ostream & operator << (ostream& output, const st::Color& color); 

Color.cpp:

ostream & operator <<(ostream& output, const st::Color& color) { 

    output << "Colors:\nalpha\t: " << color.a << "\nred\t: " << color.r << "\ngreen\t: " << color.g 
      << "\nblue\t: " << color.b << "\nvalue\t: " << color.color(); 

    return output; 
} 

errore:

Color.h||In function 'std::ostream& operator<<(std::ostream&, const st::Color&)':| 
Color.h|52|error: 'unsigned char st::Color::a' is private| 
Color.cpp|15|error: within this context| 
Color.h|49|error: 'unsigned char st::Color::r' is private| 
Color.cpp|15|error: within this context| 
Color.h|51|error: 'unsigned char st::Color::g' is private| 
Color.cpp|15|error: within this context| 
Color.h|50|error: 'unsigned char st::Color::b' is private| 
Color.cpp|16|error: within this context| 
||=== Build finished: 8 errors, 0 warnings (0 minutes, 1 seconds) ===| 

Allora, qual è il problema? Sto usando Code :: Blocks come IDE. E non mostrerà nemmeno proprietà o metodi quando uso l'operatore punto sul parametro "colore". Questo è ovviamente un segno di qualcosa che va storto ... da qualche parte.

Ho eliminato l'operatore dell'amico e lo compila bene. Nessun errore altrove. Cosa dà?

E 'dichiarato come segue:

namespace st{ 

class Color { 

    friend ostream & operator << (ostream& output, const st::Color& color); 
public: 
    .... 
private: 
    ..... 

}; 
}; 

Edit:

Nel mio CPP ora ho fatto questo:

namespace st{ 
ostream & st::operator <<(ostream& output, const st::Color& color) { 

    output << "Colors:\nalpha\t: " << color.a << "\nred\t: " << color.r << "\ngreen\t: " << color.g 
      << "\nblue\t: " << color.b << "\nvalue\t: " << color.color(); 

    return output; 
} 
} 

st::Color::Color() { 

    reset(); 
} 

st::Color::Color(const Color& orig) { 

    a = orig.a; 
    r = orig.r; 
    g = orig.g; 
    b = orig.b; 
} 

void st::Color::reset() { 
    a = 0; 
    r = 0; 
    g = 0; 
    b = 0; 
} 
... etc 
} 

No errori di compilazione, ma è normale per un tale situazione per utilizzare nuovamente lo spazio dei nomi nell'intestazione? O è completamente fuori da quello che dovrei fare?

Modifica: @Rob grazie anche per l'input!

Answer 1

È necessario dichiarare e definire gli operatori nello stesso spazio dei nomi dell'oggetto. Verranno comunque trovati tramite Argoment-Dependent-Lookup.

Un solita applicazione sarà simile a questa:

/// header file 
namespace foo { 
    class A 
    { 
    public: 
    A(); 

    private: 
    int x_; 
    friend std::ostream& operator<<(std::ostream& o, const A& a); 
    }; 

    std::ostream& operator<<(std::ostream& o, const A& a); 
} // foo 

// cpp file 
namespace foo { 
    A::A() : x_(23) {} 

    std::ostream& operator<<(std::ostream& o, const A& a){ 
    return o << "A: " << a.x_; 
    } 
} // foo 


int main() 
{ 
    foo::A a; 
    std::cout << a << std::endl; 
    return 0; 
} 

Modifica

Sembra che non si è declarin tuo operator<< nello spazio dei nomi e stanno definendo anche al di fuori dello spazio dei nomi. Ho modificato il codice.

Answer 2

È necessario qualificare il proprio operatore con lo spazio dei nomi. È una firma di funzione dichiarata nello spazio dei nomi, quindi per accedere al suo simbolo è necessario prefissarlo con lo spazio dei nomi.

Prova in questo modo:

namespace st { 

    ostream & operator <<(ostream& output, const Color & color) { 

     output << "Colors:\nalpha\t: " << color.a 
       << "\nred\t: " << color.r 
       << "\ngreen\t: " << color.g 
       << "\nblue\t: " << color.b 
       << "\nvalue\t: " << color.color(); 

     return output; 
    } 
}