개념

1. template: type의 종류에 관계없이 사용 가능한 data structure 또는 function

2. stl(standard template library)

   

   1. container: data 관리 --> 개념인듯
      1. ex) stack, queue, vector ...
   2. algorithms: container의 data 연산
   3. iterator: pointer

Stack

1. 선언

   stack <int> s1;
   stack <double> s2;
   stack <s_record> s3;

2. gerneric
   1. 데이터 타입 일반화
      1. 해당하는 타입에 맞게 위와 같이 사용 가능
3. 함수
   1. pop(): void 타입이므로 맨 위 원소 보려면 top() 사용
   2. Puch()
   3. top(): top 원소 읽어옴
   4. size(): 스택, 큐 등 대부분 있는 듯

queue

1. 함수 --> 일관성을 위해 insert, delete 대신에 push, pop 사용
   1. push(): rear에 원소 삽입 --> void 타입임, rear 원소 읽어 오려면 rear() 함수 사용
   2. pop(): front에서 원소 삭제

vector

1. dynamic array: array + dynamic(메모리 제약 없음) 기능이 추가 되었다고 생각
2. 특징
   1. indexing 가능
      1. index 변수 type은 unsigned int
   2. 컨스럭터 기능 탑재

      vector <int> a(5); // 원소 5개 갖는 vector

3. function
   1. push_back: 끝위치 원소 추가 --> 일종의 배열이므로 끝 위치의 추가, 삭제는 용이함, 중간 위치 추가, 삭제는 효율이 떨어짐
   2. pop_back: 끝위치 원소 삭제
   3. begin(): 첫 원소의 위치(iterator)
   4. end(): 끝 위치(끝 원소 다음 위치)
      1. 전산에서 일반적인 범위: begin <= n < end
   5. insert(): 원소 추가 --> 여러가지 오버로딩 가능(포인터 P 이용, push, pop은 값을 넣음)
      1. insert(p,t): p의 앞쪽에 t추가
      2. insert(p, n, t): p의 앞쪽에 n개의 t 추가
   6. erase()
      1. erase(p): p 위치의 원소 삭제
4. traverse
   1. for(int i=0; i<a.size(); i++)

lists

1. 순차적 접근이 필요한 경우 사용
2. 특징
   1. 인덱싱 불가([] 사용 x) --> 인덱스 접근이 vector를 사용
   2. p=p+3; (불가)
3. function
   1. push_front, back()
   2. pop_fornt, back()
   3. front, back: 맨 앞/ 맨 뒤 원소 읽기
   4. a.merge(b)
      1. a와 b를 merge하여 a를 구성
      2. 연산 후 b는 empty
   5. a.remove(x)
      1. 해당 값 여러개면 모두 삭제
   6. a.sort()
      1. 연산 가능한 원소거나 user defined class인 경우 연산자 overloading 해주면 사용 가능
      2. user defined class의 경우 연산자<을 구현해주면 sort() 사용 가능
   7. a.splice(p, b)
      1. a의 p 위치에 b 끼워 넣음
      2. 연산 후 b는 empty
4. traverse
   1. list <s_record>::iterator p;
   2. for(p=a.begin(); a!=a.end(); p++)

iterator

1. 컨테이너 클래스 원소 가리키는 일종의 포인터

   vector <int> a(10); 
   vector <int>:: iterator p;

2. traverse
   1. for(p = a.begin(); p<a.end(); p++)
      1. p++ 가 다음 원소를 가리키는 것으로 약속 --> abstract 개념
   2. 범위
      1. [ a.begin(), a.end() )

operator overloading

1. 연산 기호를 user defined class object에서 사용 가능하도록 하기 위함

   1. 상수(const) 패러미터를 레퍼런스로 받아야 함

   class weight 
   { 
   public:
     int kg;
     int gram;
     weight operator+(const weight & t);
   };
   weight weight::operator+(const weight & t)
   { 
     weight tmp;
     tmp.kg = kg + t.kg; tmp.gram = gram + t.gram; 
     if (tmp.gram >= 1000) {
     
     tmp.kg += tmp.gram / 1000;
     tmp.gram = tmp.gram % 1000;
   }
     return tmp; 
   }

2. 레퍼런스(&)

   1. 타입 뒤에 & 붙임
   2. another a는 a의 참조자임 --> another_a에 작업을 하면 a에도 반영, 반대도 마찬가지
      1. 포인터로 가리키는 것과 거의 유사 --> *, & 없이 조금 더 편안하게 쓰기 위함인 듯

   int main() {
   
   int a = 3;
   int& another_a = a;
   
   another_a = 5;
   std::cout << "a : " << a << std::endl;
   std::cout << "another_a : " << another_a << std::endl;
   
   return 0;
   }