cdeclog

#include <iostream>
#include <string>
using namespace std;


class Adder
{
public:
  Adder() {}
  ~Adder() {}

  int operator()(int lvalue, int rvalue)
  {
    return nSum_ = (lvalue + rvalue);
  }

  int operator()(int value)
  {
    return nSum_ += value;
  }

  int Result() const
  {
    return nSum_;
  }

private:
  int nSum_;

};


int FnAdd(int lvalue, int rvalue)
{
  return lvalue + rvalue;
}


int main()
{
  Adder add;

  cout << add(3, 6) << endl;
  cout << FnAdd(2, 4) << endl;

  cout << add(1) << endl;
  cout << add.Result() << endl;
}

#include <iostream>
#include <string>
using namespace std;


class Printer
{
public:
  Printer() {}
  ~Printer() {}

  template <class T>
  void operator()(const T &ty)
  {
    cout << ty << "!";
  }
};

void Print(int n)
{
  cout << n << ":";
}


template <class IterT, class FunT>
void ForEach(IterT begin, IterT end, FunT fun)
{
  while (begin != end) {
    fun(*begin++);
  }
}


int main()
{
  enum { ARR_SIZE = 5 };
  int nArr[ARR_SIZE] = { 1, 2, 3, 4, 5 };

  Printer printer;
  ForEach(nArr, nArr + ARR_SIZE, printer);
  cout << endl;

  ForEach(nArr, nArr + ARR_SIZE, Print);
  cout << endl;

  cin.get();
}

class Base {};
class Derived : public Base {};

void f(Derived *p)
{
}

int main()
{
  Base *p = new Derived;
  f(static_cast<Derived *p>(p)); // down cast 

  int i = 39;
  unsigned long lvalue = static_cast<unsigned long>(i); // 일반적인 cast 
  unsinged long lvalue2 = (unsigned long)i;  // C언어 cast도 지원 
}

int main()
{
  int n = 90;
  char *p = reinterpret_cast<char *>(&n);  // 서로다른 포인터 

  int nHandle = reinterpret_cast<int>(p);  // 포인터와 일반타입 
}

int main()
{
  const char sz[] = "TEST";
  char *p = const_cast<char *>(sz);
}

class NotVBase
{
public:
  ~NotVBase() {}
};
class NotVDerived : public NotVBase {};

class VBase
{
public:
  virtual ~VBase() {}
};
class VDerived : public VBase{};

int main()
{
  NotVBase *p = new NotVDerived;
  // ERROR   
  // 컴파일러에서 에러를 잡아 줄것 입니다. 
  // Base 클래스가 virtual member 가 존재하지 않습니다. 
  NotVDerived *pp = dynamic_cast<NotVDerived *>(p);   // 컴파일 에러   


  VBase *vp = new VDerived;
  VBase *nvp = new VBase;

  VDerived *vpp1 = dynamic_cast<VDerived *>(vp); // SUCCESS   

  // nvp가 가르키고 있는 포인터는 VDerived 타입이 아닙니다. 
  // 따라서 vpp 에는 NULL이 세팅됩니다.   
  VDerived *vpp2 = dynamic_cast<VDerived *>(nvp);
  if (!vpp2) {
    // 이부분이 실행됩니다.   
  }

  try {
    // 만약 참조로 cast하다 실패하면 bad_cast Exception이 발생합니다. 
    VDerived &vd = dynamic_cast<VDerived &>(*nvp);
  }
  catch (...) {}

}

class Base1
{
public:
  virtual ~Base1() {}
};

class Base2
{
public:
  virtual ~Base2() {}
};

class Derived : public Base1, public Base2
{

};

int main()
{
  Base1 *p1 = new Derived();

  // Base1 에서 Base2로의 형변환 
  // p1이 가르키고 있는 타입은 Derived 
  Base2 *p2 = dynamic_cast<Base2 *>(p1); // SUCCESS 

}

template <class T>
class TClass
{
  T t;
};

class TClass
{
  int t;
};

int main()
int main(int argc, char *argv[])

int main()
{
  return 0;
}

// 이 main은 타당합니다. 
// 컴파일러에 의해 return 0; 가 수행됩니다. 
int main()
{
}