Sobrecarga de operadores en namespace

[caraplo]

Hola a todos,
estoy haciendo un pequeño programita que consta de 12 clases,
las he metido todas dentro de un espacio de nombres que he creado:

Código:

namespace MyNM {
class uno {
...
};
...
class dos {
...
};
}

El tema es que necesito sobrecargar el operador << para todas ellas, por ello he optado por hacer una sobrecarga global, no metiendolo dentro de ninguna clase, pero si dentro del namespace de la forma:

Código:

//fichero miespacio.h
namespace MyNM {
class uno {
...
};
ostream &operator<<(ostream &os, const uno &u){
    os<<"\n some text \n";
    return os;
};
class dos {
...
};
}

luego en otro fichero hago

Código:

#include "miespacio.h"
//...mas cosas...
cout<<vble_tipo_class_uno;

pero el linker me dice:
multiple definition of `MyNM::operator<<(ostream&, uno&)'

alguien tiene idea de que estoy haciendo mal?

gracias a todos.

[Eternal Idol]

El error del enlazador es por definir el codigo en el archivo de inclusion (.H), si solo lo declaras en el archivo de inclusion:

Código:

ostream &operator<<(ostream &os, const uno &u);

Y despues lo definis en un archivo de codigo (.cpp):

Código:

namespace MyNM 
{
  ostream &operator<<(ostream &os, const uno &u)
  {
    os	<<	"\n some text \n";
    return os;
  }
};

Lograras enlazarlo pero igual no creo que sea la solucion que estas buscando ...

[caraplo]

No, asi tampoco funciona, ya lo habia probado.
El caso es que solo tengo un fichero .h que es en el que defino todas las clases justo dentro de la definicion del namespace, y luego cada clase tiene su .cpp donde desarrollo el codigo de cada una.

De todas formas muchas gracias por interesarte.

Un saludo.

[Eternal Idol]

Ese codigo solo, tal como te digo funciona perfectamente. Tal vez el problema sea que en cada clase estas definiendo la misma funcion ...

ostream &operator<<(ostream &os, const uno &u);
ostream &operator<<(ostream &os, const uno &u);
ostream &operator<<(ostream &os, const uno &u);

En vez de:
ostream &operator<<(ostream &os, const uno &u);
ostream &operator<<(ostream &os, const dos &u);
ostream &operator<<(ostream &os, const tres &u);

Dejanos la minima cantidad de codigo que de el error ...

[caraplo]

No, no lo sobrecargo varias veces, solo necesito sobrecargarlo una vez.
hago esto:

Código:

// fichero.h
namespace uno_ {
class c1 {
...
};
ostream &operator<<(ostream &os, const c1 &c); //fallo1
class c2 {

};
class c3 {

};

}

y ahora en el fichero en el que implemento los metodos hago:

Código:

// fichero.cpp
void uno_::c2::metodo_de_c2() {
...
}
...
ostream &uno_::operator<<(ostream &os, const uno_::c1 &c)
  {
    os	<<	"\n some text \n";
    return os;
  }
void uno_::c2::metodo_de_c2() {
    //declaro un objeto "ce" de tipo c1
    cout<<ce;
}

y el compilador me da dos fallos en "fallo1"

266 C:\Dev-Cpp\fichero.h expected constructor, destructor, or type conversion before '&' token

266 C:\Dev-Cpp\fichero.h expected `,' or `;' before '&' token

[Eternal Idol]

Bueno, a mi con el VC++ me compila, enlaza y funciona perfectamente esto:

fichero.cpp

Código:

#include <iostream>
using namespace std;

#include "fichero.h"

//void uno_::c2::metodo_de_c2() { }
	
ostream &uno_::operator<<(ostream &os, const uno_::c1 &c)
{
  os <<	"\n some text \n";
  return os;
}

void uno_::c2::metodo_de_c2() 
{
  //declaro un objeto "ce" de tipo c1
  uno_::c1 ce;
  cout<<ce;
}

void main()
{
  uno_::c2 x;
  x.metodo_de_c2();
}

fichero.h

Código:

namespace uno_ 
{
  class c1 
  {
     public:
       c1() { }
       ~c1() { }
  };
	
  ostream &operator<<(ostream &os, const c1 &c);
	
  class c2 
  {
     public:
	c2() { }
	~c2() { }
	void metodo_de_c2();
  };
}

Simplemente con hacer: cl /EHsc fichero.cpp