Newsgroup: it.comp.programmare.win32
Titolo: [NEWBIE] Aiuto operatore <<

Salve a tutti!!! Spero di essere sul NG giusto....
Sto tentando di effettuare l'overloading dell'operatore binario << nella mia
classe ClVertex.
Non riesco a venirne a capo, spero che qualcuno possa aiutarmi.
L'unico errore che ho in compilazione (Visual c++ 6.0) č:
Compiling...
main.cpp
C:\[...]\main.cpp(8) : error C2678: binary '<<' : no operator defined which
takes a left-hand operand of type 'class ostream_withassign' (or there is no
acceptable conversion)
Ecco il codice:
-----------VERTEX.H----------------------
#include    "stdafx.h"
#include <math.h>
#include <vector>
#include <iostream.h>
#include <string>
class ClVertex
{
 public:
ClVertex ()
  {
   this->SetZero ();
  }
   ClVertex(float vx, float vy, float vz)
  {
    n.x = vx;
    n.y = vy;
    n.z = vz;
  }
  ClVertex( float f )
  {
   n.x = f;
   n.y = f;
   n.z = f;
  }
 ~ClVertex()
  {}
  /** Get the x component.
   */
  float get_x() const
  {
   return ( n.x );
  }
  /** Set the x component.
   */
  void set_x( float v_x )
  {
   n.x = v_x;
  }
  /** Get the y component.
   */
  float get_y() const
  {
   return ( n.y );
  }
  /** Set the y component.
   */
  void set_y( float v_y )
  {
   n.y = v_y;
  }
  /** Get the z component.
   */
  float get_z() const
  {
   return ( n.z );
  }
  /** Set the z component.
   */
  void set_z( float v_z )
  {
   n.z = v_z;
  }
  /** Array based component access.
   * \param i Integer component index, 0-2.
   * \return Appropriate component, or z if index is invalid.
   */
   float& operator[] (const int idx)
   {
    return a[idx];
   }
   ClVertex operator - (const ClVertex &v)
   {
    return ClVertex(n.x-v.n.x, n.y-v.n.y, n.z-v.n.z);
   };
   ClVertex& operator = (const ClVertex *vect)
   {
     n.x = vect->n.x;
    n.y = vect->n.x;
     n.z = vect->n.x;
    return *this;
   };
   friend std::ostream &operator<<( std::ostream &Stream, const ClVertex
&V ) ;
   void SetZero ()
   {
    n.x = n.y = n.z = 0;
   };
   protected:
  union
  {
   struct
   {
    float x, y, z;
   } n;
   float a[3];
  };
};
-----------VERTEX.CPP----------------------
#include "stdafx.h"
#include "vertex.h"
std::ostream &operator<<( std::ostream &Stream, const ClVertex &V )
{
 Stream << V.n.x << "," << V.n.y << "," << V.n.z;
 return ( Stream );
}
-----------MAIN.CPP--------------------
#include "stdafx.h"
#include "vertex.h"
int main()
{
 ClVertex v(1, 2, 3);
 cout<<v;
return 0;
}
Grazie
Banshee

 nella mia classe ClVertex.
Scusa se ti rispondo senza darti info sul tuo dubbio ma facendoti una
domanda:
come mail il nome vertex?
-- 
Alex {per email metti '[IOPOSSO]' nell'oggetto}
"In C i bug vanno scritti. In C++ si possono ereditare. (Marco
Bernardini)"

 come mail il nome vertex?
e come mai tutta l'implementazione nel VERTEX.H (che poi, dato che la
classe si chiama ClVertex lo avrei chiamato ClVertex.h), mentre nel
VERTEX.CPP ci metti solo l'operator?
scusa se non risponde alla domanda originale, ma non mi ricordo mica
tanto degli operator...
A prima vista l'unica cosa che non vedo e' un
#include <iostream.h> in main.cpp
(certo hai un include per stdafx.h, ma non so se stdafx.h include
iostream....
e si, includi anche vertex.h che include iostream, ma con VC++ 6.0 non
so se le varie inclusioni sono fatte come dovrebbero...)
hmmm... non e' che l'operator deve ritornare *Stream anziche' Stream di
per se' ?
HTH,
F.O.R.

 con l'overloading.
Ah ecco... una delle ragioni per cui VC++ 6.0 era stato rinominato
M$ Visual Nightmare all'universita' :-)
Cmq buono a sapersi.
F.O.R.