cdeclog

operator->() #

">>", "<<" 연산자 겹지정 #

operator overloading #

example #

#include <iostream>
using namespace std;


class Set
{
public:
        Set() {}
        Set(const Set &s) {}
        ~Set() {}

public:
        Set& operator=(const Set &s); // 대입연산자 

        Set operator+(const Set &s) const; // 합집합 
        Set operator-(const Set &s) const; // 차집합 
        Set operator*(const Set &s) const; // 교집합 
};

Set& Set::operator=(const Set &s)
{
        if (this != &s) {
                // 대입을 합니다. 
        }
        return *this;
}

Set Set::operator+(const Set &s) const
{
        Set r;
        // 합집합 구현 ... 
        return r;
}

Set Set::operator-(const Set &s) const
{
        Set r;
        // 차집합 구현 ... 
        return r;
}

Set Set::operator*(const Set &s) const
{
        Set r;
        // 교집합 구현 ... 
        return r;
}


int main()
{
        Set a;
        Set b;

        // 합집합을 구합니다. 
        // Set c = a.operator+(b); 
        Set c = a + b;

        // 차집합을 구합니다. 
        // Set c = a.operator-(b); 
        Set d = a - b;

        // 교집합을 구합니다. 
        // Set c = a.operator*(b); 
        Set e = a * b;

        // 대입연산자를 이용합니다.   
        // a.operator=(b); 
        a = b;

}

증가연산자의 prefix와 postfix를 구분하기 #

#include <iostream>
using namespace std;

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

public:
        // prefix : ++CInt 
        CInt& operator++();

        // postfix : CInt++ 
        const CInt operator++(int);

private:
        int n_;
};


CInt& CInt::operator++()
{
        ++n_;
        return *this;
}

const CInt CInt::operator++(int)
{
        CInt ci(*this);
        ++(*this);

        return ci;
}


int main()
{
        CInt ci;

        ci++;
        ++ci;
}

class String
{
public:
        /* ... */

        // 변환함수 
        // 암시적으로 const char* 타입으로 변환하게 합니다. 
        operator const char*()
        {
                return pstr;
        }

private:
        char *pstr;
};


int main()
{
        String str;

        // 변환 함수가 사용됩니다. 
        const char *pstr = str;
}

#include <iostream>
using namespace std;

class String
{
public:
        String(const String &str)
        {
                pstr_ = new char[strlen(str.pstr_) + 1];
                strcpy(pstr_, str.pstr_);
        }

        explicit String(const char *pstr = NULL)
        {
                pstr_ = new char[strlen(pstr) + 1];
                strcpy(pstr_, pstr);
        }

        ~String()
        {
                delete pstr_;
        }

        String& operator=(const String &str)
        {
                if (this != &str) {
                        if (pstr_) {
                                delete pstr_;
                        }

                        pstr_ = new char[strlen(str.pstr_) + 1];
                        strcpy(pstr_, str.pstr_);
                }

                return *this;
        }

        operator const char*() const
        {
                return pstr_;
        }

private:
        char *pstr_;
};


int main()
{
        String str("AAA");

        // 컴파일 에러가 생겨야 하지만 문제없이 
        // 컴파일 됩니다. 
        // 변환함수때문에 포인터값을들 비교하는 
        // 의도하지 않은 결과가 이루어 집니다. 
        if ("AAA" == str) {
                /* ... */
        }

}

#include <iostream>
using namespace std;

class CInt
{
public:
        CInt() {}
        CInt(int n) : n_(n) {}
        ~CInt() {}

        operator int()
        {
                return n_;
        }

private:
        int n_;
};


int main()
{
        CInt Number;

        // 파라미터가 1개인 생성자인 
        // CInt(int n)에 근거하여 암시적인 
        // 형변환이 이루어 집니다.   
        Number = 34;


        // operator int()의 변환연산자를 통하여 
        // CInt객체가 int 형으로 암시적으로 형변환이 
        // 가능합니다. 
        int n = Number;
}

#include <iostream>
using namespace std;

// String 타입의 배열객체 
class StringVector
{
public:
        // 디폴트생성자   
        StringVector() {}

        // n개의 String형의 배열 객체를 생성합니다. 
        explicit StringVector(int n) {}

        ~StringVector() {}
};


int main()
{
        StringVector vec;

        // 이것은 아무의미가 없습니다. 
        // 컴파일러에 의해 막아줘야 합니다. 
        // 이때 사용하는 것이 
        // explicit 키워드 입니다. 
        // 아래의 문장은 컴파일러에 의해 에러를 보고 할것 입니다. 
        vec = 34;
}

#include <string>
using std::string;

template <class T>
T Add(T tp1, T tp2)
{
        return tp1 + tp2;
}

int main()
{
        int n = Add(5, 2);
        string str1 = "C";
        string str2 = "++";
        string str = Add(str1, str2);
}

template <class T>
T Add(T tp1, T tp2)
{
        return tp1 + tp2;
}

int Add(int tp1, int tp2)
{
        return tp1 + tp2;
}

std::string Add(std::string tp1, std::string tp2)
{
        return tp1 + tp2;
}

class NoOperator {};

int main()
{
        NoOperator Op1;
        NoOperator Op2;

        // 에러입니다. 
        // NoOperator는 operator+() 제공하지 않습니다. 
        Add(Op1, Op2);
}

#include <string>
using std::string;

template <class T>
class TWrapper
{
public:
        T& GetRefValue()
        {
                return tp_;
        }

private:
        T tp_;
};


int main()
{
        TWrapper<int> Int;
        TWrapper<string> String;
}

class TWrapper
{
public:
        int& GetRefValue()
        {
                return tp_;
        }

private:
        int tp_;
};

class TWrapper
{
public:
        string& GetRefValue()
        {
                return tp_;
        }

private:
        string tp_;
};

template <class T>
T Add(T tp1, T tp2)
{
        return tp1 + tp2;
}

int main()
{
        const char *sz = Add("C", "++");
}

const char* Add(const char* tp1, const char* tp2)
{
        return tp1 + tp2;
}

template <class T>
T Add(T tp1, T tp2)
{
        return tp1 + tp2;
}

template <>
const char* Add(const char* p1, const char* p2)
{
        static char sz[1024] = {0, };
        strcpy(sz, p1);
        strcat(sz, p2);
        return sz;
}


int main()
{
        // template Add 함수 버전을 사용합니다. 
        int n = Add(3, 2);

        // const char* 특화버전 Add 함수를 사용합니다. 
        const char* p = Add("C", "++");
}

template <class T>
class TWrapper
{
public:
        T& GetRefValue()
        {
                return tp_;
        }

private:
        T tp_;
};


// const char* 타입에 대해서는 인스턴스를 못만들게 하기위해 
// 아래와 같은 템플릿 클래스의 전문화를 만듭니다. 
template <>
class TWrapper<const char*>
{
private:
        TWrapper() {}; // private 생성자입니다. 
};


int main()
{
        // 성공입니다. 
        TWrapper<int> Int;

        // 에러입니다. 
        // 위의 const char* 의 클래스전문화가 
        // const char* 인스턴스생성을 막아줍니다. 
        // 기특하기도 하쥐 -_- 
        TWrapper<const char*> CharP;
}

class Adder
{
public:
        template <class T>
        T Add(const T& t1, const T& t2)
        {
                return t1 + t2;
        }
};


int main()
{
        Adder adder;
        int n = adder.Add(3, 4);
        double d = adder.Add(5.3, 2.3);
}

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


template <class T>
class Any
{
public:
        string GetType()
        {
                return "class Any";
        }
};


template <class T>
class Any<T *>
{
public:
        string GetType()
        {
                return "class Any<T *>";
        }
};

template <class T>
class Any<const T>
{
public:
        string GetType()
        {
                return "class Any<const T>";
        }
};


template <class T>
class Any<const T*>
{
public:
        string GetType()
        {
                return "class Any<const T*>";
        }
};


int main()
{
        Any<int> A1;
        cout << A1.GetType() << endl;

        Any<int *> A2;
        cout << A2.GetType() << endl;

        Any<const int> A4;
        cout << A4.GetType() << endl;

        Any<const int *> A5;
        cout << A5.GetType() << endl;
}

결과:
class Any
class Any<T *>
class Any<const T>
class Any<const T*>

#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()
{
}

ATL COM+ (VC++)

- Unmanaged (Native)의 Custom 인터페이스로 호출시 호출성능은 가장 좋음

- 라이브러리 응용프로그램 패키지에서 호출성능은 가장 좋으나

  AddData 의 경우 DB 풀링이 안되는거 같아 성능 저하 현상

- .Net 클라이언트 프로그램에서 호출했을 경우도 Iterop 에 의한 성능저하 별로 없음

: 서버 응용프로그램 패키지에서 실행 권장

: 어플리케이션 프로그램이 아닌 웹환경에서는 대세 

C# COM+ (.Net Enterprise Service)

- Unmanaged (Native) 코드보다는 호출성능은 떨어짐

- 그러나 DB업무인 AddData의 경우 Unmanaged 코드랑 성능차이 없음

- AddData 의 경우 라이브러리 응용프로그램 패키지에서 성능 향상   

  (ATL COM+ 와 대조적인 결과, DB풀링을 드라이버차원이 아닌 .Net 어셈블리에서 처리하는것 같음)

- Unmanaged 클라이언트 프로그램에서 호출했을 경우 Iterop에 의한 약간의 성능 저하

- Managed (.Net)에서 호출시 가장 좋은 성능을 보임

- DTC를 사용하지 않을경우 .Net Library 를 사용하는것이 COM+를 이용하는것 보다 성능이 좋음

: 라이브러리 응용프로그램 패키지에서 실행 권장

: COM+ DTC를 이용하지 않을시는 .Net Library 권장