ㅎㅎ 

연관 컨테이너 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. 

끗 ! 어렵다 .. 

우선 헤더에 #include <iterator> 넣는거를 까먹지 말자!

ostream_iterator는 출력 스트림 반복자로, 타입 매개변수로 원소의 타입을 받는 클래스 템플릿입니다. 생성자는 출력 스트림과 이 스트림의 원소 끝마다 붙일 string 타입의 구분자를 인수로 받습니다. ostream_iterator 클래스는 스트림에 원소를 쓸 때 operator<<를 사용합니다.

- Used to output data to an output stream 

ostream_iterator<Tyoe> out(ostream&);

예시:

#include <iterator>
...
ostream_iterator<char> screen1(cout);
copy(v.begin(), v.end(), screen1);
	//will output the contents of v

1. ostream iterator 의 delimiter (출력 반복자의 구분자)

ostream_iterator<Type> out(ostream&, char* deLimit);

deLimit이라는 구분자를 통해 char단위로 쪼개서 출력할 수 있음

예시:

ostream iterator<int> screen2(cout, " ");
copy(v.begin(), v.end(), screen2);
	// will output the contents of v
	// seperated by a space

2. range-based FOR loop

vector<int> aVector = {1, 2, 3, 4, 5};
for (int i : aVector)
	cout << i << " ";

- less prone to errors : 범위를 벗어나는 out-of-bonds 접근을 방지 하기때문에 오류 발생률이 적음 

- Does not use a counter variable : 인덱스를 사용하는 전통적인 for loop와 달리 컨테이너의 요소를 직접 사용.  반복 변수를 따로 선언하거나 업데이트할 필요가 없음 

- Does not use a subscript operator : 배열접근연산자를 사용하지않음 ! 컨테이너의 요소를 직접 참조함

vector<string> aVector = {"First", "Middle", "Last"};
for(const string& i : aVector)
	cout << i << " ";

-> 참조사용하기 !

3. AUTO !!

vector<int> aVector = {1, 2, 3, 4};

auto iter = aVector.begin();
auto iterEnd = aVector.end();

for(iter; iter != iterEnd; ++iter)
	cout << *iter;

장점 : initialization expression 에서 형을 유추하게 하여 코드의 가독성을 높임. ex: (string) 일케하면 너무 길다..

단점 : 변수의 타입이 명확하지않거나 추론이 복잡할 경우 오히려 가독성을 해칠 수 있음 ! 

끝 ! 

ostream겁나 어렵네.. 먼소린지 모르겠다 ; /Mar 29 2024

~ 순환 반복자 ~

for 문과 while문으로 싸이클을 돌려보아요.. 

vector<int> v = {1, 2, 5, 7, 8};
vector<int> const_iterator iter = v.cbegin(); 
vector<int> const_iterator iterEnd = v.cend();

for(iter; iter != iterEnd; ++iter) //NULLPTR가 아닐때까지 싸이클
{
	cout << *iter <<endl;
}

while(iter != iterEnd) 
{
	cout << *iter << endl;
    ++iter;
}

잘했나요..? 사실 for문에서 !=을 쓰는건 아주 위험하다구 합니다.. 

while문으로 써보는 습관을 기르자 ! 아자아자 ! 

거꾸로 싸이클을 돌려보고 싶다면 어떻게 해야될까요??

iter 을 v.cend() 으로 설정하고 반대로 돌리면 되지않을까? 라고 생각할 수 있지만 

v.cend() function은 null값을 가르키기 때문에 할수 없음 !!!!

for(iter; iter != iterBegin; --iter) // DOES NOT WORK!

이 부분에 대해서는 Cycling in Reverse Order 으로도 해볼 수 있따! 

vector<char>::reverse_iterator revIter = v.rbegin();

참쉽져 ㅎㅎ

만약에 const를 쓰고 싶다면 

vector<char>::const_reverse_iterator constRevIter = v.crbegin();
vector<char>::const_reverse_iterator constRevIterEnd = v.crend();
for(constRevIter; constRevIter != constRevIterEnd; ++constRevIter)
	cout << *constRevIter << endl;

이렇게 간다!  사실상 뒤로(backwards)로 움직이는 거지만, ++을 써야함! 왜냐,., 이건 REVERSE니까.. 

~summary~

끝 ㅎㅎ

1. begin() 

vector<int> v = { 10, 20, 30, 40, 50, 60 };
cout << *(v.begin( ) + 4); // will print 50
vector<int>::iterator iter = v.begin( ) + 2;

// iter will point to 30

++iter; // moves iter forward
cout << *iter; // will print 40

2. end()

end function은 그냥 FLAG!!

* last element 를 포인트 하지않음 

* --v.end() 는 value가 unpredictable하기 때문에 쓸수없음 

3. Constant iterators 상수형 반복자 

- 컨테이너의 요소를 반복하여 읽기만 할때 사용

- 벡터의 요소를 반복하면서 해당 요소를 변경하지 않고 출력 

-  컨테이너 요소를 수정할 수 없는 환경에서 사용 

vector<char>::const_iterator iter = v.cbegin();
*iter = 39; // illegal

4. Cycling Iterators 순환 반복자 

vector<int> v = {1,2,3,4};
vector<int>::const_iterator iter = v.cbegin();
vector<int>::const_iterator iterEnd = v.cend();
for (iter; iter != iterEnd; ++iter)

cout << *iter;
//*iter is current data item

vector<int> = {1,2,3,4,5};
vector<int>::const_iterator iter = v.cbegin();
vector<int>::const_iterator iterEnd = v.cend();
while (iter != iterEnd)
{

...
++iter;
//*iter is current data item

}

순환반복자 .. 다음편에서 계속 .. ^ㅅ^

~ Container를 살펴보기 전에 Iterator를 살펴봅시다 ~

Container classes make an intensive use of iterators to .... 

1. 컨테이너에 들어가는 데이터들의 순환을 도움

2. 각기 다른 컨테이너들에게 동일한 인터페이스를 제공 (provide uniform interface)

3. 반복자는 포인터의 "일반화 된 개념"이다. -> 포인터는 아님! 추상화된 개념! (A generalization of a pointer) 

4. An iterator variable points to one data entry in the container  

5. Each container has its "own" iterator type -> 데이터타입 들이 그들만의 반복자 타입을 갖고있는거랑 유사함! 

예시 ; 

// Container type's own iterator type
std::vector<int> myVector;
std::vector<int>::iterator iter; // 벡터에 대한 iterator 타입
std::list<double> myList;
std::list<double>::iterator iter; // 리스트에 대한 iterator 타입
std::map<std::string, int> myMap;
std::map<std::string, int>::iterator iter; // 맵에 대한 iterator 타입
std::set<float> mySet;
std::set<float>::iterator iter; // 세트에 대한 iterator 타입

// Data type's their own pointer type 
int* dynamicArray = new int[10];
int* iterator = dynamicArray; // 동적 배열에 대한 반복자 타입
std::string str = "Hello";
std::string::iterator iter = str.begin(); // 문자열에 대한 반복자 타입
int arr[5] = {1, 2, 3, 4, 5};
int* iter = arr; // 배열에 대한 반복자 타입
int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int* iter = *matrix; // 매트릭스에 대한 반복자 타입

<반복자에 대한 멤버함수들 - member functions for iterators>

ct.begin() : Returns an iterator for the container ct that points to the first data item in ct(container) 

ct.end() : It is a flag and does NOT return the last element - IT IS LIKE NULL !!!!!!

<Iterator Operators>

< STL > 

- Standard Template Library (STL) : library of classes and associated functions 

- 한국어로는 표준 라이브러리라고 한다. 

- template-based components 를 통해 software reuse을 함.  -> 이는 타입의 일반화로 말할 수있음 

: which is "GENERIC PROGRAMMING ! " ( vs functional programming - 함수형 프로그래밍) 

<STL 의 구성요소> 

1. Containers : 컨테이너 

- Data structures capable of storing objects of almost any data type (there are some restrictions) 

- 흔히 stl 자료구조라는 것이 stl container으로 통용된다. (컬렉션이라 칭하는 경우도 있음) 

2. Iterators ( -> objects) : 반복자 

- Used to step through the elements of a container

- 포인터 같은거 

3. Algorithms ( = non-member functions) : 알고리즘 

- Functions that perform common data maniputation such as sorting, searching, and comparing elements (or entire contatiners) 

- sorting, searching, comparing 같은 일반적인 해결방법을 규격화 - 형식화 해놓은 방법?? 

<STL 의 장점> 

- 개가티 빠르다 

- 짜여져 있는 템플릿을 적재적소에 넣으면 되기 때문에 효율성이 무쟈게 올라간다 

.. 단점은 아직 모르겟음 ㅋ. ( 그치만 아마 Generic programming의 단점이 그대로 가지않을까 하는 생각이 든다) 

다음은 STL의 Iterator에 대해서 아라보자 

いつサッーカーやってるの？　： 축구 언제해 ?? .. 사실 넘 쉬운 일본어라 한번에 알아들었따 

그치만 새로운 사실 

1. 이츠 사카얏떼루노? 도 할수 있지만 

2. 사카 이츠 얏떼루노?? 도 할슈있당 ㅎㅅㅎ 

いつ는　いつもなんどでも(언제나 몇번이라도) 에서처럼 언제? .. 임 

やってる 는 야루 (~하다?) 의 의문 + 진행형 인데 

여기서 축구를 하다는 サッーカーをやる。라구 생각할수 있지만 사카는 스루다 .. 

축구어디서 할꺼야는 : 사카 도코데 스루노? 사카 도코니 스루노?? 정도가 될거같다(고 생각한당.....) 

데 니 는 아직도 구분 모단다 . 

근데 또 야루가 뭐냐구 하면 좀 곤란해지는데 왜냐면 일단 내가 생각했을때는 전혀 와닿지 않기 때문이다 ..

나의 짧은 일본어회화 알아듣기 능력으로는 ... 

야루 -> やったぜ！！（해냈다!!)   やってみよっかな（해볼까나 ~~ ) 이런거고 

스루 -> 勉強するとかサッーカーする、、、대충 요약 : 야루가 좀더 casual하다구 생각해

애들한테 물어봐야겠다 .........

두번째 .. 

칭구들이랑 얘기하다가 내가 케미오로 일본어로 공부 한다 하니까 난리가 나버려서 .. 

또 내가 팬서비스로 アゲアゲー를 해죠따 ㅎㅎ

여기서 아게아게는 그냥 갸루 감탄사 (?) 그런거라서 .. 이거는 모르겠구 

아게 뜻도 물어봤는데 그건 까먹었구 

テンションあがってます。：I'm high　（テンション上がってます。）

テンションたかい。　：I'm high （テンション高い。）

둘다 하이하다 정도의 느낌이당 . . 

끝 .... 

## Assuming that you are not implementing a portion of the standard library, which of these are legal identifiers. (This means that they follow the syntax rules for C++)

- switch 

- _int 

- string 

what is  L-Value, R-Value or Non-Modifiable L-Value. ??? 

In C++ and many other programming languages, the terms "L-value" and "R-value" are used to classify expressions based on whether they can appear on the left side of an assignment (`=`) operator or not. Additionally, there's a concept called "non-modifiable L-value," which refers to an L-value that cannot be modified. Here's an explanation of these terms:

1. **L-Value (Left Value)**:
   - **Definition**: An L-value is an expression that refers to a memory location, and it can appear on the left side of an assignment operator (`=`). In other words, it represents an object or variable that can be modified.
   - **Example**: Variables, array elements, and non-const references are typically L-values. For instance, `int x = 5;` - here, `x` is an L-value.

2. **R-Value (Right Value)**:
   - **Definition**: An R-value is an expression that represents a value and cannot appear on the left side of an assignment operator. R-values are typically temporary and may not have a memory location.
   - **Example**: Literal values (`5`, `"hello"`), the result of an expression (`x + y`), and function return values are often R-values.

3. **Non-Modifiable L-Value**:
   - **Definition**: A non-modifiable L-value is an expression that refers to a memory location like an L-value but cannot be modified. It represents an object that is marked as const.
   - **Example**: A const variable (`const int y = 10;`) is a non-modifiable L-value because you cannot modify its value.

Here are some examples to illustrate these concepts:

```cpp
int x = 5;         // 'x' is an L-value.
int y = x + 3;     // 'x + 3' is an R-value (temporary result).
const int z = 7;   // 'z' is a non-modifiable L-value (const variable).

x = 10;            // 'x' is an L-value, and it can be modified.
// 'y = 15;' would be a compilation error because 'y' is an R-value.
// 'z = 8;' would be a compilation error because 'z' is a non-modifiable L-value.
```

In summary, L-values are expressions that can appear on the left side of an assignment, R-values are expressions that represent values and cannot be on the left side of an assignment, and non-modifiable L-values are L-values that are marked as const and cannot be modified.

이 아이의 특징 .. 

1. native code 

2. machine language

3. machine dependent 

This code is written in machine (and assembly) language for a specific processor; thus it is non-portable or machine dependent. This is the native code for the 6502 processor. Machine language is both difficult to write and to understand. (That's why Woz added all of the comments on the right).

step 1 - text editor : vim 같은거 ! 처음에 텍스트 에디터로 코드 작성함 

step 2 - preprocessor : Performs text substitution on your source code / Converts processed source code to object code.

step 3 - compiler : converts processed source code to object code 

step 4 - linker : combines object files with library code to produce the executable image, 

step 5 - loader : reads the program on disk, loads any required shared libraries and starts the program running.

step 6 - CPU : responsible for executing your code 

그니까 1. 빔으로 텍스트 써서 코드 쓰면 2. 프리프로세서가 적은 텍스트를 코드로 substitute하고  3. 컴파일러가 sourcecode 를 object code 로 convert 해 4. 컴차일이 되면 링커가 뭔가 결과를 내기위해서 매치를 링크를 함 5. 로딩을 함 6. 결과를 냄 ???

/**
 *  @author Jimin
 *  @date Thu Aug 31
 *  @file h01.cpp
 */ -> (1) documentation comment
 
#include <iostream>
#include <string>
#include <iomanip> // -> (2) standard library

using namespace std; // -> (3) namespace directive

double convert(double temp); // -> (4) function prototype 

int main()
{
cout << "Enter a temperature in 화씨"; // -> (6) prompt
double fahr; // -> (7) variable statement 
cin >> fahr;
double celsius = convert(fahr); //-> (9) function call 
cout << "Converted: " << fanhr << "F -" << celsius << "C" << endl; // -> (10) output statement 
return 0; // -> (11) optional return 

double convert(double temp) // -> (14) parameter
{
return (temp -32 ) * 5.0 /9.0; // -> (13) expression
} 
// -> (12) function definition