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

#include <iostream>
 
class Foo
{
public:
    Foo(int a = 0):
    _a(a)
    {
    }
 
    friend std::ostream &operator+(std::ostream &, const Foo &);
 
private:
    int _a;
};
 
std::ostream &operator+(std::ostream &output, const Foo &rhs)
{
    return output << rhs._a;
}
 
int main()
{
    Foo f1(1), f2(2), f3(3);
 
    std::cout + f1 + f2 + f3 << std::endl;
 
    return 0;
}

#include <cassert>
#include <string>
#include <iostream>
 
class Base{
public:
  int value;
  Base( int _value ) : value( _value ) {}
  virtual std::string getName() = 0;
};
 
#define CLASS(NAME)                  \
class NAME : public Base{            \
public:                              \
  NAME( int _value) : Base(_value){} \
  virtual std::string getName(){     \
    return #NAME;                    \
  }                                  \
};                               
 
 
#define BEGIN_SWITCH( COUNT )                \
do{                                          \
  switch( COUNT ) { 
 
#define CASE( NUM, TYPE, OBJ, GOOD, LP )     \
case NUM :                                   \
  if( !dynamic_cast<TYPE*>( OBJ ) ){         \
    GOOD = false;                  \
  }                                                    \
  LP[NUM] = OBJ;                             \
  break;
 
#define END_SWITCH()                         \
  default: assert( 0 );                      \
}} while(0)
 
CLASS(A);
CLASS(B);
CLASS(C);
 
Base& operator<<( Base& a, Base& b ){
  static unsigned uCount = 0;
  static bool bIsGood = true;
  static Base* lpB[3];
 
  std::cout << a.getName() << b.getName() << uCount << bIsGood << std::endl;
 
  BEGIN_SWITCH( uCount )
    CASE( 0, A, &a, bIsGood, lpB )
    CASE( 1, B, &a, bIsGood, lpB )
    CASE( 2, C, &a, bIsGood, lpB )
  END_SWITCH();
  if( 1 == uCount ){
    ++uCount;
    return b << b;
  }else if( 2 == uCount ){
    if( bIsGood ){
      //std::cout << "!\n";
      lpB[0]->value = lpB[1]->value * lpB[2]->value;
    }
    uCount = 0;
    bIsGood = true;
  }else{
    ++uCount;
  }
  return b;
}
 
int main(){
  A a(1);
  B b(2);
  C c(3);
  a << b << c;
  std::cout << a.value << std::endl;  
  a.value = 0;
 
  b << b << c;
  std::cout << a.value << std::endl;  
  a.value = 0;
 
  c << b << a;
  std::cout << a.value << std::endl;  
  a.value = 0;
 
  a << b << c;
  std::cout << a.value << std::endl;  
  a.value = 0;
 
}

#include <iostream>
 
class B {};
class C {};
class A {
public:
    A operator <<(B b);
    void operator<< (C c);
};
 
A A::operator <<(B b)
{
    //ваш код
    return *this;
}
 
void A::operator <<(C c)
{
   //ваш код
}
 
A aa;
B bb;
C cc;
 
int main()
{
    aa << bb << cc;
//    аналогично вызову
//    (aa.operator <<(bb)).operator <<(cc);
    return 0;
}

for(int* p=arr;p!=arr+size;++p)
   cout<< *p;

#include <iostream>
using namespace std; 
struct Inta
{
int a;
Inta():a(0){}//по умолчанию
Inta(const int rhs):a(rhs){}//преобразования
Inta(const Inta &rhs):a(rhs.a){}//копирующий
Inta &operator=(Inta &rhs)//присваивания
{
a=rhs.a;
return *this; 
}
 
friend
ostream &operator<<(ostream &os, Inta &rhs);
};
 
struct Intb
{
int b;
Intb():b(0){}//по умолчанию
Intb(const int rhs):b(rhs){}//преобразования
Intb(const Intb &rhs):b(rhs.b){}//копирующий
Intb &operator=(Intb &rhs)//присваивания
{
b=rhs.b;
return *this; 
}
 
friend
ostream &operator<<(ostream &os, Intb &rhs);
};
struct Intc
{
int c;
Intc():c(0){}//по умолчанию
Intc(const int rhs):c(rhs){}//преобразования
Intc(const Intc &rhs):c(rhs.c){}//копирующий
Intc &operator=(Intc &rhs)//присваивания
{
c=rhs.c;
return *this; 
}
 
friend
ostream &operator<<(ostream &os, Intb &rhs);
};
 
struct ABC_out_sequence_Checker
{
static Inta * pa;
static Intb * pb;
static Intc * pc;
static ABC_out_sequence_Checker* ABC_checker;
ostream &cacaut(ostream &os)
{
 
if(pa!=NULL && pb!=NULL && pc!=NULL)
{
//тут поля для вывода в нашем распоряжении и мы можем их изменить: 
pa->a=pb->b+pc->c;//например так
pb->b=pc->c*pa->a;//так
pc->c=pb->b/(pa->a+1);//и так
os<<pa->a<<'\t'<<pb->b<<'\t'<<pc->c;
pa=NULL;
pb=NULL;
pc=NULL;
}
return os;
}
ABC_out_sequence_Checker *get_ABC_ptr()
{
static ABC_out_sequence_Checker abc;
if(ABC_checker==NULL)ABC_checker=&abc;
return ABC_checker;
}
private:
ABC_out_sequence_Checker()
{
if(ABC_checker==NULL)ABC_checker=this;
}
};
Inta *
ABC_out_sequence_Checker::pa = NULL;
Intb *
ABC_out_sequence_Checker::pb = NULL;
Intc *
ABC_out_sequence_Checker::pc = NULL;
 
ABC_out_sequence_Checker*
ABC_out_sequence_Checker::ABC_checker=NULL;
ostream &
operator<<(ostream &os, Inta &rhs)
{
    
    if(
        ABC_out_sequence_Checker::ABC_checker->pa==NULL &&
        ABC_out_sequence_Checker::ABC_checker->pb==NULL &&
        ABC_out_sequence_Checker::ABC_checker->pc==NULL
        )
    {
ABC_out_sequence_Checker::ABC_checker->pa=&rhs;
    }
    
    return ABC_out_sequence_Checker::ABC_checker->cacaut(os);
}
ostream &
operator<<(ostream &os, Intb &rhs)
{
    if(
        ABC_out_sequence_Checker::ABC_checker->pa!=NULL &&
        ABC_out_sequence_Checker::ABC_checker->pb==NULL &&
        ABC_out_sequence_Checker::ABC_checker->pc==NULL
        )
    {
ABC_out_sequence_Checker::ABC_checker->pb=&rhs;
    }   
return ABC_out_sequence_Checker::ABC_checker->cacaut(os);
}
ostream &
operator<<(ostream &os, Intc &rhs)
{
    if(
        ABC_out_sequence_Checker::ABC_checker->pa!=NULL &&
        ABC_out_sequence_Checker::ABC_checker->pb!=NULL &&
        ABC_out_sequence_Checker::ABC_checker->pc==NULL
        )
    {
ABC_out_sequence_Checker::ABC_checker->pc=&rhs;
    }   
return ABC_out_sequence_Checker::ABC_checker->cacaut(os);
}
 
int main()
{
 
Inta a(1);
Intb b(2);
Intc c(3);
 
cout<<a<<b<<c<<endl;
cout<<b<<a<<c;
cout<<c<<a<<b;
cout<<a<<b<<c<<endl;
cin.get();
return 0;    
}

for(int i(0); i < size; i++)
* *cout<< arr[i];

#include <iostream>
int main()
{
    std::cout<<1["abcd"];
}

#include <iostream>
#include <time.h>
 
int main()
{
    const int size(30000);
    int arr[size];
    srand(time(NULL));
    //рандомно заполняем массив
    for (int i(0); i < size; i++)
    {
        arr[i] = rand() % 200;
    }
 
    clock_t start, end;
    //засекаем время
    start = clock();
    //сортируем пузырьком обращаясь к массиву при помощи индексации
    for (int i(0); i < (size - 1); i++)
        for (int j(i); j < size; j++)
            if (arr[i] > arr[j])
            {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
    //останавливаем время - выводим на консоль результат
    end = clock();
    std::cout << ((double)end - start) / ((double)CLOCKS_PER_SEC) << std::endl;
    //снова рандомно заполняем
    for (int i(0); i < size; i++)
    {
        arr[i] = rand() % 200;
    }
    //снова засекаем время
    start = clock();
    //снова сортируем пузырьком, но уже обращаемся к элементам массива с помощью адресной арифметики
    for (int i(0); i < (size - 1); i++)
        for (int j(i); j < size; j++)
            if (*(arr + i) > *(arr + j))
            {
                int temp = *(arr + i);
                *(arr + i) = *(arr + j);
                *(arr + j) = temp;
            }
    //снова останавливаем время - выводим на консоль результат
    end = clock();
    std::cout << ((double)end - start) / ((double)CLOCKS_PER_SEC) << std::endl;
 
    system("pause");
    return 0;
}