#include <iostream>
#include <vector>

int main() {
  std::vector<int> vec;
  vec.push_back(10);  // 맨 뒤에 10 추가
  vec.push_back(20);  // 맨 뒤에 20 추가
  vec.push_back(30);  // 맨 뒤에 30 추가
  vec.push_back(40);  // 맨 뒤에 40 추가

  for (std::vector<int>::size_type i = 0; i < vec.size(); i++) {
    std::cout << "vec 의 " << i + 1 << " 번째 원소 :: " << vec[i] << std::endl;
  }
}

#include <iostream>
#include <vector>
#include <string>
// vector is basically like a resizeable array
using namespace std;

int main() {

	vector<string> strings;
	//vector is template class
	//vector<> <- inside of blanket is type of the variable we are going to create
	//resizeable automatically memory value.
	//if we use push_back we dont need to add strings()


	strings.push_back("one");
	strings.push_back("two");
	strings.push_back("three");
	// index one two in along way
	// Push_back은 vector 의 끝에 요소를 추가할 때 사용 되는 함수이다.
	// push_back is delete the element in list
	cout << "For loop: " << endl;
	for(int i=0; i<strings.size(); i++) {
		cout << strings[i] << endl;
	}
	cout << endl;
	// .end() <- after the element
	// vector.end() <- end interator를 반환
	// vector.begin() <- beginning iterator 반환
	//
	cout << "Iterator loop: " << endl;
	//The auto keyword specifies that the type of the variable that is begin declared will automatically be deduced
	//from its initializer and for functions if their return type is auto then that will be evaluated by return type expression at runtime.
	// auto 키워드를 사용하면 초깃값의 형식에 맞춰 선언하는 인스턴스(뱐수)의 형식이 자동으로 결정된다.
	for(auto it = strings.begin(); it != strings.end(); ++it) {
		cout << *it << endl;
	}
	cout << endl;

	cout << "Single item." << endl;
	vector<string>::iterator it = strings.begin();
	//strings.begin()<- this will actually give us a thing called an iterator(반복자)
	//which points to the first element in the vector.
	//vector<string>::iterator it <- it is that equal to return value of string stop again

	it += 2;
	// so we gonna call the first vector + 2 index value

	cout << *it << endl;

	return 0;
}

vector<double> numbers(0);
//specifiy the argument (0)

cout << "Size: " << numbers.size() << endl;

int capacity = numbers.capacity();
//.capacity is the size of the internal array that the vector is using and that size is
//going to increase as you add elements
cout << "Capacity: " << capacity << endl;
//we've reserve we precisely rated 20 elements. so capacity is 20
//capacity 배열의 크기만 신경쓴다. 값은 신경안씀!

for(int i=0; i<10000; i++) {

	if(numbers.capacity() != capacity) {
		capacity = numbers.capacity();
		cout << "Capacity: " << capacity << endl;
	}

	numbers.push_back(i);
}
// expenantionaly incresae number of elemenst
// propotiaonal to the number of elements in the array
// if insert an element into a vector and it has to internally create a new array
// a bigger capacity and then copy the elements from the order rates.
// how big our arrays going to get based on its current size
// and it crease the capacity based on that
// capacity is completely different the size of capacity is the size of the internal
// rate it reserved the size the actual number of elements that are added to that vector
numbers.reserve(100000);
//numbers.resize(100) <- only resize size of valuable.
//reserve method, we want to reserve(적립하다.) memory and in turn on a rate
//increase size of capacity array.
cout << numbers[2] << endl;
cout << "Size: " << numbers.size() << endl;
cout << "Capacity: " << numbers.capacity() << endl;

//numbers.clear() <- remove all of the element in the vector
//doent change the capacity of the internal array


return 0; }

> Result

<a href="https://postimg.cc/kVvY541T"><img src="https://i.postimg.cc/Dzt9B4q3/421321312.png" width="700px" title="source: imgur.com" /></a>

# Two Dimensional vectors
- Vector<> <- column
- Vector<vector<>> <- raw
- grid( 3<- 3 raw , vector<int>(4,7) <- some value put)
- 3 space of raw, 4 space of column all value is 7

grid[1].push_back(8);

for(int row=0; row < grid.size(); row++) {
		for(int col=0; col < grid[row].size(); col++) {
			cout << grid[row][col] << flush;
			//grid[row] is the vector
			//and [col] is to access the elements in that particular row using
			//this column
		}

		cout << endl;
}

return 0; } ``` > Result

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

class Test
{
	string name;
	int id;

public:
	Test(int id, string name) :
		id(id), name(name)
	{

	}

	bool operator<(const Test &other)  const {
		return name == other.name ? id < other.id : name < other.name;

		//?: <- is the conditional operator
		// condition ? result_if_true : result_if_false
		/* int qempty()
		{
            if(f==r)
            {
                return 1;
            }
            else
            {
                return 0;
            }
		}*/ // example of conditional operator
	}
	// because of for function??

	void print()
	{
		cout << id << ": " << name << endl;
	}

	friend bool comp(const Test &first, const Test &second);
	// friend function은 protect data/function 에 접근이 가능하다.
};

bool comp(const Test &first, const Test &second)
{
	return first.name < second.name;
}
// 알파뱃 순서로 정령한다.

int main(int argc, char const *argv[])
{

	vector<Test> tests;

	tests.push_back(Test(5, "Mike"));
	tests.push_back(Test(10, "Sue"));
	tests.push_back(Test(7, "Raj"));
	tests.push_back(Test(3, "Vicky"));

	sort(tests.begin(), tests.end(), comp);
	//comp is the funtion pointer

	for(int i = 0; i < tests.size(); i++)
	{
		tests[i].print();
	}

	return 0;
}