Перегрузка operator<<

/////////////////////////////////////////////////////////////////////////////////////////
//Есть очередная задачка - перегрузить оператор вывода таким образом:
//
//Есть три объекта разных классов - А а, В в, С с;
//
//Нужно, чтобы при записи а << b << c; изменялось значение некоторых членов 
//всех трех классов, ну грубо говоря, пусть там есть по одному члену типа float и пусть 
//при такой записи вывода произойдет нечто вроде
//b.f+=0.2*c.f;
//a.f+=0.8*c.f;
//
//А при любой другой записи - (b<<c<<a, c<<b<<a, b<<a<<c, a<<b<<a) - пусть проводится 
//просто вывод каких-нибудь членов класса, не суть важно. Или даже ошибка за неправильный 
//порядок членов в выводе.
//
//Можно ли это вообще сделать, а если нельзя, то что требуется от этих трех объектов?
//
//Точно известно, что речь про перегрузку вывода, а не перегрузку сдвига.
//С перегрузкой я знаком, но вызывает затруднение именно такой порядок и вообще, наличие 
//3х объектов, о которых идет речь. 
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string  T_str;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_base
{
    float  val_;
    //-----------------------------------------------------------------------------------
public:
    T_base(float  val) : val_(val)
    {}
    //-----------------------------------------------------------------------------------    
    void  set_zero()
    {
        val_ = 0;    
    }
    //-----------------------------------------------------------------------------------
    operator float()
    {
        return  val_;
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
class  A : public T_base
{
public:
    A() : T_base(1)
    {}
};
/////////////////////////////////////////////////////////////////////////////////////////
class  B : public T_base
{
public:
    B() : T_base(2)
    {}
};
/////////////////////////////////////////////////////////////////////////////////////////
class  C : public T_base
{
public:
    C() : T_base(3)
    {}
};
/////////////////////////////////////////////////////////////////////////////////////////
class AB
{
    A&  a_;
    B&  b_;
    //-----------------------------------------------------------------------------------
public:
    AB(A&  a, B&  b) : a_(a), b_(b)
    {}
    //-----------------------------------------------------------------------------------
    AB(const AB&  ab) : a_(ab.a_), b_(ab.b_)
    {}
    //-----------------------------------------------------------------------------------
    void  operator<< (C&  c)
    {
        a_  .set_zero();
        b_  .set_zero();
        c   .set_zero();
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
AB  operator<< (A&  a, B&  b)
{    
    return  AB(a, b);    
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print
    (
        T_str  message,
        A      a,
        B      b,
        C      c
    )
{
    std::cout << message
              << std::endl
              << a
              << " "
              << b
              << " "
              << c
              << std::endl
              << std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    A  a;
    B  b;
    C  c;
 
    print("Исходные значения:", a, b, c);
      
    //Если раскомментировать какие-либо из нижерасположенных выражений, то выдает ошибку.
    //a << c << b;   
    //b << a << c;
    //b << c << a;
    //c << a << b;
    //c << b << a; 
 
    //a << b << a;
   
    a << b << c;
    print("После оператора a << b << c:", a, b, c);
}

#include <iostream>
#include <sstream>
#include <string>
 
using namespace std;
 
class Base{
public:
  virtual string toString() = 0;
};
 
class A : public Base{
public:
  string toString(){ return "a"; }
};
 
class B : public Base{
  string toString(){ return "b"; }
};
 
class C : public Base{
  string toString(){ return "c"; }
};
 
class Manager{
private:
  unsigned uCount;
  stringstream str;
  bool bIsGood;
public:
  Manager() : uCount(0), str( stringstream::in | stringstream::out ), 
                     bIsGood( true )
  {
  
  }
 
  void out( ostream& os, Base* b ){
    if( bIsGood ){
      switch( uCount ){
      case 0:
         if( !dynamic_cast<A*>( b ) ){
           bIsGood = false;
         } 
         break;
      case 1:
         if( !dynamic_cast<B*>( b ) ){
           bIsGood = false;
         } 
         break;
      case 2:
         if( !dynamic_cast<C*>( b ) ){
           bIsGood = false;
         } 
         break;     
      }
      if( bIsGood ){
         str << b->toString();
      }else{
         str.str("");
      }
    }
 
    if( 2 == uCount ){
      if( bIsGood ){
         os << str.str();
      }
      uCount = 0;
      bIsGood = true;
    }else{
      ++uCount;
    }
  }
};
 
Manager man;
 
#define MACRO( OS, OBJ ) \
  man.out( OS, &OBJ );   \
  return OS;
  
 
ostream& operator<<( ostream& os, A& obj ){
  MACRO( os, obj );
}
 
ostream& operator<<( ostream& os, B& obj ){
  MACRO( os, obj );
}
 
ostream& operator<<( ostream& os, C& obj ){
  MACRO( os, obj );
}
 
int main(){
  A a;
  B b;
  C c;
 
  cout << a << b << b << endl;
  cout << a << b << c << endl;
  cout << b << a << c << endl;
  cout << a << b << c << endl;
 
}