MyClass obj; 
obj.Cout();

ostream& operator<<(ostream& cout,MyClass obj)
{
     cout << "Output members here.";
 
    return cout;
}

friend ostream &operator<<(ostream &cout,MyClass &obj)
{
     cout << "Output members here.";

    return cout;
}

#include <iostream>
#include <string>
using namespace std;
 
void reverse_print_const( const string& s )
  {
  cout << "const: ";
  for (string::reverse_iterator c = s.rbegin(); c != s.rend(); c++)
    cout << *c;
  cout << endl;
  }
 
void reverse_print_non_const( string& s )
  {
  // Take note that the function body is exactly the same as above
  cout << "const: ";
  for (string::reverse_iterator c = s.rbegin(); c != s.rend(); c++)
    cout << *c;
  cout << endl;
  }
 
int main()
  {
  string message = "Hello world!";
 
  // Both of these work just fine
  reverse_print_const( message );
  reverse_print_non_const( message );
 
  // But this fails for the non-const
  reverse_print_const( "!sseccuS" );
  reverse_print_non_const( "...eruliaF" );  // <-- this line won't compile!
 
  // The reason why is that the const char* is
  // type-promoted to a const string temporary
  reverse_print_const( string( "!edud suoethgiR" ) );
  reverse_print_non_const( string( "...remmuB" ) );  // <-- same here
 
  // We can test it the same with a const message
  const string message2( "Good-bye." );
  reverse_print_const( message2 );
  reverse_print_non_const( message2 );  // <-- same here
 
  return 0;
  }

ostream& operator << ( ostream& outs, const foo& f )
  {
  // 'outs' is non-const, because it is modified (by writing to it)
  // but 'f' is const, so it can be anything, anywhere, with any
  // access permissions --including temporaries created by
  // type-promotions or returned from functions or even
  // generated explicitly by using an inline initializing ctor.
  ...
  return outs;
  }