[Effective C++] Chapter 3. 자원 관리

class Investment {};

Investment * createInvestment(); // 팩토리 함수 

void f()
{
  Investment * pInv = createInvestment(); // Investment를 생성한다.
  
  // ...
  
  // 도중하차되어 여기까지 코드가 도달하지 않으면 어떡할 것인가?
  delete pInv; 
}

void f()
{
  std::auto_ptr<Investment> pInv(createInvestment());
  // ...
} // auto_ptr이 소멸자를 통해 delete pInv를 한다. 

std::auto_ptr<Investment> pInv1(createInvestment());

// pInv2가 Investment를 가리키고, pInv1은 null이다.
std::auto_ptr<Investment> pInv2(pInv1);  

// pInv1이 Investment를 가리키고, pInv2는 null이다. 
pInv1 = pInv2; 

std::shared_ptr<Investment> pInv1(createInvestment());

// pInv1와 pInv2 모두 Investment를 가리킨다. 
std::shared_ptr<Investment> pInv2(pInv1); 
pInv1 = pInv2; 

std::auto_ptr<std::string> aps(new std::string[10]);

std::shared_ptr<int> apt(new int[1024]);

class Lock
{
private:
  Mutex * mutexPtr;

public:
  explicit Lock(Mutex * pm) : mutexPtr(pm)
  {
    lock(mutexPtr); // 잠금
  }
  
  ~Lock()
  {
    unlock(mutexPtr); // 해제 
  }
};

// 사용자는 이렇게 사용하면 되겠다. 
int main()
{
  Mutex m;
  
  {
    Lock lock(&m); // 잠금을 건다. 
    // ... 임계 영역에서 연산을 수행한다. 
  } // 블록의 끝이므로 ~Lock()소멸자가 자동으로 불려서 잠금이 해제된다.  
}

class Lock : private Uncopyable {}; // Item 6 참고 

class Lock
{
private:
  std::shared_ptr<Mutex> mutexPtr;
  
public:
  explicit Lock(Mutex * pm) 
    : mutexPtr(pm, unlock) // 삭제자를 unlock으로 지정한다. 
  {
    lock(mutexPtr.get()); // 잠금
  }
};

// Item 13에서 가져온 예제 

// 투자금이 유입된 이후로 경과한 날수를 계산한다. 
int daysHeld(const Investment * pi); 

void f()
{
  std::shared_ptr<Investment> pInv(createInvestment()); 
  
  int days = daysHeld(pInv); 
  // 이렇게 사용하고 싶지만 
  // pInv는 std::shared_ptr<Investment> 이고
  // 매개변수 형식은 Investment * 이다.
  // shared_ptr의 자원에 접근할 수 있어야 하겠다. 
} 

int days = daysHeld(pInv.get()); // 동작한다. 

class Investment
{
public:
  bool isTaxFree() const;
};

Investment * createInvestment();

int main()
{
  std::shared_ptr<Investment> pi1(createInvestment());
  bool isTaxFree1 = pi1->isTaxFree(); // operator->

  std::auto_ptr<Investment> pi2(createInvestment());
  bool isTaxFree2 = (*pi2).isTaxFree(); // operator*
}

class FontHandle {};

class Font
{
private:
    FontHandle f;
    
public:
  FontHandle get const // 명시적 변환 함수 
  {
    return f;
  }

  operator FontHandle() const // 암시적 변환 함수
  {
    return f;
  }
};

FontHandle getFont();
void changeFontSize(FontHandle f, int newSize);

int main()
{
  Font f(getFont());

  // (1) 명시적 변환
  changeFontSize(f.get(), 13);


  // (2) 암시적 변환 
  changeFontSize(f, 13); // Font 형식인 f가 FontHandler로 변환된다.
    
  // 원치 않는 경우가 발생할 수도 있다.
  FontHandle fh = f;
  // Font를 복사하고 싶었는데
  // f가 FontHandle로 바뀐 후 복사된다.
}

std::string * sPtr1 = new std::string;
std::string * sPtr2 = new std::string[100];

delete sPtr1;
delete [] sPtr2;

typedef std::string AddressLines[4];

int main()
{
  std::string * pal = new AddressLines; // new string[4];
    
  delete pal;    // 이거 아니다.
  delete [] pal; // 이거 써야되는데 헷갈리지 않는가?
}

class Widget {};

int getPriority();

void processWidget(std::shared_ptr<Widget> pw, int priority);

int main()
{
  // 컴파일 에러 :
  // shared_ptr의 생성자는 explicit이라서 암시적 변환이 안 된다.
  processWidget(new Widget, getPriority());

  // 이것은 위험하다 :
  // new Widget으로 만들어진 자원이 shared_ptr에 저장되기 전, 그 사이에
  // getPriority()가 불리고 예외가 발생했다면
  // 만들어진 자원은 유실되고 만다.
  processWidget(std::shared_ptr<Widget>(new Widget), getPriority());
}

std::shared_ptr<Widget> pw(new Widget);

processWidget(pw, getPriority());