Überladen von operator<< - wenn eigener namespace gegeben

MEE

Hallo,

ich habe folgende Deklaration in einem Header

class Project {
    ...
    private:
        short unsigned int parameter;
    friend ostream& operator<< (ostream& out, const Project& proj);
    };

Und implementiert als

ostream& operator<< (ostream& out, const Project &proj) {
    out << proj.parameter << endl;
}

Ich dachte mit friend kann man erreichen auf Private Variablen zuzugreifen? Doch leider beschwert sich gcc genau darüber:
error: 'short unsigned int yamas::Project::parameter' is private
(yamas ist mein namespace - aber das nur am Rande.)

Was mache ich falsch?

Danke,
Christian

DocShoe

Im Header fehlt die Vollqualifizierung der STL Klassen, möglich, dass er dadurch die Funktionssignatur der Implementation nicht erkennt.

MEE

Danke, das war wohl mißverständlich.

Im Header ist eingebunden:

#include <string>
#include <list>
#include <iostream>
#include <vector>
using namespace std;

Das habe ich weggelassen, um den Code kurz zu halten.

Aber gerade eben ist mir aufgefallen, das wenn ich den namespace auskommentiere und auch die entsprechende using-Deklaration im .cpp-File - dann funktioniert es.

Hm, also habe ich wohl den falschen Thread-Titel gewählt. Aber nochmal von vorne. Angenommen der Header sieht so aus (mit den oben gezeigten includes):

namespace yamas {
    class Project {
         // und hier Konstruktor, Destruktor etc.
         friend ostream& operator<< (ostream& out, const Project& proj);
         private:
            short unsigned int parameter;
    };
}

Wie müßte denn dann die korrekte Implementierung lauten?

#include <iostream>
using namespace std;

#include "../include/ya_project.h"
using namespace yamas;

ostream& operator<< (ostream& out, const Project &proj) {
    out << proj.parameter << endl;
}

Dies jedenfalls ist zu kurz gegriffen. Aber warum?

Christian

DocShoe

Im Header ist eingebunden:

#include <string>
#include <list>
#include <iostream>
#include <vector>
using namespace std; // Das gehört hier nicht hin! 

namespace yamas 
{
   class Project {
      // Vollqualifizierte Typennamen benutzen!
      friend std::ostream& operator<< ( std::ostream& out, const Project& proj);
      private:
         // Sachen gibts... warum nicht unsigned short?
         short unsigned int parameter;
    };
}

#include <iostream>
using namespace std;

#include "../include/ya_project.h"

// Implementation findet im namespace yamas statt
namespace yamas
{
   ostream& operator<< (ostream& out, const Project &proj) 
   {
      out << proj.parameter << endl;
   }
}

MEE

Ah, vielen Dank! Wie dumm von mir.

Nur: Warum soll man in Headerfiles kein 'using' verwenden und stattdess vollqualifizierte Typennamen?

l'abra d'or

MEE schrieb:

Nur: Warum soll man in Headerfiles kein 'using' verwenden und stattdess vollqualifizierte Typennamen?

Weil überall da wo dein Header includiert wird, der Namensraum ebenso ausgeleert wird. Das macht den Namensraum nutzlos.

MEE

Danke.

M.a.W. zweimal ein ähnlicher Fehler ... Zeit für die Mittagspause.

MEE schrieb:

Im Header ist eingebunden:

#include <string>
#include <list>
#include <iostream>
#include <vector>
using namespace std;

Iihh! So ein "using namespace std;" hat dort (im Header) nichts zu suchen. Du solltest auch genug Erklärungen dazu im Netz finden können. Es schaded auch nicht, verstanden zu haben, was diese Direktive genau macht.

Überladen von operator&lt;&lt; - wenn eigener namespace gegeben

Überladen von operator<< - wenn eigener namespace gegeben