STL Pair 

• pair combines two values in a single unit
• pair 타입의 모든 객체는 두개의 멤버 변수를 가짐 - first, second (전부 public)
• #include <utility> 를 꼭 넣어야댐 

EX1)

#include <utility>
...
void someFuction()
{
	pair<int, double> pair1(3, 5.4);
    	cout << pair1.first() << ", " << pair1.second() <<endl;
}

EX2)

#include <utility>

pair<int, double> p1;
p1.first() = 3;
p1.second() = 2.5;

pair<int, double> p2(13, 4.5);
pair<string, int> student("Bob", 123);

cout << student.first();
cout << student.second();

EX3)

Pair's memebr variables should be PUBLIC ! The program will CRASH!!!

#include <utility>
...
void someFunction()
{
	pair<int,MyClass> pair1; //default values
    cout << pair1.first() << pair1.second(); 
}

class MyClass
{
	public:
    	...
    private:
    	string str;
        double d;
}

Nested Containers 중첩컨테이너 

• An STL container can store instances of other containers.
  • A vector of vectors
  • A list of pointers to vectors
  • A map of strings and sets
  • 대충 컨테이너 안에 컨테이너가 들어간다는 뜻 .. 

EX1) Vectors of Vectors

vector<vector<int>> studentGrades = {
		{98, 90, 100},	// student 1
        	{75, 97, 87},	// student 2
        	{96, 74, 88}	// student 3
};

cout << "Total number of students: " <<	studentGrades.size() << endl;
		// studentGrades 벡터에 저장된 학생의 수 -> 3
        
//iterating the elements in a vector of vectors
int row = 0;
for (const auto& students : studentGrades)
{
	cout << "Student " << row << "grades: ";
    for (auto grade : students)
    {
    	cout << grade << " ";
    }
    ++row;
    cout << "\n";
}

EX2) Map of Strings and Vectors

map<string, vector<int>> studentGrades = {
            {"Jane", {98, 90, 100}},
            {"Bob", {75, 97, 87}},
            {"Jill", {96, 74, 88}},
            };
            
cout << "Total number of students: " << studentGrades.size() << endl;

for (const auto& grades : studentGrades)
{
    cout << grades.first << ": ";
    for (auto grade : grades.second)
    {
        cout << grade << " ";
    }
    cout << "\n";
}

.. 뀼

ㅎㅎ 

연관 컨테이너 Associative Container

automatically sorted
오름차순으로 정렬됨 (<)

Sets and Multisets

• automatically sorted ( By default, in ascending order)
• multisets은 중복허용, sets는 허용 안함 !

기본생성자 default constructor

set<int> set1;
set1.insert(6);
set1.insert(2);
set1.insert(4);  // set is: 2 4 6

-> 기본적으로 사이즈가 0인 set이 만들어짐

복사생성자 copy constructor

set<int> set3(set1);
set<int> set4 = set1;

초기화 리스트 생성자 initializer list constructor

set<int> set5 = {10, 30, 20};
//Elements will be stored in ascending order

범위 생성자 Range constructor

set<int>::iterator iter = set3.begin(); ++iter;
// 또는 auto iter = set3.begin()으로 써도됨
set<int> set4(iter, set3.end());
// set4 is: 20 30 40

set::erase(value)

size_type erase(const value_type& val);
// erase() 함수는 삭제된 요소의 갯수를 반환함! 

multiset<int> aMultiSet =
{ 14, 12, 13, 17, 14, 19, 18, 16, 14, 14, 19, 11, 15 };
size_t itemsDeleted = aMultiSet.erase(14);
cout << itemsDeleted << "\n"; //4, 삭제된 14의 갯수
for (auto elem : aMultiSet) cout << elem << " "; // 11 12 13 15 16 17 18 19 19

set::erase(position)

iterator erase(const_iterator position);

multiset<int> aMultiset = { 11, 12, 13, 15, 17 };
auto iterSet = ++aMultiset.begin(); 
cout << *iterSet << endl; //12

iterSet = aMultiset.erase(iterSet); //-> 삭제된 요소의 다음요소를 가르킴
cout << *iterSet << endl; // 13

for(auto elem : aMultiSet) 
	cout << elem << endl; // 11 13 15 17

set::erase(range)

iterator erase(const_iterator first, const_iterator last);

set<int> aSet = {11, 12, 13, 15, 17, 18, 19};

auto iterSet = aSet.begin();
for (int i = 1; i < 6; ++i) 
{
	++iterSet; //5번반복 
}
cout << *iterSet << endl; // 18 (6th element)

iterSet = aSet.erase(++aSet.begin(), iterSet); // 12 ~ 18 사이에 있는거 다지움 
cout << *iterSet << endl; // 18(삭제된 요소 뒤에 있는 바로 첫 요소

for(auto elem:aSet)
	cout << elem << endl; // 11 18 19

-> 왜 마지막이 11 12 18 19 가 아니지?? 

set::find(value)

set<int> aSet = { 23, 34, 48, 57, 68, 71, 83 };
auto iter = aSet.find(57); //iter은 57을 가리키는 반복자가됨 

if (iter != aSet.end())
cout << "Element found."; // set에서 57을 찾으면 출력 !
else
cout << "Element not found.";

* find 함수는 True and False, Boolean Value로 리턴할 수 없다 ! 

Maps and Multimaps

• elements를 key/value쌍의 형태로 관리함 
• automatically sorted ( By default, in ascending order)
• multimaps은 중복허용, maps는 허용 안함 !

map<int, string> aMap = {{1, "one"}, {2, "two"}, {3, "three"}, {4, "four"}};

auto iterEnd = aMap.cend();
for (auto iter = aMap.cbegin(); iter != iterEnd; ++iter)
cout << iter->first << " " << iter->second << "\n";

map<char, int> aMap;
aMap['A'] = 90;
aMap['b'] = 80;
aMap['C'] = 70;
aMap['D'] = 60;

auto iterEnd = aMap.cend();
for (auto iter = aMap.cbegin(); iter != iterEnd; ++iter)
cout << iter->first << " " << iter->second << "\n";

// Output : A 90, C 70, D 60, b 80
// ASCII code 에 따라서 b 80이 뒤로 감

map<int, int> intMap;

for (int i = 1; i < 10; ++i) // insert integers
intMap.insert (make_pair (i, (100 / i)));

auto itEnd = intMap.cend();
for (auto it = intMap.cbegin(); it != itEnd; ++it)
cout << it->first << " " << it->second << "\n";

// map is: {(1,100),(2,50),(3,33),...(8,12),(9,11)}

const_iterator find(const value_type& k) const;
map<string, int> states = {{"AK", 1959}, {"CA", 1850}, {"FL", 1845}, {"IL", 1818}, {"IO", 1846}, {"OR", 1859}};

auto iter = states.find("CA");
if (iter != states.end())
	cout << "Year: " << iter->second;
else
	cout << "State not found.";

드디어 컨테이너 챕터로 넘어간다 !!

STL Sequence Container은 객체를 sequential oreder (순차적) 으로 저장하는 데이터 구조이다

* Random Access : 배열의 요소를 임의의 위치에서 직접 액세스 할 수 있는 기능 

-> 인덱스 연산자(sunscript operator) 를 사용하여 배열의 특정요소에 액세스 : array[i]

vector container

• implemented as a dynamic array : 동적배열로 구현됨. array와 유사하게 연속적인 메모리 공간에 요소를 저장하고 필요에 따라 크기를 동적으로 조정할 수 있음.
• can access elements randomly (임의적으로 접근)
• 기본생성자(default constructor)이외에도 다양한 생성자를 포함 -> 다양한 방법으로 vector을 초기화하고 생성가능
• size -> number of elements / capcity -> how much memeory is allocated to contain elements.

기본 생성자 default constructor

.reserve()

vector<int> vector1; //capacity = 0
vector1.reserve(20);
//reserve() sets an initial capacity for the vector = 20
vector1.push_back(10); //capacity = 1
vector1.push_back(20); //capacity = 2

복사 생성자 copy constructor

vector<int> vector2(vector1);
vector<int> vector3 = vector1;

초기화 리스트 생성자 initializer list constructor

vector<int> vector4{ 130, 750, 259, 1234};
vector<int> vector5 = {234, 54, 5634, 65};
// set size and capacity right away + with specific elements!!

범위 생성자 Range constructor

vector<int> vector5 {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
vector<int> vector6 (vector5.begin() + 2, vector5.begin() +6);
//vector6 becomes : 30 40 50 60

• (20, 50) "closed range" => 20 30 40 50 
• [20, 50] "open range" => 30 40 
• [20, 50) "half open range" => 30 40 50

vector capacity 

• vector grows automatically; by default their capacity is increased as needed
• tho do not shrink automatically; maintain the same capacity 

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec; 
    
    std::cout << "Initial capacity: " << vec.capacity() << std::endl;
    
    for (int i = 0; i < 10; ++i) 
    {
        vec.push_back(i); //vector capacity automatically grows
        std::cout << "Size: " << vec.size() << ", Capacity: " << vec.capacity() << std::endl;
    }
    
    return 0;
}

elements를 저장할 공간이 없을경우... -> 동적배열이 생성 (dynamic array) -> 모든 elements가 새로운 배열에 복사됨

Inserting Elements

iterator insert(const_iterator position, cosnt value_type& val);
		//넣고싶은 position, 넣고싶은 single element
iterator insert(const_iterator position, size_type n, const value_type& val);
		//넣고싶은 position, 넣고싶은 횟수, 넣고싶은 single element
iterator insert(const_iterator position, initializer_list<value_type> il);
		//넣고싶은 position, 넣고싶은 initializer list object

vector<int> vector1 = {10, 20, 30, 40};
vector1.insert(vector1.begin() + 2, 100); // 10 20 100 30 40
vector1.insert(vector1.begin() + 2, 3, 100); // 10 20 100 100 100 30 40 
vector1.insert(vector1.begin() + 2, {1, 2, 3, 4}); // 10 20 1 2 3 4 30 40

Subscript Operator 첨자 연산자 

vector<int> vector1 = {1, 2, 3, 4, 5};
vector1[2] = 999;

//vector1 is 1 2 999 4 5

Other STL vector functions

front() / back() / begin() / end() / erase() / pop_back() 

vector<string> names = { "Ted", "Sue", "Bob", "Jill"};
// Return the first element.(/= .begin())
cout << names.front() << "\n"; //Ted
// Return the last element.(/= .end())
cout << names.back() << "\n"; //Jill 
// Delete "Bob".
names.erase(names.begin() + 2); // vector is: Ted Sue Jill
// Delete the last element.(which is Jill)
names.pop_back(); // vector is: Ted Sue

list container

• implemented as a doubly-linked list : 이중연결리스트로 구현됨. 이는 연속적인 메모리 공간에 요소를 저장하지않는다는 말과 같음.. ->  리스트의 각요소는 다음 요소를 가리키는 포인터를 포함하고 있으므로, 요소를 추가하거나 제거할때 메모리를 재할당 할 필요가 없음. 따라서 리스트는 동적으로 크기를 조정하는데에 효율적이다. 
• has no random access (임의적으로 접근 불가능!!!!) -> ++iter, --iter 은 가능하지만 (iter +2) 는 불가능!!!!
• 첨자 연산자 사용불가 ! (subscript operator) 
• slist(singly-linked-list) 도 존재함 ㅎ

기본 생성자 default constructor

* By default, an empty list will be created of size 0.

list<int> list1;
list1.push_back(10);
list1.push_back(80);
list1.push_back(54); // list is now: 10 80 54
list1.push_front(3);
list1.push_front(9); // list is now: 9 3 54 80 10

복사 생성자 copy constructor

list<int> list2(list1); //list1이 그대로 복사된 list2생성
list<int> list3 = list1;

초기화 리스트 생성자 initializer list constructor

list<int> list4{ 130, 750, 259, 1234};
list<int> list5 = {234, 54, 5634, 65};
// set size and capacity right away + with specific elements!!

범위 생성자 Range constructor

list<int> list5 {10, 20, 30, 40};
list<int>::iterator iter = list5.begin();
++iter;
++iter;

list<int> list6(iter, list5.end());

//list6 contains : 30 40 
//list cannot use list5.begin() + 2!!!! 임의적 접근 불가능!

For loop to Increment

list<int> aList = { 1, 2, 3, 4, 5, 6, 7, 8 };
auto iter = aList.begin(); // iter은 1
for (int i = 0; i < 6; ++i) // 총 6 번 반복 
	++iter; // 1에서 시작해서 2 3 4 5 6 7 (6번반복) 
cout << *iter; // will print 7

Transferring elements

list::splice()

void splice(const_iterator position, list& x);
void splice(const_iterator position, list& x, const_iterator first, const_iterator last);

list<int> nums1 = { 5, 4, 3, 2, 1};
list<int> nums2 = { 77, 66, 55}; 
nums1.splice(++nums1.begin(), nums2); //nums1 is : 5 77 66 55 4 3 2 1 , num2 is empty
nums1.splice(nums1.begin(), ++nums2.begin(), nums2.end()); //nums1 is : 66 55 5 4 3 2 1 , nums2 is 77

Merging lists

void sort();
void merge(list& x);

list<int> nums5 = { 1, 7, 3, 4, 5};
list<int> nums6 = { 999, 888, 777};
list<int> nums7 = { 89, 23, 874};
nums5.sort(); // nums5 is : 1 3 4 5 7
nums6.sort(); // nums6 is : 777 888 999
nums5.merge(nums6) // nums5 is : 1 3 4 5 7 777 888 999, num6 is empty

//what happens if we do not sort the list? 
nums7.merge(nums6); // nums7 is : ...졸라 복잡해짐. 그냥 sort하자 ㅎ

Other STL list functions

push_front() / pop_front() / reverse() / sort() / remove() 

list<int> scores = { 24, 76, 99, 87 };
// Add a new element to the front.
scores.push_front(75); // list is: 75 24 76 99 87
// Delete the front element.
scores.pop_front(); // list is: 24 76 99 87
// Reverse the order of elements.
scores.reverse(); // list is: 87 99 76 24
// Sort the list.
scores.sort(); // list is: 24 76 87 99
// Delete a given element in the list.
scores.remove(87); // list is: 24 76 99

Returning Iterators

std::vector::erase
iterator erase(const_iterator position);

vector<int> v = {1, 4, 5, 2, 3};
v.erase(v.begin() + 3;); // v is : 1 4 5 3

vector<int> v = {1, 4, 5, 2, 3};
vector<int>::iterator iter = v.erase(v.begin() + 3); 
	/* 먼저 v.begin() + 3을 통해 인덱스가 3인 요소에 대한 반복자를 얻고, 
   	 v.erase() 함수를 사용하여 해당 요소를 삭제합니다. 
   	 이 반복자는 삭제된 요소의 위치를 가리키게 됩니다. */
v.insert(iter, 100); // v is : 1 4 5 100 3

Q. iter이 인덱스가 3인 요소에 대한 반복자를 얻고, 그걸 삭제함. 그럼 위치값(position)을 기록하고, 그  value는nullptr 이 되는건가?? 

A. 

끗 ! 어렵다 ..