[C++ Primer Plus] Chapter 16. (5) STL - 알고리즘, 기타 라이브러리

template<class InputIterator, class OutputIterator>
OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);

template<class ForwardIterator, class T>
void replace(ForwardIterator first, ForwardIterator last,
    const T& old_value, const T& new_value);
// 제자리 알고리즘.
// old_value의 각 인스턴스를 new_value로 바꾼다. 


template<class InputIterator, class OutputIterator, class T>
OutputIterator replace_copy(InputIterator first, InputIterator last, 
    OutputIterator result,
    const T& old_value, const T& new_value);
// 복사 알고리즘.
// 복사 알고리즘의 관행은,
// 마지막으로 복사된 값 바로 다음 위치를 지시하는 이터레이터를 리턴하는 것이다. 

template<class ForwardIterator, class Predicate, class T>
void replace(ForwardIterator first, ForwardIterator last,
    Predicate pred, 
    const T& new_value);
// 조건(predicate)은 bool값을 리턴하는 단항 함수이다. 

string letters;

cout << "글자를 입력하세요. (quit to quit): ";
while (cin >> letters && letters != "quit")
{
    cout <<  letters << "의 모든 치환들: " << endl;

    sort(letters.begin(), letters.end());
    cout << letters << endl;
    // next_permutation은  더 큰 순열로 재배열을 할 수 있으면 반복하여 구해내는 구조이므로
    // 앞에 이미 큰 원소들이 배치되어 있으면 반복하지 않게 된다.
    // 따라서 오름차순으로 정렬을 해준다. 

    while (next_permutation(letters.begin(), letters.end()))
        cout << letters << endl;
    // next_permutation은 범위에 있는 내용의 고유한 그 다음 순열을 제공한다.

    cout << "다음 글자를 입력하세요. (quit to quit): ";
}

// remove 메서드 사용
list<int> li = {1, 4, 1, 4, 4, 4};

li.remove(4);
cout << li.size() << endl;  // 크기가 자동으로 줄어들어서 2


// remove 함수 사용
list<int> li2 = {1, 4, 1, 4, 4, 4};

list<int>::iterator last;
last = remove(li2.begin(), li2.end(), 4);
cout << li2.size() << endl;  // 크기가 그대로 6

li2.erase(last, li2.end());  // 뒤를 지운다. 
cout << li2.size() << endl;  // 크기가 2

char toLower(char ch)
{
    return tolower(ch);
}

string& ToLower(string& st)
{
    transform(st.begin(), st.end(), st.begin(), toLower);
    return st;
}

void display(const string& s)
{
    cout << s << " ";
}

int main()
{
    // vector 컨테이너: 입력을 저장한다. 
    vector<string> words;
    cout << "단어 입력 (enter quit to quit) :\n";
    string input;
    while (cin >> input && input != "quit")
        words.push_back(input);
    
    cout << "다음과 같은 단어들을 입력하셨습니다. :\n";
    for_each(words.begin(), words.end(), display);
    cout << endl;
    
    // set 컨테이너: 유일하며, 순서대로 저장되는 단어들.
    set<string> wordset;
    transform(words.begin(), words.end(),
        insert_iterator<set<string>>(wordset, wordset.begin()),
        ToLower);
    cout << "\n단어들의 알파벳순 리스트 :\n";
    for_each(wordset.begin(), wordset.end(), display);
    cout << endl;
    
    // map 컨테이너: 키를 단어로 하고, 값을 단어의 빈도로 한다. 
    map<string, int> wordmap;
    set<string>::iterator si;
    for (si = wordset.begin(); si != wordset.end(); si++)
        wordmap[*si] = count(words.begin(), words.end(), *si);
    
    cout << "\n단어별 빈도 :\n";
    for (si = wordset.begin(); si != wordset.end(); si++)
        cout << *si << ": " << wordmap[*si] << endl;
}

vector<int> vec = { 1, 2, 5, 4, 3 };
int temp;

int size = vec.size();
valarray<int> valArr(size);
for (int i = 0; i < size; i++)  // vector의 내용을 valarray로 옮긴다.
    valArr[i] = vec[i];

// vector는 정렬 알고리즘 sort()를 사용할 수 있다. 
sort(vec.begin(), vec.end());   

// C++11에서는 이렇게 valarray에 sort()를 사용할 수 있다. 
sort(begin(valArr), end(valArr));  

// valarray는 간단하게 한 문장으로 배열을 연산할 수 있다.
valarray<int> sq_rts(size);
sq_rts = sqrt(valArr);            

valarray<int> results(size);
results = valArr + 2 * sq_rts;

// vector는 이런 방식으로 해야된다.
vector<int> result(size);
transform(vec.begin(), vec.end(), result.begin(), bind1st(plus<int>(), 2));

// valarray를 출력한다.
// cols는 열의 개수이다. 이 개수에 따라 띄어쓴다. 
void show(const valarray<int>& v, int cols)
{
    int lim = v.size();

    for (int i = 0; i < lim; ++i)
    {
        cout.width(3);
        cout << v[i];
        if (i % cols == cols - 1) cout << endl;
        else                      cout << ' ';
    }

    if (lim % cols != 0) cout << endl;
}

int main()
{
    valarray<int> valint = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};  // 4행 3열로 생각한다. 

    cout << "원래의 배열 :\n";
    show(valint, 3); // 3열로 출력한다. 

    valarray<int> vcol(valint[slice(1, 4, 3)]); // 1, 4, 7, 10이며 이것은 두 번째 열이다. 
    cout << "2열을 출력한다. :\n";
    show(vcol, 1);   // 1열로 출력한다. 

    valarray<int> vrow(valint[slice(3, 3, 1)]); // 3, 4, 5이며 이것은 두 번째 행이다. 
    cout << "2행을 출력한다. :\n";
    show(vrow, 3); 

    valint[slice(2, 4, 3)] = 10;                // 2, 5, 8, 11이며 이것은 세 번째 열이다. 
    cout << "3열을 10으로 설정한다. :\n";
    show(valint, 3);

    cout << "1열의 2열과 3열의 합으로 만든다. :\n";
    valint[slice(0, 4, 3)]                      // 0, 3, 6, 9 즉 1열을 2열과 3열의 합으로 만든다. 
        = valarray<int>(valint[slice(1, 4, 3)]) + valarray<int>(valint[slice(2, 4, 3)]);
    show(valint, 3);
}

vector<double> vec1 {1.2, 3.2, 4.4};  // (O)

// 위의 코드는 다음과 같이 동작하는 것이다. 
vector<double> vec1 ({1.2, 3.2, 4.4});

vector<int> vec2(10)  // 원소 10개를 가진 벡터를 생성한다. 
vector<int> vec3{10}  // 10이라는 원소 1개를 가진 벡터를 생성한다. 

vector<int> vec4{ 1.2 };  // (X) narrowing. 컴파일링 시간 에러 발생. 
vector<double> vec5{ 1 }; // (O) 1은 double인 1.0으로 전환된다. 

class Position
{
private:
    int x, y, z;

public:
    Position(int nx, int ny, int nz) : x(nx), y(ny), z(nz) {}
    
    // 고정된 크기이므로 initializer_list 생성자가 없다. 
};

int main()
{
    Position p{ 1, 2, 3 }; // (O) Position(int, int, int) 생성자를 호출한다. 
}

double Sum(initializer_list<double> il)
{
    double tot = 0;
    for (auto p = il.begin(); p != il.end(); p++)
        tot += *p;
    return tot;
}

double Average(const initializer_list<double>& ril)
{
    double tot = 0;
    int n = ril.size();
    double ave = 0.0;

    if (n > 0)
    {
        for (auto p = ril.begin(); p != ril.end(); p++)
            tot += *p;
        ave = tot / n;
    }
    return ave;
}

int main()
{
    cout << "목록 1: Sum = " << Sum({ 2,3,4 }) << ", Ave = " << Average({ 2,3,4 }) << '\n';

    initializer_list<double> dl = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    cout << "목록 2: Sum = " << Sum(dl) << ", Ave = " << Average(dl) << '\n';

    dl = { 16.0, 25.0, 36.0, 40.0, 64.0 }; // 대입 가능
    cout << "목록 3: Sum = " << Sum(dl) << ", Ave = " << Average(dl) << '\n';
}