항목 1. 포인터(pointer)와 참조자(reference)를 구분하자.

그래서 C++에서는 static_cast, const_cast, dynamic_cast, reinterpret_cast 이 네가지 연산자가 추가 되었다.

static_cast는 C 스타일의 캐스트와 동일한 의미와 형변환 능력을 가지고 있다.
long형을 int형으로 우겨 넣는다던지 double형을 float형으로 넣을때 사용하면 된다.

const_cast는 상수성이나 휘발성(volatile)을 제거하는데 쓰인다.
const int를 int형으로 바꾸는 경우나 volatile int를 int형으로 바꾸는 경우에 쓰인다.

dynamic_cast는 상속의 경우에서 가상함수가 사용되는 경우 파생(derived)클래스나 형제(sibling)클래스로 변환할때 쓰인다.

class Widget { ... }; class SpecialWidget? : public Widget { ... }; ... SpecialWidget? *psw; Widget pw; psw = dynamic_cast<SpecialWidget? *>(&pw);

reinterpret_cast는 static_cast연산자가 처리 못하는 대부분을 형변환 시킬수 있다.
그러나 이 연산자는 컴파일러마다 다르게 정의되므로 이식성에 문제가 있다.
struct형을 long *형으로 바꿀수도 있고 float형을 bool형으로 바꾸는등 자유자재로 사용한다.

위의 연산자들은 변환이 불가능할때는 예외를 발생한다.

결론은 차라리 기본 생성자를 생기도록 나두지 말고 그냥 생성자를 만들어 쓰자.

• 어느정도 모호한 부분이 있음. 뒷 부분 읽고 다시 돌아 올것
  

연산자(Operator)

항목 5. 사용자 정의 타입변환 함수에 대한 주의를 놓지 말자

컴파일러가 정의한 타입변환은 두가지 종류가 있다.
하나는 단일 인자 생성자(single-argument constructor)이고

class Name { Name(const string &s); // string 타입을 Name 타입으로 바꿉니다. ... };

다른 하나는 암시적 타입변환 연산자(implicit type conversion)이다.

class Rational { public: ... operator double() const; // Rational 형을 double 형으로 암시적으로 바꿉니다. };

이 방법은 분명 편할수도 있으나 만약의 경우 모호하게 넘어가버리는 경우가 생겨 버그의 원인이 될수도 있다.
C++표준의 string형에는 char *형으로 암시적인 타입변환을 허용하지 않고 멤버인 c_str()을 두어 변환을 하게 한다.
암시적인 타입변환은 그다지 추천하지 않는데 최근 C++에 추가된 내용중 explicit 키워드를 사용하여 암시적 타입변환을 막을수 있다.
(그러나 명시적 타입변환은 여전히 허용하고 있다.)

그렇다면 또 다른 방법은 프록시 클래스(proxy class)를 사용하면 된다.
C++의 규칙에 두번의 암시적 타입변환은 이루어 질수가 없다는 구문이 있기 때문에.
단일 인자 생성자의 경우 이너 클래스(inner-class)를 두어 프록시로 사용하면 간단하게 해결된다.

내부적 구현은 밑과 같다. C++ 공식적인 구현 방법

UPInt& UPInt::operator++() // 전위 { (*this) += 1; return *this; } const UPInt UPInt::operator(int) { const UPInt oldValue = *this; ++(*this); return oldValue; }

효율을 위해서라면 전위 연산자의 사용을 권한다.

멤버 함수일 경우

if(expression1.operator&&(expression2)) ...

전역 함수일 경우

if(operator&&(expression1,expression2)) ...

이렇게 바뀌게 되는데 이는 expression1과 expression2가 이미 평가를 마친상태에서 이루어지기 때문에 단축평가가 불가능해진다.

또한 쉼표(,) 연산자의 경우도 마찬가지의 이유로 먼저 평가되고 그 다음 순차적으로 이루어져야 하는 반면 오버로딩을 하게되면
왼쪽부터 순차적으로 이루어진다는 보장이 없다. (컴파일러가 지원하는지 조차 모른다-_-;)

오버로딩 불가능한 연산자.
. .* :: ?: new delete sizeof typeid static_cast dynamic_cast const_cast reinterpret_cast

오버로딩 가능한 연산자.
operator new
operator delete
operator new[]
operator delete[]
+ - * / % ^ & | ~ ! = < > += *= /= %= ^= &= |= << >> >>= <<= == != <= >= && || ++ -- , ->* -> () []

일반적으로 new연산자를 사용하면 다음과 같은 코드가 생성된다.

string *ps = new string("Memory Management"); 아래와 같이 변한다. void *memory = operator new(sizeof(string)); // 미초기화된 메모리를 반환한다. string::string("Memory Management"); // 생성자로 초기화한다. string *ps = static_cast<string*>(memory); // 캐스트

여기서 operator new가 쓰이는데 이 연산자는 오버로딩이 가능하다.
따라서 사용자가 지정한 메모리 영역을 설정하여 그 부분을 할당하여 줄수 있는데
이를 메모리 지정 new(Placement new)라고 부른다.

사용방법은 다음과 같다.

new (사용자 지정 메모리)할당할 객체(객체의 크기);

그리고 operator new는 다음과 같이 오버로딩한다.

void *operator new(size_t, void *location) { return location; }

new와 마찬가지로 delete 연산자도 역시 유사한 코드를 생성한다.

string *ps; ... delete ps; 아래와 같이 변한다. ps->~string(); // 객체의 소멸자가 호출된다. operator delete(ps); // 메모리를 해제한다.

이와 같이 operator new와 operator delete는 C언어의 malloc과 free와 유사하다.
단지 메모리를 생성해줄뿐 내부적인 생성자의 호출은 new 연산자에 존재한다.

항목 9. 리소스 누수를 피하는 방법의 정공(正攻)은 소멸자이다.

객체가 아닌 포인터로 조작하고 있을때 예외가 발생한다면 리소스 누구가 발생한다.
이럴때는 스마트 포인터(smart pointer)와 같은 방법으로 객체화 시켜준다.

C++표준 라이브러리중 auto_ptr 클래스가 있다.

template <class T> class auto_ptr { public: auto_ptr(T *p = 0) : ptr(0) {} ~auto_ptr() { delete ptr; } private: T *ptr; };

대략적인 구조는 위와 같은데 이것은 지역객체로 존재하면서 포인터를 받아 예외발생시 확실한 리소스 해제를 보장하여 준다.

생성자에서 try - catch문으로 예외구문을 처리하여도 되지만 앞의 항목의 auto_ptr을 사용하는것도 좋은 방법이다.

... Session::~Session() { try { logDestruction(this); } catch(...) // 이와 같이 차라리 아무런 처리가 없더라도 절대 소멸자의 예외가 외부로 전파되는것은 막아야 한다. { } }

예외 발생의 매개변수 전달의 경우를 알아보자면

... catch(Widget w) ...

이와 같은 경우 전달되는 객체에 대하여 두 개의 사본이 만들어진다.
하나는 예외 복사 매커니즘에 의해 생기는 임시 객체이고 또 하나는 w로 저장될때 생기는 임시객체이다.

... catch(Widget &w) ... catch(const Widget &w) ...

위와 같은 경우는 한번의 복사만 이루어진다.
예외 복사 매커니즘의 한번의 복사와 그 객체애 대한 참조이다.

그리고 catch문 안의 throw는 예외를 전파(propagate)하고자 할때 쓰인다.

... catch(Widget &w) { ... throw; }

이 경우에는 예외 자체를 그대로 전파하기 때문에 복사가 일어나지 않는다.

... catch(Widget &w) { ... throw w; }

만약 이경우라면 예외 처리 매커니즘으로 다시 한번 사본과 함께 전파가 이루어진다.

이제 가상 함수의 호출 경우를 보기전에
예외의 파라미터는 타입변환을 허용하지 않는다는것을 알아두어야 한다.
만약 catch문에 double의 인자를 받아들이는 구문이 있을때 int형의 인자를 넘겨준다면 그 catch문은 실행되지 않는다.

그러나 상속 기반(inheritance-based)의 전달은 상위 호환성을 가진다.
예를 들면 표준 C++라이브러리의 예외 클래스의 경우 exception의 최상위 클래스부터 시작하여 logic_error과 runtime_error들로 나뉜다.
만약 catch문이 runtime_error를 받아들인다고 할때 exception의 예외를 전달한다면 runtime_error를 받아들이는 catch문에서
exception을 감지하고 예외를 처리하게 된다.

그리고 또 하나 알아둘점은 예외는 가장 첫째(first fit)를 선택하는 방식으로 진행되는데 상위 예외로 부터 하위 예외로 이어지는 코딩을
하지 않아야한다.

밑은 잘려지는 문제의 예이다.

... class Validation_error:public exception { public: virtual const char *what() throw(); ... } void someFunction() { ... if(유효성 검사가 실패했을 경우) throw Validation_error(); } void doSomething() { try { someFunction(); } catch(exception ex) { cerr << ex.what(); // exception.what()을 호출하고 Validation_error::what()은 호출되지 않는다. } ... }

마지막으로 세번째는 참조를 이용한 경우인데 위의 슬라이싱 문제도 생기지 않고 가장 C++ 표준에 근접한 예외처리 방법이다.

혹시라도 템플릿에 예외 지정을 사용하고자 한다면 포기하는게 좋다. 템플릿의 데이터 구조를 알수 없으므로 어떤 예외가 발생할지 예측하는건 너무 많은 요소가 존재하기 때문이다.
같은 이유로 콜백함수에 예외 지정을 사용하는것도 힘들지만 콜백함수 타입에 미리 예외 지정을 사용함으로 정상적인 동작을 할수 있다.

그렇더라도 뜻하지 않게 런타임 에러가 발생되는것은 참기 힘든일이다.
이것을 피할려면 unexpected가 호출하는 함수를 변경하여 주면 쉽게 해결가능하다.

void 예외 발생 함수() { ... // throw를 사용하여 그냥 중개하는것도 하나의 방법이다. } ... set_unexpected(예외 발생 함수);

항목 16. 뼛속까지 잊지 말자, 80-20 법칙!

몇가지 요소로 알아보면
참조 카운팅(Reference Counting) 만약 문자열 두개를 합친다면 복사가 이루어지게 된다.
하지만 최대한 늦춰서 우선 문자열 두가지를 포인터 등으로 이어두기만 하면 우선 당장은 두 문자열이 합쳐진것과 같은 효과를 지닌다.
만약 두 문자열중 하나가 수정이 가해야 한다면 그제서야 복사를 해도 충분하다.

데이터 읽기와 쓰기를 구분하기 나중!!!!!!!!!!!!! 항목30을 참조

지연 방식의 데이터 가져오기(lazy fetching) 만약 데이터베이스에서 필드를 읽어온다고 가정하면 두번째 필드가 우선 필요할경우 두번째 필드만 데이터베이스로부터 읽어온다.
차후 나중에 필요할대 다른 필드도 읽어오는 방식으로 최소한의 시간으로 바로 다음 명령을 처리할수 있다.

• mutable은 멤버함수내 어느곳에서도 (const 멤버 함수에서도) 수정이 가능하다. 만약 멤버외 인자로 넘어온 파라미터만 수정이 불가능하다면
  

지연 방식의 표현식 평가(lazy expression evaluation) 앞의 이야기와 비슷한데 만약 데이터 계산된 부분만 필요할 경우 부분 부분만 필요할때 계산하는게 유리하다.

size_t countChar(const string &str, char ch); ... char bufferMAX_STRING_LEN?; char c; ... countChar(buffer, c);

이것은 정상적으로 실행이 된다.
buffer은 char형 배열이지만 string형으로 암시적으로 바뀌어 임시객체가 생성된후 거기에 대한 레퍼런스가 넘어간다.
만약 인자의 타입이 const string &str이 아니라 string &str이었다면 실행이 불가능했겠지만 위와 같은 코드는 정상적으로 작동한다.

생각지 못한 임시객체 생성을 주의하자.

그리고 단독 연산자를

const Rational operator+(const Rational &lhs, const Rational &rhs) { return Rational(lhs) += rhs; }

이와 같이 =이 붙은 연산자와 연관 시켜주면 단독 연산자를 쉽게 구현할수 있다.

또한

const T operator+(const T& lhs, const T& rhs) { return T(lhs) += rhs; }

프렌즈 함수로 어렵게 구현할 내용이 깔끔하게 해결 된다.

항목 25. 생성자 함수와 비(非)멤버 함수를 가상 함수처럼 만드는 방법

이런 방법으로 비멤버 함수도 가상 함수처럼 동작하게 할수 있다.

class NLComponent { ... public: virtual ostream& operator<<(ostream &str) const = 0; } class TextBlock? : public NLComponent { ... public: virtual ostream& operator<<(ostream &str) const; }; ... TextBlock? t; t << cout; // 일관성및 가독성이 떨어진다.

class NLComponent { ... public: virtual ostream& print(ostream &s) const = 0; } class TextBlock? : public NLComponent { ... public: virtual ostream& print(ostream &s) const; }; ostream &operator<<(ostream &s, const NLComponent&c) { return c.print(s); }

일관성및 가상함수 처럼 사용 가능하다.

우선 객체를 하나만 생성해야 할때는 자신이 객체로 만들어질 경우 하나뿐이다.
(두번째와 세번째의 경우는 객체를 하나만 생성해야 되는 범위가 다른 클래스에게도 넘어간다.)
생성자를 private으로 하고 정적 객체를 friends나 static함수로 접근하면 쉽게 하나만 생성할수 있다.

이번에는 제한된 여러개의 객체를 생성할 경우 생성자를 private로 하고 유사 생성자(pseudo-constructor)로 만들면서 카운트 하면 된다.

class FSA { public: static FSA *make FSA(); static FSA *make FSA(const FSA& rhs); ... private: FSA(); FSA(const FSA& rhs); }; FSA *FSA::make FSA() { return new FSA(); } FSA *FSA::make FSA(const FSA &rhs) { return new FSA(rhs); }

이것은 유사 생성자의 예제이다. 호출한 쪽에서 delete를 해주어야 하는 부담이 있으므로 auto_ptr을 잘 활용하자.

하지만 이런 생성방법을 사용하면 코드의 중복된 부분이 많아질 것이라는 것을 쉽게 알수있다.
그렇기 때문에 카운트 부분을 템플릿과 상속을 활용하여 생성하면 된다.
카운트 부분의 클래스를 만들고 템플릿의 타입을 받는 부분에 만들고자 하는 클래스를 넣어서 private로 상속을 한다.
카운트 변수와 최대 만들고자 하는 변수들은 카운트 부분 클래스에 있으므로 using을 사용하요 private상속이지만 사용한다는 것을 표시하여주고
유사 생성자로 사용하면 카운팅 부분을 모을수 있다.

귀차나

template <class T> class SmartPtr? { public: // 생성자와 복사 생성자와 소멸자 SmartPtr?(T *realPtr = 0); SmartPtr?(const SmartPtr? &rhs); ~SmartPtr?(); // 대입 연산자 SmartPtr? &operator=(const SmartPtr? &rhs); // 역참조 T *operator->() const; T &operator*() const; // 비교 연산자 operator void*(); // bool연산자의 true와 대부분의 비교 연산자를 지원 bool operator !() const; // bool 연산자의 false를 지원 // 스마트 포인터 객체를 포인터로 변환 operator T* (); // 상속의 경우 template<class newType> operator SmartPtr?<newType>(); private: T *pointee; };

대입이나 복사 생성자의 경우 비트 단위 복사시 두개의 포인터가 생기며 스마트 포인터를 삭제시 두번 삭제되는 위험한 경우에 도달하게 된다.
그러므로 하나의 방법은 대입과 같은 연산시 소유권을 이전하여 준다. 대입하는 객체는 포인터를 NULL로 만들고 대입 받는 객체는 포인터가 전달된다.