1. 플랫폼 류 신발들 !! 

알아본건 이정도? 

웻지형태의 신발은 나에게 너무 불편해서 이렇게 스레빠같은 플랫폼 형식의 신발이 갖고싶다 

넘 기엽자나 

예산 500불 이하  ! ^ㅁ^ 

2. 대충 어그부츠 

.... 겨울 대비 ^ㅁ^

예산 150불 이하 ! 

3.에르메스 미니팝 

요즘 핑크 색에 꽂혀서 미니팝 핑크가 눈에 들어온다.. 

넘기엽자나 

샤워할때도 악세사리 안빼는 사람으로서 휘뚤템이 필요한데 

멀로 사야될지 고민이담 .. 

예산 500불 이하 ! 

4. 지갑 

woc형태 너무 답답해서 못갖고다니겠음 

묵직하고 ( 그치만 작고) 에어태그 넣을 동전 지갑 지퍼있고 ...

이런 알뜰살뜰 기여운 지갑이 필요하담 

셀린느는 걍 요즘 꽂혀서 돌아봤는데

카드지갑 똑딱이로 떼어지는것도 그렇고 뭔가 마음에 안든다.. 

거추장 스러워... 

아직 쏙 마음에 드는게 없어서 도저히 못찾으면 

다시 마뗑킴으로 돌아갈듯 

메탈 로고 무거워서 잘 잃어버리지도 않고 그게 조앗는데 

이번 지갑은 너무 가벼워서 잘 잃어버릴거같애서 무섭댜 

예산 100마넌 이하 

5. 미니가방 

휘뚤마뚤 잘들고다닐 미니 백팩 !!!!!!!

디자이너 브랜드는 귀찮아서 안알아봤고 

걍 대충 이두개 중에 하나살겅미 

6. 커여운 키링 

이거 너무 갖고시퍼서 죽겟서 . 

넘 기엽자나 

7. 그다음에 갖고싶은것들...

기찬아서 사진을 못올리겠으 ㅁ

다이슨 에어스트레이트너 사고싶고 

록시땅 네일 에센스 사고싶고 

블루 마이크랑 

옥토버디 .. 핑크 재입고 되면 살꾸야 .. 

보조배터리도 사야되는데 먼가 면세점에서 살라고 존버중 

보다나 봉고데기는 그냥 살려구 . . 

<Functions to know how to use WITHOUT a description.>

Exam 2 - STL Functions to Know

Functions to know how to use WITHOUT a description.

• STL vector/list/set/multiset/map/multimap
  • Constructors (all those included in the lessons)
  • begin/end/rbegin/rend
  • clear
  • empty
  • operator=
  • size
  • erase(first, last)
• STL vector
  • at
  • assign(first, last), assign(n, val)
  • erase(position), erase(first, last)
  • front, back
  • insert(position, val), insert(position, n, val)
  • operator[]
  • pop_back, push_back
  • reserve, resize
  • swap

• STL list
  • assign(first, last), assign(n, val)
  • front, back
  • pop_back, pop_front, push_back. push_front
  • erase(position)
  • insert(position, val), insert(position, n, val)
  • merge (list x)
  • remove(val), remove_if(predicate), sort()
  • splice(position, x), splice(position, x, i), splice, position, x, first, last)
  • swap(list x)
  • unique()
• STL set/multiset/map/multimap
  • count
  • erase(val)
  • insert(val), insert(first, last), insert(initializer list)
  • swap
• STL map/multimap
  • maps only: operator[]
  • insert(make_pair)
  • find

• STL stack
  • Constructor
  • empty
  • pop
  • push
  • size
  • swap (member function)
  • top
• STL queue
  • Constructor
  • back
  • empty
  • front
  • pop
  • push
  • size
  • swap (member function)
• STL algorithms
  • advance(position, n)
  • next (position, n)

Functions to know how to use WITH a given description.

On the exam, you will have descriptions for the functions listed below.

Here is an example of an STL function description:

std::fill_n
OutputIterator fill_n (OutputIterator first, Size n, const T& val);

Fill sequence with value
Assigns val to the first n elements of the sequence pointed by first.
Parameters
- first: Output iterators to the initial position in a sequence of at least n elements that support being assigned a value of type T.
- n: Number of elements to fill.
- val: Value to be used to fill the range.
Return value
An iterator pointing to the element that follows the last element filled.

• STL algorithms
•    
• About these functions:
  • adjacent_find
    • Some do not work with all containers. How can you find out which ones do work? By reading their description in cplusplus.com OR by trying them.
    • Some require a predicate function. Make sure you try them both ways by writing a non-member function and by using a lambda expression.
  • all_of, any_of
  • copy, copy_backward, copy_if, copy_n
  • count, count_if
  • fill, fill_n
  • find, find_if
  • for_each
  • is_sorted
  • remove, remove_if
  • replace, replace_if
  • reverse
  • rotate
  • sort(first, last), sort(first, last, comp)
  • swap
  • unique

The questions will cover:

Linked lists (one or two questions only).

The STL (see the “STL Functions to know” section for more details).

1) 벡터 !!! 

2) 리스트 !! 

3) vector

1) multiset!!

int difference(const set<int>& s) 
{
    return *(--s.end()) - *s.begin();
    //set에서 가장 큰 값과 가장 작은 값의 차이를 계산함
    //end()라는 반복자는 컨테이너의 마지막 요소의 다음을 가리키므로 --s.end()로 함!!
}

int difference(const set<int>& aSet)
{
	return (*aSet.crbegin() - *aSet.cbegin()); //-> 이게 더 직관적인듯
    //crbegin()은 역방향반복자중 가장 큰 요소 ! (reverse) 
    //똑같이 큰값에서 작은값의 차이를 계산함. 
}

2) map !!!!

// 10의 배수는 10,0 일케 / 아니면 12,10 일케 
void multiplesOfTen(map<int, int>& aMap)// map의 형태 기억하기~
{
   int multiple = 0;

   for(auto& pair : aMap)
   {
      if(pair.first % 10 == 0)
      {
         multiple = pair.first;
      }
      else 
      {
         pair.second = multiple;
      }
   }
}

3) Set!!!

void copyAfterFive(const multiset<int>& aSet, multiset<int>& aEmptySet)
{
   //auto aSetElem = aSet.begin(); 
   

   for(auto elem : aSet)
   {
      if(elem > 5 && elem > -10000)
      {
         aEmptySet.insert(elem);
      }
   }
}

1) list !!!

1. sll, dll, list 등의 기본은 nullptr인지 아닌지 확인하는거.. 
   1. count == 0 이나 next_it != nullptr 이렇게 감
   2. iterator이 쓰이는 경우에는 next_it != lst.end();
2. auto it = lst.begin(); auto it_next = next(it); 

void deleteListDuplicates(list<int>& lst)
{
   auto it = lst.begin(); 
   auto next_it = next(it); // ++lst.begin();
   
   while(next_it != lst.end())
   {
      if(*it == *next_it)
      {
         next_it = lst.erase(next_it);
      }
      else
      {
         ++it;
         ++next_it;
      }
   }
}

void deleteListDuplicates(list<int>& aList)
{
    auto iterLeft = aList.begin();    // Cleaner to use “auto” for iterators.
    auto iterRight = ++aList.begin(); // Note the increment operator.
    auto iterEnd = aList.end();       // Avoid calling function list::end() in
    while (iterRight != iterEnd)      //   the while loop header.
    {
        if (*iterLeft == *iterRight)
        {
            iterRight = aList.erase(iterRight);
        }
        else
        {
            ++iterLeft;     // We can do this (different from the vector
            ++iterRight;    // implementation), because we are deleting
        }                   // “consecutive” duplicates.
    }
}

2) vector !! 

1. 이번에는 벡터 ! -> 이번에도 nullptr인지 아닌지 확인하기. 
2. 벡터는 임의접근반복자(random access iterator) 를 사용하기때문에 각 요소에 대한 인덱스를 직접 접근할 수 있는 반복자를 증가시키는게 가능함.  때문에 it +1,이렇게는 가능하지만 ++it은 불가능함 . 

void deleteVectorDuplicates(vector<int>& vec)
{
   auto it = vec.begin();
   
   while(it != vec.end())
   {
      auto next_it = next(it) ; //it + 1 가능! 그러나 ++it, vec.begin()++은 불가능
      while(next_it != vec.end())
      {
         if(*it == *next_it )
         {
            next_it = vec.erase(next_it);
         }
         else
         {
            next_it++;
         }
      }
      it++;
   }
}

1. front() 

#include "DoublyList.h"

int DoublyList::front() const
{
	return first -> getData();
}

2. back()

#include "DoublyList.h"

int DoublyList::back() const
{
	return last -> getData();
}

3.insertBack()

#include "DoublyList.h"

void DoublyList::insertBack(int newData)
{
   //Node* newNode = new Node(newData, nullptr);
   if(first == nullptr)
   {
      first = new DLLNode(newData, nullptr, nullptr);
      last = first;
   }
   else 
   {
      last -> setNext(new DLLNode(newData, last, nullptr));
      last = last -> getNext();
   }
   ++count;
}

4)moveToList()

void DoublyList::moveToList(DoublyList& toList)
{
    // Assume parameter object is empty.
    // Do NOT assume the calling object is empty.
    // Do nothing if the calling object is empty.


    if (count != 0)
    {
        toList.first = first;
        toList.last = last;
        toList.count = count;


        // Detach the calling object from the nodes that
        // now belong to the parameter object.
        first = nullptr;
        last = nullptr;
        count = 0;


        // The calling object still exists, but it is empty
        // as it was when it was created before inserting
        // any elements.
    }
}

5) deleteElem()

void DoublyList::deleteElement(int elementToDelete)
{
	// Case 1: List is empty
	if (first == nullptr)  // OR: if (count == 0)					   
	{
		// Use cerr, rather than cout (why?)
		cerr << "The list is empty.\n";
	}
	else
	{
		// Set a Boolean value to keep track of 
		// whether the item is found or not.
		bool found = false;


		// There is only one node in the list.
		if (first == last)	// OR: if (count == 1)							
		{
			// Node to be deleted is the first node.
			if (first->getData() == elementToDelete)
			{
				delete first;
				first = last = nullptr;
				found = true;
			}
			
			// No need to make a case if the only node 
			// does not store the data to delete.
		}
		else // If there is more than one node...
		{
			// Check if the first node or the last node needs
			// to be deleted. Why should you check this 
			// separately? Because these are special case, 
			// where pointer first and last must be updated.


			if (first->getData() == elementToDelete)
			{
				first = first->getNext();
				delete first->getPrev();
				first->setPrev(nullptr);
				found = true;
			}
			else if (last->getData() == elementToDelete)
			{
				last = last->getPrev();
				delete last->getNext();
				last->setNext(nullptr);
				found = true;
			}
			else // Node to delete might be somewhere in between 
			     // the first node and the last node.
			{
				// Create a pointer to traverse the list.
				// Start pointing at the second node, because
				// you already know that it is not the first node,
				// and stop before checking the last node for the
				// same reason.


				DLLNode* current = first->getNext();
				while (!found && current != last)
					// Don't let the WHILE loop continue if 
					// the element is found!
				{
					if (current->getData() == elementToDelete)
					{
						// connect previous and next node
						current->getPrev()->setNext(current->getNext());
						current->getNext()->setPrev(current->getPrev());
						// NOTE: It would be more efficient to create 
						// a pointer pointing to the previous node and 
						// another pointer pointing to the next node,
						// because we would not have to call too many 
						// functions, but this is good practice for the exam.


						delete current;
						current = nullptr;
						// Don't leave a dangling pointer!


						found = true;
					}
					else
						current = current->getNext();
				}
			}
		}


		if (!found)
			cout << "Element is not in the list." << endl;
		else
			--count; // This statement is needed only once.
	}
}

1) 

#include "AnyList.h"
// 1. insertBack -> 리스트에 있는 목록의 맨끝에 val을 넣는 함수 
// 2. new node 를 만들어서 그 안에 parameter 에 저장된 값을 저장 -> Node* newNode = new Node(val);
// 3. insertBack() 사용법 !!

void AnyList::insertBack(int val)
{
	Node* newNode = new Node(val, nullptr);
	if(first == nullptr)
    {
    	first = newNode;
    }
    else
    {
    	Node* current = first;
        for(int i = 1; i < count ;++i)
        {
        	current = current -> getNext();
        }
        current ->setNext(newNode);
    }
    count++;
}

<insertBack 사용법>

1. Node* newNode = new Node(newData, nullptr) <- 기본 형태 ! 
2. 우선 리스트가 비어있는지, 아니면 뭐가 있는지 확인 해야됨 
   1. 리스트가 비어있다 -> first는 새로운 노드가 들어간다
   2. 리스트가 안비어있다 -> iterator툴로 리스트를 전부 돌려서 맨끝(back)으로 들어가게 한다 
3. 마지막에 count++; 잊지않기 

2)

#include "AnyList.h"

int AnyList::getNumOfElements() const
{
	return count; 
}

-> const 를 언제언제 넣어야되는지, 달라지는 점이 뭔지 알아두자 ! 

3)

1. while문(만약에 element을 찾으면) 으로 true 이면 return 하고 머 이런식으로 
2. parameter은 int, return 값을 boolean. 
3. 일단 모든 elem을 다 돌아봐야되기 때문에 반복문 써야함
   1. while(int elem : 전체? ) 그리고 그 밑에 if else 으로 bool 값 지정 ( count만큼 반복될 예정) 
   2. *** 이건 node 이기 때문에  "-> getData" 이런거 다써야댐!!!!!! " ***

bool AnyList::search(int elem) const 
{
   if(count == 0)
   {
      cerr << "The list is empty." << endl; 
      return false;
   }
   else 
   {
      Node* current = first; 
      
      while(current != nullptr)
      {
         if(current -> getData() == elem)
         {
            return true;
         }
         else
         {
            current = current -> getNext(); 
         }
      }
      return false;
   }
}

4)

void AnyList::replaceData(int oldKey, int newKey)
{
	bool found = false; // to stop the loop when key is found
	Node* current = first;
	while (current != nullptr && !found)
	{
		if (current->getData() == oldKey)
			found = true;
		else
			current = current->getNext();
	}


	if (current == nullptr) // key was not found
		cout << "Element is not in the list." << endl;
	else
		current->setData(newKey);
}
// 내가 생각한거 까지는 
void AnyList::replaceData(int oldData, int newData)
{
   Node* current = first; 
   
   while(current != nullptr)
   {
      if(current ->getData() == oldData)
      {
         current -> setData(newData);
      }
      else
      {
         cout << "Element is not in the list." << endl;
         current = current -> getNext();
      }
   }
} // 이거였어 근데,, 이러면 element is not in the list 가 개많이 나옴 왜냐면은 안나올때마다 계속 되야되니까 ...

... 플래그 쓰는거 너무 어렵다 ㅠ .... 연습하쟈 ! 

5) 

void AnyList::deleteElem(int elem)
{
    if (count == 0) // OR: (first == nullptr)
    {
	  // Review the Course Style Guide to learn when to use cerr/cout.
        cerr << "The list is empty." << endl;
    }
    else
    {
        // Search if the elem is in the list.
        // When found, delete the node.


        // if it is the first node
        if (first->getData() == elem)
        {
            Node* current = first;
            first = first->getNext();
            delete current;
            current = nullptr;
            --count;
        }
        // else (could be any of the other nodes)
        else
        {
            bool found = false;
            Node* trailCurrent = first;
            Node* current = first->getNext();
            // OR: Node* current = trailCurrent->getNext();


            while (!found && current != nullptr)
            {
                if (current->getData() == elem)
                {
                    trailCurrent->setNext(current->getNext());
                    delete current;
                    current = nullptr;
                    --count;
                    found = true;
                }
                else
                {
                    trailCurrent = current;
                    current = current->getNext();
                }
            }


           if (!found) // Do NOT write (found == false) !!!
                       // Redundant statement.
               cout << "Element " << elem 
                   << " is not in the list.\n";
        }
    }
}

이것도 어렵다 .. 다시다시 ㅠ 

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";
}

.. 뀼