• ** 뼈 구조를 맞춰주어 다른 캐릭터의 애니메이션을 사용할 수 있게 해주는 기능 **

💡 사용법

📢 타겟(애니메이션을 적용 시킬 스켈레탈 메쉬)의 IK Rig을 만들어 준다

↳ 컨텐츠 브라우저 우클릭 - 애니메이션 - 리타겟팅 - IK Rig 클릭

↳ 새로 생성된 IK Rig 첫 화면, 우측 Preview Mesh 에서 타겟 스켈레탈 메쉬를 적용

소스 IK Rig	타겟 IK Rig

뼈를 선택한 후 우클릭 - New Retarget Chain 클릭	체인 이름을 확인하고 Add Chain 클릭

우측 하단에서 체인 확인 및 삭제 가능

↳ 소스(옮겨줄 애니메이션을 갖고있는 스켈레탈 메쉬)의 IK Rig을 참고해 타겟의 IK Rig을 만들어 준다

↳ 완성한 모습

📢 IK Retargeter를 만들어 준다

↳ 컨텐츠 브라우저 우클릭 - 애니메이션 - 리타겟팅 - IK Retargeter 클릭

↳ 소스, 타겟 스켈레탈 메시 설정 ↳ 소스와 타겟이 겹쳐 있으므로 타겟 메쉬 오프셋에서 x축 200으로 설정 << 필수는 아니고 확인할 때 편함

↳ 에셋 브라우저에서 애니메이션을 클릭해 두 캐릭터의 모션을 확인할 수 있음

📢 사용할 애니메이션을 리타겟팅 해준다

↳ 애니메이션 에셋 우클릭 - Retarget Animation Assets - Duplicate and Retarget Animation Assets/Blueprints 클릭

↳ 아주 잘 작동하는 모습

💡 문제점

📢 애니메이션 루트모션 사용 / 미사용이 적용이 안된다!

• ** 애니메이션의 Enable Root Motion 체크를 해도 안된다.... 왤까... **

📢 (수정) 찾았다!!!!!!!!!

[참고 블로그] https://boobiebird.tistory.com/55

• ** 빌드 시 발생 **

💡 해결법

• ** 에디터 라이브 코딩 비활성화 시키니 해결 ** - 에디터 우측 하단, 라이브 코딩 활성화 체크표시 해제

• ** 사용자가 동적으로 할당한 영역 중 더 이상 사용하지 않는 영역을 찾아 자동으로 해제하는 기능 ** - C++의 경우 사용자가 직접 해제해줘야 하지만, C#의 경우 GC가 자동으로 해준다.

💡 Garbage Collection Generation

• ** Generation은 객체가 Garbage Collection을 몇번 거쳤는지 나타낸다 **

• ** 세대가 높을 수록 즉, Garbage Collection을 겪고도 생존한 객체들을 중요한 객체로 판단하는 방식 **

• ** 기본적으로 0세대를 대상으로 먼저 Garbage Collection을 시행하고, 그럼에도 공간확보가 부족하다면 1세대까지 포함, 그럼에도 부족하다면 2세대까지 포함시켜 시행한다 **

📢 ** 2세대까지 포함한 모든 Garbage Collection 수행 시 아예 프로세스를 일시정지하고 우선적으로 수행하기 때문에, 순간적인 프레임 드랍 등이 일어나게 됩니다. **

💡 Garbage Collection의 동작 방식

• ** 크게 3가지 과정을 거친다. ** 1) Mark, 사용되고 있는 개체들을 연결하는 작업 2) Relocate, 사용되지 않는 개체들을 식별하는 작업 3) Compact, 필요 없는 객체들을 지우고 살아있는 객체들을 모으는 작업

📌 Mark

Garbage Collection 주기가 시작될 때 일단 모든 object를 가비지로 가정한다. 즉, 루트 목록 내 어떤 루트도 메모리를 가리키고 있지 않다고 가정한다. 이 상태에서 가비지 컬렉터는 루트 목록을 돌면서 각 루트가 참조하는 것들을 마킹한다. 루트가 참조하는 힙 object가 또 다른 힙 object를 참조한다면 이 object 또한 마킹한다. 좀 더 언밀히 말하면 마킹이란 루트 목록에서 시작되는 연결된 그래프를 만드는 것이다. 루트에서 연결될 수 있는 object를 우리는 도달할 수 있는 object라 부른다.

📌 Relocate

루트 목록에서 도달할 수 없는 object들을 가비지로 간주한다. 가비지가 차지한 공간은 비어 있는 공간으로 간주하게 된다.

📌 Compact

루트 목록에 대한 조사가 끝나면 가비지 컬렉터는 힙을 순회하며 가비지가 차지했던 비어있는 공간에 인접한 도달할 수 있는 object들을 메모리 복사를 통해 덮어 씌운다. 도달 가능한 모든 object에 대한 이동이 끝나면 가비지 컬렉터는 포인터의 위치 또한 적절하게 수정한다

💡 Garbage Collection의 중요성

📌 자동으로 방식하는데 왜 동작 방식까지 알아야 하는가..?

• ** Garbage Collection도 자원을 사용하는 소프트웨어, 유한한 자원을 사용하는 프로그램에서 Garbage Collection이 사용하는 자원을 줄일 수 있다면 프로그램의 성능이 늘어나기 때문! ** - 이러한 이유를 바탕으로 코드를 작성할 때 아래와 같은 노력들을 할 수 있다.

  • 객체 너무 많이 할당하지 않기 너무 많은 object를 생성하면 그 만큼 메모리가 금방 차고 Garbage Collection이 빈번히 발생하게 될 것이다.
    
  • ** 너무 큰 객체 할당하지 않기 **
    
  • ** 복잡한 참조 관계 만들지 않기 ** Garbage Collection 후 도달할 수 있는 object의 세대를 옮기기 위해 메모리 복사를 수행한다. 이때 참조 관계가 복잡하다면 단순히 메모리 복사가 아니라 참조하고 있는 모든 메모리 주소를 수정하는 과정을 거쳐야 한다.
    
  • 루트를 많이 만들지 않기 루트 목록을 기반으로 가비지를 찾아내기 때문에 많지 않다면 그만큼 루트 목록을 순회하는 시간을 줄일 수 있다.

• ** Unity에서 제공하는 기능 **

• ** Prefab은 GameObject를 에셋의 형태로 저장해 사용 하는 것 ** - 컴포넌트, 프로퍼티 포함

• ** Prefab object들은 여러개 생성해 사용할 경우 단순 복사와 달리 동기화가 이루어 짐 ** - object를 단순 복사할 경우 수정 사항을 복사된 object들 하나 하나 변경해야 하지만 Prefab object들은 동기화를 통해 Prefab 에셋만 변경하면 한번에 변경이 이루어 진다

💡 Prefab 필요성?

* 1. 똑같은 오브젝트를 많이 배치해야 하는 경우... * - Prefab을 사용하지 않는다면 필요한 컴포넌트를 매번 부착해줘야 하는 비효율적인 작업이 필요해짐

* 2. 1번과 같은 경우를 피하고자 오브젝트를 복사했는데, 오브젝트의 수정이 필요한 경우... * - 예를 들어 오브젝트의 scale을 2배로 키우려고 할 경우, 복사된 모든 오브젝트들을 하나 하나 수정해줘야 한다...

💡 Prefab 장점?

• ** 재사용이 편하다 **

• ** 여러군데 배치되어있는 prefab 인스턴스들을 한꺼번에 수정하기 쉽다 **

• ** 컴포넌트만 제대로 만들어 준다면, 프로그래머에게 요청하지 않고도 손쉽게 게임 요소들을 수정할 수 있다 **

💡 Prefab 인스턴스화?

• ** Prefab 원본 그대로는 게임 씬에서 보거나 사용할 수 없으며 이것을 게임 씬에 배치하고 사용할 수 있게 생성하는 과정을 인스턴스화 라고 한다 **

• ** GameObject의 Instantiate() 함수를 이용해 인스턴스화 한다 **

• ** Unity에서 제공하는 기능 **

• ** 코드 내에서 구문 실행 도중에 처리를 대기시키거나 순차 처리에 함수를 병렬로 동시에 처리하도록 구현하는 기능 ** - 쉽게 말해 내가 필요한 순간에만 반복하고 필요하지 않은 순간에는 사용을 하지 않을 수 있다

💡 Coroutine의 필요성?

• * 시간이 지남에 따라 점진적으로 결과를 보여주고자 할 때 *

• * 어느 시점으로부터 일정 시간 이후 작업을 진행하고자 할 때 *

• * 프레임마다 호출이 아닌, 일정 시간마다 호출하여 연산의 수를 줄이고자 할 때 *

• * 너무 무거운 작업을 Update에서 진행할 시의 오버헤드를 방지하고자 할 때 *

💡 Coroutine 사용 방법!

📌 Coroutine의 필수 조건

• ** Coroutine은 IEnumerator를 반환해야 한다 ** - IEnumerator : StartCoroutine()함수의 매개변수, C#의 iterator

• ** yield return이 반드시 함수 내부에 존재해야 한다 ** - yield return의 반환 값에 따라 일시 정지, 재개에 대한 기준이 마련 된다. - yield break로 진행중인 코루틴을 중단할 수 있다.

📌 Coroutine 실행 방법

• ** 매개변수로 함수 형태로 전달 ** - 성능이 더 뛰어나지만 제어권을 얻을 수 없다

• ** 매개변수로 함수의 이름을 전달 ** - 해당 코루틴의 중지를 제어 할 수 있다.

📌 Coroutine 정지 방법

• ** 매개변수로 함수의 이름을 전달 ** - 해당 이름의 코루틴을 중지.

• ** StopAllCoroutines() 함수 이용 ** - 해당 스크립트에서의 모든 코루틴을 중지.

💡 Coroutine 사용 예시!

📌 * 실행 후 2초가 지난 시점부터 1초 간격으로 "Coroutine!" 로그를 3번 만 띄워보자! *

* [ update 이용시 ] * * - 매프레임 마다 시간을 중첩시켜 연산 * * - 2초가 지나는 시점 1초 간격을 위한 연산 * * - 로그가 3번 띄워져야 하기 때문에 실행 후 2초, 3초, 4초에 1번씩 "Coroutine" 로그를 띄우고 * * - 4초가 지난 후 부터는 로그를 띄우지 않게 예외처리를 해준다 * * - 하지만 update이기 때문에 매 프레임 불필요한 연산을 반복함 *

* [ Coroutine 이용시 ] * * - 내가 원하는 시점(실행 후 2초가 지난 시점)에 Coroutine 실행 * * - Coroutine 내부에서 루프문을 통해 1초 간격으로 3번만 "Coroutine" 로그를 띄움 * * - 3번의 루프를 빠져나오면 Coroutine 종료 * * - Coroutine이 종료되어 더이상의 불필요한 연산을 할 필요가 없음 *

• ** 조건부 Explicit 생성자 **

• ** 조건에 맞는 경우에만 암시적 형변환을 허용 하겠다! **

💡 Designated Initialization 사용 방법!

• ** explicit(조건) 조건 설정**

  class CTest
  {
    template<typename T>
    explicit(!std::is_same<T, bool>::value) Test(T t)
    {
        ...
    }
    ...
  }
  

void MyFucn(CTest test) { ... }

CTest test = true; MyFucn(test); // OK! MyFucn(true); // OK! 조건에 맞는 bool 타입 이기 때문에 암시적 형변환 허용! MyFucn(10); // Error! 조건에 맞지 않는 int 타입 이기 때문에 암시적 형변환 불가! ```

** [ OSTEP ] 정리 모음집 " OS공부를 위한, 램지 H. 아파시 뒤소의 OSTEP 을 읽고 내용 요약 / 정리 "**

💡 핵심

" 가상 메모리 시스템은 프로세스 전용 공간이라는 환상을 프로그램에게 제공할 책임이 있다! "

• 가상 메모리에 프로그램 명령어 전부와 데이터 전부가 저장되며, 하드웨어의 도움을 받아 운영체제는 가상 메모리 주소를 물리 주소로 변환시킨다.
• 물리 주소는 원하는 정보를 반입하기 위해 물리 메모리에 전달된다.
  📢 운영체제는 많은 프로세스를 대상으로 이러한 작업을 수행해 프로그램과 운영체제를 보호한다!

💡 주소 공간의 개념

📌 초기 시스템

• ** 초기 컴퓨터의 물리 메모리 ** - 특별한 가상화는 존재하지 않았으며 사용자 또한 운영체제로부터 그리 많은 것을 기대하지 않음 - 물리 메모리에 하나의 실행중인 프로그램이 존재했으며 해당 프로그램은 운영체제가 차지하는 공간 외의 공간을 사용 함
  

📌 멀티 프로그래밍 & 시분할

• ** 더 효과적인 컴퓨터를 위해 시분할을 이용한 멀티 프로그래밍 시대가 도래! **

• ** 초기 시분할 기법은 매우 엉성 했다! ** - 하나의 프로세스를 짧은 시간 동안 실행시키고 해당 기간 동안 프로세스에게 모든 메모리를 접근할 권한을 줌, 기간이 끝나면 프로세스를 중단하고 중단 시점의 모든 상태를 디스크 종류의 장치에 저장한 후 다른 프로세스를 탑자해 실행시킴...[반복] - 메모리 내용 전체를 디스크에 저장하는 행동이 반복되어 속도가 매우 느렸다.

• ** 프로세스 전환 시 프로세스를 메모리에 그대로 유지하면서, 운영체제가 시분할 시스템을 효율적으로 구현할 수 있게! ** - 위와 같이 메모리에 프로세스를 유지하고 하나의 프로세스가 실행될 떄 다른 프로세스들은 준비 큐에서 실행을 기다림 - 여러 프로그램이 메모리에 동시에 존재하려면 각 프로세스가 서로의 메모리를 읽거나 혹은 더 안좋게 쓸 수 있는 상황이 없어야 하므로 보호(protection)가 중요한 문제!

📌 주소 공간

• ** 운영체제의 사용하기 쉬운(Easy To Use) 메모리 개념 ** - 프로세스가 서로의 메모리를 읽거나 사용하는 행위를 막기 위함

• ** 주소 공간은 실행 프로그램의 모든 메모리 상태를 갖는다 **

  

  • ** 코드(Code) ** - 코드, 명령어 - 코드는 정적이기에 주소 공간에 저장하기 쉬워 상단에 배치하며 프로그램 실행되면서 추가 메모리를 필요로 하지 않음
  • ** 스택(Stack) ** - 함수 호출 체인 상의 현재 위치, 지역 변수, 함수 인자와 반환 값 등 저장 - 프로그램이 실행되면서 메모리가 확장되거나 축소될 수 있기에 하단에 배치 - 확장시 위 방향으로 확장
  • ** 힙(Heap) ** - C의 malloc(), C++의 new를 통해 할당된 동적 메모리 - 프로그램이 실행되면서 메모리가 확장되거나 축소될 수 있기에 상단에 배치 - 확장 시 아래 방향으로 확장

  📢 ** 정적 변수 등이 위치하는 데이터(Data)영역도 있지만 코드, 스택, 힙만 있다고 가정! ** 📢 ** 스택과 힙의 배치는 관례일 뿐 주소 공간을 다르게 배치할 수도 있다!** 📢 ** 실제로 프로그램이 물리 주소 0에서 16KB 사이에 존재하는 것이 아니며 실제로는 임의의 물리 주소에 탑재된다!**

📌 메모리의 가상화(Virtualizing Memory)

• ** 운영체제가 물리 메모리를 공유하는 다수의 프로세스에게 프로세스 전용의 커다란 주소 공간이라는 개념을 제공하는 것 ** - 사진의 프로세스A가 주소 0으로부터 load 연산을 수행할 때, 운영체제는 하드웨어의 지원을 통해 물리 주소 0이 아니라 물리 주소 320KB를 읽도록 보장해야 함 📢 ** 주소 0은 가상 주소(Virtual Address) 이다!**

📌 가상 메모리의 주요 목표

• ** 투명성(Transparency) ** - 운영체제는 실행 중인 프로그램이 가상 메모리의 존재를 인지하지 못하도록 가상 메모리 시스템을 구현해야 한다!

• ** 효율성(Efficiency) ** - 운영체제는 가상화가 시간과 공간 측면에서 효율적이도록 해야 한다! - 시간적 : 프로그램이 너무 느리게 실행되서는 안 된다. - 공가적 : 가상화를 지원하기 위한 구조를 위해 너무 많은 메모리를 사용해서는 안 된다. - 운영체제는 TLB 등의 하드웨어 기능을 포함해 하드웨어의 지원을 받아야 함! - [ TLB ] 참고

• ** 보호(Protection) ** - 운영체제는 프로세스를 다른 프로세스로부터 보호해야 하고 운영체제 자신도 프로세스로부터 보호 해야 한다! - 보호 성질을 이용해 프로세스들을 서로 고립 시킬 수 있다.

  ** [ 고립의 원칙 ] **

  • 고립은 신뢰할 수 있는 시스템을 구축하는 데 중요한 원칙!
  • 두 개체가 서로 적절하게 고립된 경우, 한 개체가 실패하더라도 상대 개체에 아무 영향을 주지 않는다는 것을 암시!
  • 운영체제는 프로세스를 서로 고립시키기 위해 노력하고 이런 방식으로 한 프로세스가 다른 프로세스에게 피해를 주는 것을 방지!
  • 메모리 고립을 사용해 운영체제는 프로그램이 운영체제 동작에 영향을 줄 수 없다는 것을 보장!

** [ OSTEP ] 정리 모음집 " OS공부를 위한, 램지 H. 아파시 뒤소의 OSTEP 을 읽고 내용 요약 / 정리 "**

💡 핵심

" 프로세스는 간단히 말하면 실행 중인 프로그램! " 프로세스 구현에 필요한 기법, 구현한 프로세스를 스케줄링하는 정책 등을 알아보고, 여러 방법들을 조합하여 운영체제가 CPU를 가상화하는 방식을 이해하자.

💡 프로세스의 개념

📌 프로그램

• ** 실행을 위한 명령어와정적 데이터의 묶음 ** - 이 명령어와 데이터 묶음을 읽고 실행하여 프로그램에 생명을 불어넣는 것이 운영체제

• ** 디스크 상에 존재 **

  
  

📌 프로세스

• ** 운영체제가 제공하는 실행 중인 프로그램**
  

📌 CPU의 가상화

• ** CPU는 가상화를 통해 CPU가 여러개 있는 듯한 동작을 제공한다** - 음악 플레이어를 실행해 노래를 들으며 웹 서핑을 즐기는 등... - 실제로 CPU는 한 프로세스만 실행시키지만, 실행 중인 프로세스를 중단시키고 다른 프로세스를 실행하는 작업을 반복하면서 CPU가 여러 개 존재하는 듯한 동작을 한다 - 해당 기법을 시분할(Time Sharing) 이라고 한다.

📢 ** 현대 모든 운영체제들은 시분할 기법 중 문맥 교환(Context Switch)을 사용 한다! **

📌 스케줄링 정책

📢 ** CPU의 가상화를 통해 여러 프로그램을 실행할 수 있게되었는데... 많은 프로그램 중 어떤 프로그램을 먼저 실행되고, 다음에는 어떤 프로그램을 실행되는거지..?**

• ** 운영체제 중 스케줄링 정책(Scheduling Policy)에 의해 결정 ** - 과거정보, 워크로드에 관한 지식, 성능 측정 결과 등을 토대로 결정된다 - 정책(Policy) : 운영체제의 지능, 운영체제 내에서 어떤 결정을 내리기 위한 알고리즘

• ** 과거 정보** - 예) 직전 1분 동안 어떤 프로그램이 자주 실행 되었는지

• ** 워크로드에 관한 지식 ** - 예) 어떤 유형의 프로그램들이 실행되었는지

• ** 성능 측정 결과 ** - 예) 시스템이 대화 성능 혹은 처리량을 높이려 하는지

  
  

📌 하드웨어 상태

• ** 프로그램이 실행되는 동안 하드웨어 상태를 읽거나 갱신할 수 있다 **

[ 하드웨어 상태(Machine State) 구성 요소 ]

• ** 메모리 ** - 명령어, 실행 프로그램이 읽고 쓰는 데이터가 저장되는 영역 - 프로세스가 접근할 수 있는 메모리는 프로세스를 구성하는 요소

• ** 레지스터 ** - 많은 명령어가 레지스터를 직접 읽거나 갱신 함 - 프로세스를 실행하는 데 레지스터도 사용

  ** [ 하드웨어 상태를 구성하는 특별한 레지스터 ] **

  • *프로그램 카운터(Program Counter, PC) * - 프로그램의 어느 명령어가 실행 중인지 알려주는 레지스터

  • ** 스택 포인터(Stack Pointer) & 프레임 포인터(Frame Pointer) ** - 함수의 변수와 리턴 주소를 저장하는 스택을 관리할 때 사용하는 레지스터

• ** 영구 저장장치(Persistent stroage) ** - 프로세스가 현재 열어 놓은 파일 목록을 가진 입/출력 정보

💡 프로세스 API

📌 운영체제가 반드시 제공해야 하는 기본 기능의 API

• ** 생성(Create) ** - 새로운 프로세스를 생성할 수 있는 방법 - ex) 쉘에 명령어 입력, 프로그램 아이콘을 더블 클릭하여 프로그램 실행 등

• ** 제거(Destroy) ** - 프로세스를 강제로 제거할 수 있는 방법 - 대부분의 프로세스는 실행되고 할 일을 다하면 스스로 종료하지만, 그러지 못한 프로세스는 사용자가 제거하길 원할 것, 필요없는 프로세스를 중단시키는 API는 매우 유용함

• ** 대기(Wait) ** - 어떤 프로세스의 실행 중지를 기다릴 필요가 있기 때문

• ** 각종 제어(Miscellaneous Control) ** - 프로세스 제거, 대기 외 여러가지 기능들 - ex) 프로세스 일시정지 / 재개 등

• ** 상태(Status) ** - 프로세스가 얼마 동안 실행되었는지, 어떤 상태에 있는지 등이 포함된 프로세스 상태 정보를 얻는 기능

💡 프로세스 생성 과정

• ** 운영체제가 프로그램 코드와 정적 데이터를 프로세스의 주소 공간에 탑재 ** - 초기 운영체제들은 코드와 데이터를 모두 메모리에 탑재했지만 현대 운영체제는 코드나 데이터를 필요할 때 필요한 부분만 메모리에 탑재한다 - [ 가상 메모리 / 페이징, 스와핑 기법 ] 참조

• ** 운영체제가 프로그램의 실행시간 스택 용도로 일정량의 메모리 할당 ** - 지역 변수, 함수 인자, 리턴 주소 등을 저장하기 위한 스택 영역

• ** 운영체제가 프로그램의 힙을 위한 메모리 영역 할당 ** - 동적 할당 데이터를 위한 힙 영역

• ** 운영체제가 입출력과 관계된 초기화 작업 수행 **

• ** 운영체제가 CPU를 새로 생성된 프로세스에게 넘기게 되면 프로그램이 실행된다! **

💡 프로세스 상태

• ** 프로세스 상태의 개념은 초기 컴퓨터 시스템에서 등장 **
• ** 프로레스 상태를 단순화 하면 실행, 준비, 대기 상태 중 하나로 존재함 **
• ** 프로세스는 운영체제의 스케줄링 정책에 따라 각 상태로 전이함 **

📌 실행(Running)

• ** 명령어를 실행중인 프로세스 **
  

📌 준비(Ready)

• ** 명령어를 실행할 준비가 되어 있지만 운영체제가 다른 프로세스를 실행하고 있는 등의 이유로 대기 중인 프로세스 **
  

📌 대기(Blocked)

• ** 프로세스가 다른 명령을 기다리는 동안 프로세스의 수행을 중단시키는 연산 ** - ex) 프로세스가 디스크에 대한 입출력 요청 시 프로세스는 입출력이 완료될 때까지 대기 상태로 변하고 다른 프로세스가 실행 상태가 될 수 있음

💡 운영체제의 자료 구조

• ** 운영체제도 일종의 프로그램으로 다른 프로그램들과 같이 다양한 정보를 유지하기 위한 자료 구조를 가지고 있다 **

• ** 프로세스 리스트 ** - 운영체제가 가진 자료 구조 중 하나 - 프로세스 상태를 파악하기 위해 준비 상태의 프로세스들을 위한 자료 구조

• ** 운영체제가 프로세스를 추적하기 위해 필요로 하는 정보들 ** - [ 참고 사진 / xv6 Proc 구조 ] : 대부분의 운영체제들도 이와 비슷한 프로세스 구조를 갖고 있음

OSTEP 정리 모음 OSTEP 직접 읽고 챕터별로 정리한 내용입니다. 잘못되거나 이상한 내용이 있으면 제보 부탁드려요!😁

Chapter 1 - CPU

📌 프로세스의 개념

Chapter 2 - Virtual Memory

📌 주소 공간의 개념

• ** 지정 초기화 **

• ** Aggregate Initialization을 사용하기 위해 붙는 조건들을 맞춰줄 필요 없이 사용 가능 하다 **

• [ Aggregate Initialization을 사용하기 위한 조건 ]* - 사용자 정의 생성자가 없어야 함 - 가상 함수가 없어야 함 - private, protected, static 데이터 변수는 사용 불가

• 📢 그렇다고 사용할 때 조건이 없는 것은 아니다!*

💡 Designated Initialization 사용 방법!

📌 Aggregate Initialization

class Pos3D
{
public:
    int iX;
    int iY;
    int iZ;

    ...
}

Pos3D pos{1, 2, 3};

• ** 특정 데이터 변수만 초기화를 해줄 수 없기 때문에, 만약 Pos3D의 데이터 변수들이 많다면 그 만큼 초기화 해줘야하는 번거로움이 생긴다. ** - Pos3D pos{1, 2, 3, 4, 5, 6, 7, 8, ... 999}

• ** 축소 변환이 일어난다. ** - Pos3D pos{1, 2, 3.f}

📌 Designated Initialization

class Pos3D
{
public:
    int iX;
    int iY;
    int iZ;

    ...
}

Pos3D pos{.x = 1, .y = 2, .z = 3};

• ** 특정 데이터 변수만 초기화를 해줄 수 있다! ** - Pos3D pos{.x = 1, .z = 3};

• ** 축소 변환이 일어날 경우 컴파일러 에러가 발생해 실수를 방지할 수 있다! ** - Pos3D pos{1, 2, 3.f}

• ** 하지만 데이터 변수 선언 순서에 맞게 초기화를 해줘야 한다! ** - Pos3D pos{.z = 3, .x = 1} 불가능!

• ** 3방향 비교 연산자 ** - < , <= , > , >= , == , != 를 한번에 판단 가능 - 생긴 모양이 우주선과 닮아서 우주선 연산자, spaceship operator 라고도 불린다

• ** 주어진 표현식의 결과가 같은지, 보다 작은지, 큰지 세 가지 결과 중 하나를 반환해야 하기에 bool로 표현이 불가능 하다** - 정수 타입 : strong_ordering - 실수 타입 : partial_ordering - 사용자 정의 타입 : weak_ordering

• ** 기본 타입 보다는 사용자 정의 타입에서 효과를 볼 수 있다 ** - 무거운 기존 비교 연산자를 두번 호출할 필요 없이 3방향 비교 연산자를 통해 한번 호출로 결과를 낼 수 있기 때문

📌 strong_ordering

• strong_ordering::less : 첫 번째 피연산자가 두 번째 피연산자보다 작다.

• strong_ordering::greater : 첫 번째 피연산자가 두 번째 피연산자보다 크다.

• strong_ordering::equal : 두 피연산자가 같다.

📌 partial_ordering

• strong_ordering::less : 첫 번째 피연산자가 두 번째 피연산자보다 작다.

• strong_ordering::greater : 첫 번째 피연산자가 두 번째 피연산자보다 크다.

📌 weak_ordering

• strong_ordering::less : 첫 번째 피연산자가 두 번째 피연산자보다 작다.

• strong_ordering::greater : 첫 번째 피연산자가 두 번째 피연산자보다 크다.

• strong_ordering::equivalent : 두 피연산자가 같다.

• ** C#의 Coroutine **

• ** Module과 같이 양대산맥 처럼 중요하게 사용할 문법 ** - 문법이 복잡해 당장 사용하지는 못하겠지만 누군가가 작성한 코드를 읽을 수 있을정도로는 공부하자!

• ** 어떤 함수를 호출 중에 원할 때 빠져나간 후 원할 때 핸들을 통해 다시 재개할지, 중단할지 결정하는 문법** - 쉽게 말해 함수를 호출할 때 어디까지 호출했는지 저장 및 일시정지, 나중에 이어서 다시 호출 하게 해주는 기능

💡 함수가 Coroutine이 되려면...

📌 co_return

📌 co_yield

📌 co_await

📌 사용 예시

• ** 함수의 return 문처럼 co_return, co_yield, co_await 사용 **

• ** C#의 LINQ와 문법과 유사 **

• ** Concept, Module, Coroutine에 비해 중요도가 떨어지는 문법 ** - 하지만 기능은 유용하게 사용 가능

💡 Range를 사용하는 이유?

📌 보다 가독성 좋게 코드를 작성할 수 있다.

• ** vector 컨테이너의 짝수를 추출한 후 그 값들에 2를 곱해주는 기능을 만들 때 **

  vector<int> v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  

vector v2;

// 짝수 추출 for(int n : v1) if(n % 2 == 0) v2.emplace_back(n); // 추출 값에 2를 곱해줌
for(int& n : v2) n = n * 2;

// 위와 같은 코드를 아래처럼 바꿔줄 수 있다.

auto results = v1 | std::view::filter([](int n) { return n % 2 == 0; }) | std::view::transform([](int n) { return n * 2; });

<br>

---

## 💡 Range 사용 방법!

### 📌 Range와 View
- ** ```Range``` : 순회할 수 있는 아이템 그룹**
\- STL 컨테이너 등

- ** ```View``` : ```Range```에 대해서 적용할 수 있는 연산 **

### 📌 Range와 View 주요 기능들
- ** ```std::views::all``` **
\- 모든 요소 추출

- ** ```std::ranges::filter_view``` / ```std::views::filter``` **
\- 조건을 만족하는 요소 추출

- ** ```std::ranges::transform_view``` / ```std::views::transform``` **
\- 각 요소를 변환

- ** ```std::ranges::take_view``` / ```std::views::take``` **
\- n개 요소를 추출

- ** ```std::ranges::take_while_view``` / ```std::views::take_while``` **
\- 조건을 만족할 때까지 요소 추출

- ** ```std::ranges::drop_view``` / ```std::views::drop``` **
\- n개 요소를 스킵

- ** ```std::ranges::drop_while_view``` / ```std::views::drop_while``` **
\- 조건을 만족할 때까지 요소 스킵

- ** ```std::ranges::join_view``` / ```std::views::join``` **
\- view를 병합

- ** ```std::ranges::split_view``` / ```std::views::split``` **
\- 요소를 나눔

- ** ```std::ranges::reverse_view``` / ```std::views::reverse``` **
\- 역순서로 순회

- ** ```std::ranges::elements_view``` / ```std::views::elements``` **
\- 튜플의 n번째 요소를 대상으로 view 생성

- ** ```std::ranges::keys_view``` / ```std::views::keys``` **
\- pair-like value의 첫번째 요소를 대상으로 view 생성

- ** ```std::ranges::values_view``` / ```std::views::values``` **
\- pair-like value의 두번째 요소를 대상으로 view 생성

---

## 💡 Range 사용 예시!

### 📌 sort 활용
- ** ```std::ranges::sort(정렬 범위, 정렬 조건, 정렬 대상);``` **

// 기존 sort 방법 std::sort(v1.begin(), v1.end());

// 위처럼 작성한 코드를 아래처럼 변경 가능 struct Monster { string name; int id; };

vector Monsters = { { "Golem", 1 }, { "Wolf", 2 }, { "Zombie", 3 }, { "Skeleton", 4 }, };

std::ranges::sort(Monsters, {}, &Monster::Name); // Monsters 컨테이너 대상, 기본 정렬 조건(오름 차순), 이름 으로 정렬

std::ranges::sort(Monsters, greater(), &Monster::Name); // Monsters 컨테이너 대상, 내림 차순, 이름 으로 정렬

std::ranges::sort(Monsters, {}, &Monster::id); // Monsters 컨테이너 대상, 기본 정렬 조건(오름 차순), id값 으로 정렬

std::ranges::sort(Monsters, greater(), &Monster::id); // Monsters 컨테이너 대상, 내림 차순, id값 으로 정렬

<br>

### 📌 조건에 따른 요소 추출
- ** 0~100사이 숫자 중에 앞에서부터 5개의 소수 추출 **

- ```std::views::iota(a, b)``` : a부터 시작해서 1씩 증가, b개를 만들어 줌

auto isPrime = [] (int num) { if (num <= 1) return false;

for (int n = 2; n*n <= num; n++)
    if (num % n == 0)
        return false;

return true;

};

std::vector vecNum; for (int n : std::views::iota(0, 100) | std::vies::filter(isPrime) | std::views::take(5)) { vecNum.emplace_back(n); }

```

📌 커스텀 view (std::ranges::view_interface)

• ** 원하는 조건을 커스텀해서 만들 수 있다 ** - 사용할 일이 잘 없을 것, 알고만 있어도 무방

• ** C++20의 모든 기능 중 가장 중요한 기능이라고 할 수 있다. ** - 지금 당장 많이 쓰인다기보다는 서버 프로그래밍에서는 빠르게 적용되어가고 있기 때문에 몇년 후 많이 쓰일 것

💡 Module을 사용하는 이유?

📌 C++의 빌드속도가 오래걸리는 단점을 보완하기 위해서!

• ** C++은 다른 언어에 비해 실행속도가 빠르지만 그 만큼 빌드속도가 오래걸리는 단점이 있음 ** - 불필요하게 반복되는 빌드

  [ Test1.h ]
  #include <iostream>
  

[ Test2.h ] #include

[ Test3.h ] #include

// 위와 같이 iostream을 반복해 참조하면 컴파일 단계에서 .obj 파일의 용량이 증가한다.

### 📌 매크로( #define ) 사용을 줄이기 위해!

[ Test1.h ] #define NUM 1

[ Test2.h ] #define NUM 2

[ main.cpp ] const int iNum = NUM;

// 위와 같이 매크로 NUM을 사용하면 사용자 입장에서 1인지, 2인지 헷갈리게 된다. // 해당 경우 참조 순서에따라 NUM이 바뀐다.

### 📌 심볼 중복 정의를 줄이기 위해!

[ Test1.h ] void TestFunc() { ... }

[ main.cpp ] #include "Test1.h"

// 여러번 정의된 기호 링크 에러 발생!

\- ```Test1.h```를 ```obj```파일로 만들고, ```main.cpp```도 ```obj```파일로 만들게 되는데 이때 ```TestFunc()```가중복되기 때문

### 📌 Module 사용시 위 문제들 해결 가능!
- ** Module은 딱 한번 ```import``` 된다! **

- ** ```import``` 순서에 상관 없다! **

- ** ```import``` 순서에 상관 없다! **

- ** Module 이름 지정 가능! **

- ** 인터페이스 / 구현부 분리 관리 필요성 사라짐! **

<br>

---


## 💡 Module 사용 예시!

### 📌 Module 생성 방법
- ** 프로젝트 - 모듈 추가 ```클릭``` **
![](https://velog.velcdn.com/images/minsu_lighting--/post/2c67f115-4c4b-4aa9-a1df-6b9eaff6fe68/image.png)

- ** C++ 모듈 인터페이스 단위(.ixx) ```클릭``` **
![](https://velog.velcdn.com/images/minsu_lighting--/post/749b5bb7-7461-40c8-b245-8a729e21c01e/image.png)

- ** 생성 후 기본 세팅 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/2126422e-887f-4fb4-b0f1-2eef25c629fa/image.png)


### 📌 1. 함수 앞에 export 키워드 사용
- ** 가장 기본적인 사용 예시 **


- ** 기능 선언 / 정의 후 ```export``` **
![](https://velog.velcdn.com/images/minsu_lighting--/post/4129006b-d07e-4475-a466-7a1fc16be3d0/image.png)


- ** ```import```후 사용 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/1fbd0817-6613-4732-80fe-aaa4278a4830/image.png)

<br>

### 📌 2. export 영역 지정 사용
- ** ```export```할 함수들을 ```{}```로 묶어주어 관리 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/91662bfd-793c-4029-b6cb-61a2621ffed4/image.png)


- ** ```import```후 사용 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/d7853566-51a7-4335-90d0-50f4a6bfdb9d/image.png)

<br>

### 📌 3. export namespace 지정 사용
- ** 가장 권장하는 방법 **


- ** ```export```할 함수들을 ```namespace```로 묶어주어 관리 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/7953f7e1-a45e-4e86-bc61-61611e7210cd/image.png)



- ** ```namespace::``` 후 사용 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/912e6cac-7e5c-48c5-884f-47f414f3f2cc/image.png)

<br>

### 📢 Module 내부에서만 사용할 함수라면?
- ** ```export``` 키워드를 미사용 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/f694853b-ed60-4b31-9030-a987dd46d384/image.png)

<br>

---

## 💡 Module에서 사용할 외부 라이브러리 등을 사용할 때?



### 📌 sub module 문법
- ** 주로 쓰일 문법 **

- ** sub module만 독립적으로 사용 가능 **

- ** 일종의 약속 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/fdf18841-8830-4131-9e01-c2c59021fec6/image.png)
\- module 파일의 위쪽에 위 처럼 작성해준다.


- ** ```Math.Time``` 처럼 Math의 하위 개념의 기능들을 또 다른 ```module```로 엮어 관리할 수 있다. **
\- 시간과 관련된 기능들을 묶어놓은 Time ```module``` 은 module 이름을 ```Math.Time```으로 지정해 마치 접근 연산자를 사용한 것과 같은 효과를 주어 사용 한다.

- ** ```Math.Time``` 앞 ```import```**
\- Math.Time을 해당 module 에서만 사용 하겠다

- ** ```Math.Time``` 앞 ```export import```**
\- Math.Time을 해당 module 에서도 사용 하고 Math만 ```import``` 해도 사용 가능 

<br>

### 📌 partition 문법
- ** module 본체 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/849e9566-1a7a-44b2-a2ac-4f2c59356fc0/image.png)


- ** partition module **
![](https://velog.velcdn.com/images/minsu_lighting--/post/2f7dbf4c-62e1-4853-9f24-f7c8ca910dd4/image.png)


- ** ```import```후 사용 **
![](https://velog.velcdn.com/images/minsu_lighting--/post/b9562522-84dd-423e-8922-c65e11dd8df1/image.png)


-  ** sub module과 다르게 각 partition들은 독립적으로 사용 불가능! **
![](https://velog.velcdn.com/images/minsu_lighting--/post/6241aab8-8f99-455f-af8a-0c639c900cd8/image.png)

• ** C#에서는 클래스 / 함수에 where절을 사용해 제네릭 타입에 대해 조건을 부여해 줄수 있다. **

  class GameObject
  {
    public int iObjectID;
  }
  

class Player : GameObject {

}

class Monster : GameObject {

}

void SetObjectID(T obj) { // 여러 자료형을 매개변수로 받기 위해 // 제네릭 타입으로 만들었지만 이렇게 만들 경우 // iObjectID를 변수로 갖고있지 않는 타입의 경우 오류가 발생한다.

int iObjectID = obj.iObjectID;
...
...

}

void SetObjectID(T obj) where T : GameObject { // where절을 이용해 GameObject를 상속받는 타입으로만 조건을 부여해주면 해결.

int iObjectID = obj.iObjectID;
...
...

}

📢 ** 위 C# 문법과 같이 C++에서도 어떤 타입이 가져야하는 조건을 정의해 주기 위해 나온 것이 Concept라고 할 수 있다! **
\- 사용 방법은 여러가지가 있다.
\- 정해준 제약 조건들은 컴파일 타임에 결정되어진다.

<br>

---


## 💡 Concept 사용 예시!

- ** 매개변수로 들어오는 값을 정수만 받고 싶은 상황 **

### 📌 **1. Requires Clause**
![](https://velog.velcdn.com/images/minsu_lighting--/post/fcf22e6e-cb2b-43db-bf01-7bad9689ee4c/image.png)

- ** requires 절 사용**
\- ```std::integral``` : 정수 타입
\- ```std::floating point``` : 실수 타입

### 📌 **2. Trailing Requires Clause**
![](https://velog.velcdn.com/images/minsu_lighting--/post/0ca97b12-0fa7-49e7-981d-81c69837be61/image.png)

- ** 1번과 마찬가지로 requires 절을 사용했지만 함수의 뒤에 붙인다.**
\- Trailing : 뒤에 붙는~


### 📌 **3. Constrained Template Parameter**
![](https://velog.velcdn.com/images/minsu_lighting--/post/06884a33-7065-4826-9bde-4154f5b2fcf3/image.png)

- ** 타입을 강제한다. **
\- ```template<std::integral T>``` T에 대해 타입을 integral로 강제
\- Constrained : 강제하는


### 📌 **4. Abbreviated Function Template**
![](https://velog.velcdn.com/images/minsu_lighting--/post/a6635b56-d1e8-4467-b21a-c969c14ff622/image.png)

- **auto 키워드를 사용해 정수 타입인 타입만을 추론해 사용.**

** [ Effective C++ ] 정리 모음집 " C++ 프로그래머의 필독서, 스콧 마이어스의 Effective C++ 를 읽고 내용 요약 / 정리 "**

[핵심]

" 현장에 당장 투입할 수 있을 정도로 품질도 우수하고, 실탄 무담도 적은 동시에 속알맹이도 들여다볼 수 있게 오픈 소스이고, 게다가 어지간한 플랫폼과 컴파일러에서 모두 돌아가는 C++ 라이브러리! 부스트! "

• 부스트는 동료 심사를 거쳐 등록되고 무료로 배포되는 오픈 소스 C++ 라이브러리를 개발하는 모임이자 웹사이트이다. 또한 C++ 표준화에 있어서 영향력 있는 역할을 맡고 있다!
• 부스트에서 배포되는 라이브러리들 중엔 TR1 구성요소에 들어간 것도 있지만 그 외에 다른 라이브러리들도 아주 많다!

💡 부스트의 범주

📌 문자열 및 텍스트 처리

-** 주요 구성요소로 타입 안전성을 갖춘 printf 비슷한 서식화 기능, 정규 표현식 및 토큰화와 구문분석 기능이 있다 **

📌 컨테이너

-** STL 양식의 인터페이스를 제공하는 고정 크기 배열, 가변 크기 비트세트, 다차원 배열 등이 포함 **

📌 함수 객체 및 고차 프로그래밍

-** TR1의 기능을 구현하는 데 사용된 몇 개의 기반 라이브러리가 여기에 포함 ** - 그 중 특히 람다 라이브러리는 별도의 준비 없이 즉석에서 함수 객체를 생성해 주는 기막힌 기능을 제공한다

📌 일반화 프로그래밍

-** 특성정보 클래스 ** - ** [ 항목 47 : 타입에 대한 정보가 필요하다면 특성정보 클래스를 사용하자 ] ** 참조

📌 템플릿 메타프로그래밍

-** 컴파일 타임 단정문, 부스트 MPL 라이브러리 등이 여기에 포함 ** - MPL은 타입 등의 컴파일 타임 개체를 STL스러운 자료구조로 관리할 수 있도록 지원해준다.

-** [ 항목 48 : 템플릿 메타프로그래밍, 하지 않겠는가? ] 참조 **

📌 수학 및 수치 조작

-** 유리수, 4원수 및 8원수, 최대 공약수 및 최소 공배수, 난수 등이 포함된다 **

📌 정확성 유지 및 테스트

-** 암시적 템플릿 인터페이스를 형식화해 주는 라이브러리와 테스트 우선 프로그래밍을 가능하게 해 주는 라이브러리가 있다 **

📌 자료구조

-** 타입 안전성을 갖춘 공용체, 그리고 TR1에서 지원하는 것의 뿌리격인 바로 그 투플 라이브러리가 이 범주에 들어간다 **

📌 타 언어와의 연동 지원

-** C++와 파이썬 사이의 걸림돌 없는 상호운용을 가능하게 하는 라이브러리 지원**

📌 메모리

-** 고성능의 고정 크기 할당자를 지원하는 풀 라이브러리, 스마트 포인터가 이 범주에 들어간다 **

📌 기타

-** CRC 점검, 날짜 및 시간 조작, 파일 시스템 횡단 등을 지원하는 라이브러리 **

** [ Effective C++ ] 정리 모음집 " C++ 프로그래머의 필독서, 스콧 마이어스의 Effective C++ 를 읽고 내용 요약 / 정리 "**

[핵심]

" 제목이 곧 핵심! "

• 최초에 상정된 표준 C++ 라이브러리의 주요 구성요소는 STL, iostream, 로케일 등이며, 여기에는 C89의 표준 라이브러리도 포함되어 있다!
• TR1이 도입되면서 추가된 것은 스마트 포인터, 일반화 함수 포인터, 해시 기반 컨테이너, 정규 표현식 그리고 그 외의 10개 구성요소이다!
• TR1 자체는 단순히 명세서일 뿐, TR1의 기능을 사용하기 위해서는 명세를 구현한 코드를 구해야 한다. TR1 구현을 구할 수 있는 자료처 중 한 군데가 바로 부스트이다!

💡 C++ 라이브러리의 주요 구성요소

📌 표준 템플릿 라이브러리(Standard Template Library : STL)

-** 컨테이너(vector, string, map 등), 반복자, 알고리즘(find, sort 등), 함수 객체(less, greater 등) 외에 컨테이너 어댑터와 함수 객체 어댑터가 있다 **

📌 iostream

-** 사용자 정의 버퍼링, 국제화 기능이 가능한 입출력 지원 **

-** cin, cout, cerr, clog 등의 사전정의 객체를 지원 **

📌 국제화 지원

-** 여러 로케일을 활성화시킬 수 있는 기능 포함 **

-** wchar_t 등의 타입 및 wstring을 쓰면 유니코드를 사용할 수 있다 **

📌 수치 처리 지원

-** 복소수를 나타내는 템플릿(complex) 및 수치 배열을 나타내는 템플릿(valarray)이 여기에 해당된다 **

📌 예외 클래스 계통

-** 최상위 클래스인 exception 및 이것으로부터 갈라져 나온 파생 클래스들이 포함된다 **

📌 C89의 표준 라이브러리

-** 1989년 버전의 C에 포함된 표준 라이브러리는 전부 C++에도 들어 있다 **

💡 TR1의 구성요소

📌 스마트 포인터

-** shared_ptr, weak_ptr 이 여기에 해당 ** - 동작은 기본제공 포인터와 똑같으나, 하나의 실제 객체를 가리키는 자신과 같은 포인터의 개수를 유지해 놓는(참조 카운팅)방식을 지원하는 포인터

-** TR1 에서 가장 폭넓게 쓰인다 **

📌 tr1::function

-** 어떤 함수가 가진 시그니처와 호환되는 시그니처를 갖는 함수호출성 객체의 표현을 가능하게 해 주는 템플릿 **

📌 tr1::bind

-** 현역 STL 바인더로 잘 쓰이고 있는 bind1st 및 bind2nd와 똑같이 동작함은 물론, 그보다 훨씬 더 많은 기능이 있는 범용 바인더 **

📌 해시 테이블

-** 세트, 멀티세트, 맵, 멀티맵을 구현하는 데 이 해시 테이블이 쓰였다 **

📌 정규 표현식

-** 정규 표현식 기반의 탐색과 문자열에 대한 대체 연산이 가능하며, 일치되는 원소들 사이의 순회도 지원한다 **

📌 투플

-** 종래의 표준 라이브러리에 원래 있었던 pair 템플릿의 신세대 버전, pair 객체의 경우에는 두 개만 담을 수 있는 반면, 투플 객체는 몇 개라도 담을 수 있다 **

📌 tr1::array

-** begin 및 end 등의 멤버 함수를 지원하는 배열, 객체의 크기가 컴파일 과정에서 고정되어 동적 메모리를 쓰지 않는다 **

📌 tr1::mem_fn

-** 멤버 함수 포인터를 적응시키는 용도에 쓸 수 있는 템플릿 **

📌 tr1::reference_wrapper

-** 기존의 참조자가 객체처럼 행세할 수 있도록 만들어 주는 템플릿 ** - 참조자를 담은 것 처럼 동작하는 컨테이너를 만들 수 있다

📌 난수 발생

-** rand 함수보다 몇 배는 우수한 난수 발생 기능 **

📌 특수 용도의 수학 함수

-** 라게르 다항식, 베셀 함수, 완전 타원 적분 등 **

📌 C99 호환성 확장 기능

-** C99의 새로운 라이브러리를 C++로 가져올 목적으로 설계된 함수 및 템플릿 모음 **

📌 타입 특성정보

-** 주어진 타입에 대한 컴파일 타임 정보를 제공하는 특성정보 클래스 ** - ** [ 항목 47 : 타입에 대한 정보가 필요하다면 특성정보 클래스를 사용하자 ] ** 참조

📌 tr1::result_of

-** 어떤 함수 호출의 반환 타입을 추론해 주는 템플릿 **

** [ Effective C++ ] 정리 모음집 " C++ 프로그래머의 필독서, 스콧 마이어스의 Effective C++ 를 읽고 내용 요약 / 정리 "**

[핵심]

" 어떤 경고 메시지를 없애기 전에, 그 경고가 여러분에게 알리려는 바를 정확히 이해하자! "

• 컴파일러 경고를 쉽게 지나치지 말자! 컴파일러에서 지원하는 최고 경고 수준에도 경고 메시지를 내지 않고 컴파일되는 코드를 만드는 쪽에 전력을 다 하자!
• 컴파일러 경고에 너무 기대는 인생을 지양하자. 컴파이러마다 트집을 잡고 경고를 내는 부분이 천차만별이기 때문에 지금 코드를 다른 컴파일러로 이식하면 익숙해져 있는 경고 메시지가 온 데 간 데 없이 사라질 수도 있다!

💡 예시

class B
{
public :
    virtual void f() const;
};

class D : public B
{
public :
    virtual void f();
};

-** warning D::f() hides virtual B::f() ** - B::f는 상수(const) 멤버 함수지만 D::f는 const가 붙어있지 않아 그냥 함수 자체가 가려진 거지만, 제대로 확인하지 못하면 컴파일러가 왜 이러나... 싶은 사람들도 있을 것! - 해당 경고를 다른 컴파일러에서는 알려주지 않을 가능성도 있다

📢 ** 본인이 저지른 실수를 컴파일러가 대신 잡아주는 것만 믿고 아무 생각 없이 프로그래밍에 임하는 자세는 정말 좋지 않다! **

** [ Effective C++ ] 정리 모음집 " C++ 프로그래머의 필독서, 스콧 마이어스의 Effective C++ 를 읽고 내용 요약 / 정리 "**

[핵심]

" new와 delete는 언제나 짝을 이루어야 한다! "

• operator new 함수의 위치지정 버전을 만들 때는 이 함수와 짝을 이루는 위치지정 버전의 operator delete 함수도 꼭 만들자. 이 일을 빼먹었다간 찾아내기도 힘들며 또 생겼다가 안 생겼다 하는 메모리 누출 현상을 경험하고 된다!
• new 및 delete의 위치지정 버전을 선언할 때는 의도한 바도 아닌데 이들의 표준 버전이 가려지는 일이 생기지 않도록 주의 하자!

💡 위치지정 new, delete

• ** operator new, operator delete 의 기본형과 달리 매개변수를 추가로 받는 형태의 함수를 위치지정 new, delete라고 한다 ** - 매개변수를 받는 new, delete는 가지각색일 수 있지만 그 중 특히 유용한 버전이 있는데, 어떤 객체의 메모리 위치를 나타내는 포인터를 매개변수로 받는 버전 이다.

📌 어떤 객체의 메모리 위치를 나타내는 포인터를 매개변수로 받는 operator new, operator delete

void* operator new(size_t, void* pMemory) throw(); void* operator delete(void*, ostream&) throw(); -** 위치지정 new를 사용해 메모리를 할당했으나 그 후 예외가 발생해 delete를 호출해야 할 때 컴파일러는 사용한 new와 같은 버전의 delete를 찾는다!** - 그렇기에 new와 delete는 짝을 지어야 한다.

📢 ** 만약 예외가 발생하지 않고 포인터에 delete를 적용했을 때는 절대로 위치지정 delete를 호출하지 않는다 **

Widget* pw = new (std::cerr) Widget;        // 해당 코드에서 예외 발생 시
                                            // 위치지정 delete 호출

delete pw;                                    // 해당 코드까지 닿으면
                                            // 기본 delete 호출

- 따라서 어떤 위치지정 new 함수와 조금이라도 연관된 모든 메모리 누출을 사전에 봉쇄하려면, 표준 형태의 delete를 기본으로 마련해 두고, 위치지정 new와 매개변수가 같은 delete도 구비해야 한다!

📌 위치지정 new, delete를 구현할 때 주의할 점

-** 표준형태의 new, delte가 가려지지 않게 주의하자! **

[ C++가 전역 유효 범위에 제공하는 operator new의 형태 ]

• * 기본 형태 new ** - ```void operator new(size_t) throw(bad_alloc);```
• * 위치지정 new ** - ```void operator new(size_t, void*) throw();```
• * 예외불가 new ** - ```void operator new(size_t, const nothrow_t&) throw();```

- 위 3가지 버전의 표준 형태들이 가려지지 않게 주의하자!

📢 ** 클래스 전용 버전이 전역 버전을 호출하도록 구현하자! **

class StandardNewDeleteForms
{
public:
    // 기본형 new, delete
    static void* operator new(size_t size) throw(bad_alloc)
    { return ::operator new(size); }

    static void operator delete(void* pMemory) throw()
    { ::operator delete(pMemory); }

    // 위치지정 new, delete
    static void* operator new(size_t size, void* ptr) throw()
    { return ::operator new(size, ptr); }

    static void operator delete(void* pMemory, void* ptr) throw()
    { ::operator delete(pMemory, ptr); }

    // 예외불가 new, delete
    static void* operator new(size_t size, const nothrow_t& nt) throw()
    { return ::operator new(size, nt); }

    static void operator delete(void* pMemory, const nothrow_t&) throw()
    { ::operator delete(pMemory); }
};

- 사용자 정의 형태를 추가하고 싶다면, 이 기본 클래스를 상속받아 파생 클래스를 만들어 using 선언을 사용해 주자

class Widget : public StandardNewDeleteForms
{
public:
    // 표준 형태가 가려지지 않게
    using StandardNewDeleteForms::operator new;
    using StandardNewDeleteForms::operator delete;

    // 사용자 정의 위치지정 new, delete
    static void* operator new(size_t size, ostream& logStream) throw(bad_alloc);

    static void* operator delete(void* pMemory, ostream& logStream) throw();
    ...
};

** [ Effective C++ ] 정리 모음집 " C++ 프로그래머의 필독서, 스콧 마이어스의 Effective C++ 를 읽고 내용 요약 / 정리 "**

[핵심]

" 따르기 힘든 규칙은 없지만 일부는 이해하기에 살짝 까다로운게 있기 때문에 무엇인지에 대해 유념해 둘 필요가 있다! "

• 관례적으로 operator new 함수는 메모리 할당을 반복해서 시도하는 무한 루프를 가져야 하고, 메모리 할당 요구를 만족시킬 수 없을 때 new 처리자를 호출해야 하며, 0바이트에 대한 대책도 있어야 한다. 클래스 전용 버전은 자신이 할당하기로 예정된 크기보다 더큰(틀린) 메모리 블록에 대한 요구도 처리해야 한다!
• operator delete 함수는 널 포인터가 들어왔을 때 아무 일도 하지 않아야 한다, 클래스 전용 버전의 경우에는 예정 크기보다 더 큰 블록을 처리해야 한다!

💡 operator new 및 operator delete를 구현할 때

📌 operator new

-** 반환 값 ** - 요청된 메모리를 마련해 줄 수 있으면 그 메모리에 대한 포인터를 반환, 그 반대의 경우는 bad_alloc 타입의 예외를 던지게 하자

-** 가용 메모리가 부족할 경우 new 처리자 함수를 호출해야 한다! **

-** 크기가 없는(0바이트) 메모리 요청에 대한 대비책을 갖춰야 한다! **

📢 ** 기본 형태의 new가 가려지지 않도록 한다! **

📌 operator delete

-** C++ 널 포인터에 대한 delete 적용이 항상 안전하도록 보장한다는 사실만 잊지 않으면 된다! **

📢 ** 기본 클래스에서 가상 소멸자를 빼먹으면 operator delete 함수가 똑바로 동작하지 않을 수 있다! ** - 가상 소멸자가 없는 기본 클래스로부터 파생된 클래스의 객체를 삭제하려고 할 경우, operator delete로 C++가 넘기는 size_t 값이 엉터리일 수 있다!