[C++ 기초 플러스] Chapter 16. (1) string 클래스, 스마트 포인터 템플릿 클래스

// string 클래스는 템플릿 클래스에 기초한다.  
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
class basic_string
{
    // char 뿐만 아니라 다른형에 기초하는 문자열도 사용할 수 있게 허용한다. 
    typedef basic_string<char> string;
    typedef basic_string<wchar_t> wstring;
    typedef basic_string<char16_t> u16string; // C++11
    typedef basic_string<char32_t> u32string; // C++11

    // ...
};

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

int main()
{
    string one("Lottery Winner!");  
    cout << one << endl;            

    string two(20, '$');            
    cout << two << endl;

    string three(one);              
    cout << three << endl;

    one += " Oops!";           // 오버로딩 +=     
    cout << one << endl; 
    two = "Sorry! That was ";  // 오버로딩 =
    three[0] = 'P';            // 오버로딩 []

    string four;                    
    four = two + three;        // 오버로딩 =, +        
    cout << four << endl;
    char alls[] = "All's well that ends well";

    string five(alls, 20);             
    cout << five << "!\n";

    // 배열의 이름은 주소이다.
    // 따라서 alls + 6은 char*형이다. 따라서 Iter가 char*형이 된다. 
    string six(alls + 6, alls + 10);  // 인덱스 6부터 9까지
    cout << six << ", ";

    // &five[6] 또한 char*형이다. 
    string six2(&five[6], &five[10]); 
    cout << six2 << "...\n";

    string seven(four, 7, 16);        // 인덱스 7부터 16개 문자
    cout << seven << " in motion!" << endl;
    
    string nine = { 'L', 'i', 's', 't' };
}

// C 스타일 문자열
char info[100];
cin >> info;            // 한 단어를 읽는다.
cin.getline(info, 100); // 한 행을 읽되, \n은 내버린다. 
cin.get(info, 100);     // 한 행을 읽되, \n은 큐에 남겨 둔다.

// string 객체
string stuff;
cin >> stuff;           // 한 단어를 읽는다.
getline(cin, stuff);    // 한 행을 읽되, \n은 내버린다.

// C 스타일 문자열
cin.getline(info, 100, ':'); // :까지 읽고, :는 내버린다. 

// string 객체 
getline(cin, stuff, ':');    // :까지 읽고, :는 내버린다. 

string findHere("ACAB");

int where = findHere.find_first_of("BC"); // 가장 처음 나오는 'C' 인덱스 1
where = findHere.find_last_of("BC");      // 가장 마지막으로 나오는 'B' 인덱스 3

string empty;
string small = "bit";
string larger = "Elephants are a girl's best friend";

cout << "Sizes:\n";
cout << "\tempty: " << empty.size() << endl;
cout << "\tsmall: " << small.size() << endl;
cout << "\tlarger: " << larger.size() << endl << endl;

cout << "Capacities:\n";
cout << "\tempty: " << empty.capacity() << endl;
cout << "\tsmall: " << small.capacity() << endl;
cout << "\tlarger: " << larger.capacity() << endl << endl;

empty.reserve(50);
cout << "Capacity after empty.reserve(50): " << empty.capacity() << endl;

// string에 들어있는 파일명이 필요할 경우.
// open()은 C 스타일 매개변수를 요구한다. 

string filename;
cin >> filename;
ofstream fout;

fout.open(filename.c_str());

void Remodel(string& str)
{
    string* ps = new string(str);

    //...

    if (weirdThing())
        throw exception();     
    // 지역 변수인 ps가 차지하는 메모리는 블록을 나가면서 해제되지만
    // delete ps 하지 않았기 때문에 ps가 가리키는 메모리는 해제되지 않는다!

    str = *ps;
    delete ps;
    return;
}

// auto_ptr는 클래스 템플릿을 사용해서 포인터의 종류를 구체화한다. 
template<class X>
class auto_ptr
{
public:
    explicit auto_ptr(X* p = 0) throw(); // 생성자
};

int main()
{
    auto_ptr<int> ptr(new int);       // int형을 가리키는 auto_ptr이다. 
    auto_ptr<string> ptr(new string); // string형을 가리키는 auto_ptr이다. 
}

#include <memory>

void Remodel(string& str)
{
    //string* ps = new string(str);
    auto_ptr<string> ps(new string(str));  // auto_ptr을 사용한다. 

    //...

    if (weirdThing())
        throw exception();  // auto_ptr이 동적 메모리도 알아서 해제해준다. 

    str = *ps;
    //delete ps;  이것은 이제 필요없다. 
    return;
}

shared_ptr<double> ds;
double* d = new double;

ds = d;                     // (X) 암시적 변환은 안 된다. 
ds = shared_ptr<double>(d); // (O) 명시적 변환은 된다. 

string str("I want to study.");
shared_ptr<string> pstr(&str);   // (X)

auto_ptr<string> ps(new string("I'm happy."));
auto_ptr<string> pps;

pps = ps;  
// 이렇게 하면 ps와 pps 모두 하나의 똑같은 메모리를 가리키게 된다. 
// 일반 포인터면 괜찮겠지만, 스마트 포인터는 delete 자동으로 호출하니까,
// 그럼 delete도 두 번 될텐데.. 각각의 스마트 포인터는 이 상황을 어떻게 해결했을까?

// auto_ptr

auto_ptr<string> ps(new string("I'm happy."));
auto_ptr<string> pps;

pps = ps;   // ps의 소유권이 pss에게 넘어가서 ps는 더 이상 그 문자열을 참조하지 않는다. 

cout << *ps << endl; // (X) 실행 후 프로그램 크래시가 발생한다.  

// shared_ptr

shared_ptr<string> ps(new string("I'm happy."));
shared_ptr<string> pps;

pps = ps;   // 참조가 2번이 된다.  

cout << *ps << endl; // (O) 

// 참조카운트를 2에서 1로(pps), 1에서 0으로 줄이고(ps), 0이 되었을 때 힌 번 메모리를 해제한다.  

// unique_ptr

unique_ptr<string> ps(new string("I'm happy."));
unique_ptr<string> pps;

pps = ps;   // (X) 애초에 컴파일이 되지 않아서 실행도 안 된다. 

cout << *ps << endl; 

unique_ptr<string> p1(new string("Uniquely special"));

unique_ptr<string> p2;
p2 = p1; // (X) 컴파일 에러

p2 = unique_ptr<string>(new string("Uniquely special")); 
// (O) 임시 rvalue이므로, 임시 객체는 삭제된다. 따라서 p2가 유일하기 때문에 이것은 허용 된다. 

// unique_ptr을 위한 대입 방법을 이렇게 제안한다.

unique_ptr<string> Demo(const char* s)
{
    unique_ptr<string> temp(new string(s));
    return temp;
}

int main()
{
    unique_ptr<string> ps;
    ps = Demo("Uniquely Special");  // (O)
}

string strs[3]{ "AAA", "BBB", "CCC"};

auto_ptr<string[]> psa(strs);   // (X)
unique_ptr<string[]> psu(strs); // (O) 배열을 가리킬 수 있다. 

unique_ptr<string> p1(new string("One"));
unique_ptr<string> p2 = move(p1);
p1 = unique_ptr<string>(new string("And more"));

shared_ptr<string> ps;
ps = unique_ptr<string>(new string("Uniquely special")); // (O)
ps = Demo("Uniquely Special"); // (O)