상후니의 개발 블로그

*전체적인 C++ 컴파일 과정 1. 전처리 단계 => #include, #define .... 전처리기 매크로들을 처리. 2. 컴파일 단계 => 소스파일들을 어셈블리 명령어로 변환. 3. 어셈블 단계 => 실제 기계어로 이루어진 목적 코드 (.obj) 로 변환. 4. 링킹 단계 => 목적 코드 ( obj ) 들을 하나로 모아 실행 파일 생성. *전처리 단계 1. 문자 해석하기 translation character set 2. ' \ ' 문자 해석하기 #define Test(a, b) \ {\ if(a != b)\ {\ a = b;\ }\ }; 3. 전처리 토큰들로 분리 => 소스 파일을 주석, 공백문자, 전처리 토큰 으로 분리하는 단계. 4. 전처리 실행 단계 => #include 파일 내용 복사. =..

*스마트 포인터는 왜 필요할까?? => 포인터 사본을 만들지 않도록 하는 것이 좋다. => 객체 생명주기로 주소값을 가지고 있는 객체들을 먼저 처리하고 참조되어있는 객체를 마지막으로 처리하는 것이 좋다. => 항상 실수 가능성이 있다는 것이 문제. *댕글링포인터 ( Dangling Pointer ) => 이미 존재하지 않는 객체의 주소를 가지고 있는 포인터 => 객체가 삭제될 때 그 객체가 삭제되었다고 알려주어 해당 포인터를 nullptr 해야하는데 딱히 방법이 없다. 이런 상황을 해결하기 위해 스마트 포인터를 사용할 수 있다. *shared_ptr => 참조 카운트 ( ref count ) 사용. shared_ptr k1 = make_shared(); *왜 make_shared 를 사용해 shared_..

*람다 표현식 ( lambda expression ) [ 캡처 ] ( 매개변수 ) { 구현부 } => '리턴값 자동 추론' [ 캡처 ] ( 매개변수 ) -> 리턴값 { 구현부 } vector vec; auto findIt = std::find_if(vec.begin(), vec.end(), [ ](Item& item) { return item.Rarity == Rarity::Unique; }); *[ ] 캡처 ( capture ) => 함수 객체 내부에 변수를 저장하는 개념과 유사 * [&] : call-by-reference 와 유사 => 외부의 모든 변수들의 주소를 가져온다. int a = 4; auto Changed = [&]() { a = 5; }; => 참조를 사용할 땐 값이 바뀔 수 있음을 인..

*전달 참조 ( forwarding reference ) = 보편 참조 ( universal reference ) ( template, auto 와 연관 ) => std::forward 를 사용해야함. std::move : r-value 를 반환. (즉, class&& 로 캐스팅하는 용도 ) * 특수 템플릿 인자 유추 규칙 A&& // -> A& A&&& // -> A& A&&& // -> A& A&&&& // -> A&& template void foo(T&& A); A : 좌측값 ( l-value ) 라면, T&& + &A = T&&& = T&. A : 우측값 ( r-value ) 라면, T&& + &&A = T&&&& = T&&. * && 이 무조건 오른값 참조여야만 하나 ?? => 형식 연역 ( ..

*왼값 ( l-value ) => 단일식을 넘어서 계속 지속되는 개체 *오른값 ( r-value ) => lvalue 가 아닌 나머지 개체 ( 임시 값, 열거형, 람다, i++ 등.. ) 즉, 좌측값은 & 연산자를 통해 어떠한 메모리 위치를 가리킬 수 있다. 우측값은 그렇지 않은 값들이다. * 왼값 / 오른값 구별 int test = 20; test = 123 + test; test : 왼값. 123, 20 : 오른값. 123 + test : 오른값. int result = func(); func 의 리턴값 : 오른값. result : 왼값. *이전의 상황 ( 오른값 참조가 없었을 때 ) void TestKnight_Copy(Knight k) {} void TestKnight_LValueRef(Knigh..

*enum class ( scoped enum ) 1. 이름공간 관리 ( scoped ) 2. 암묵적인 변환 금지 *enum enum PlayerType : short { None PT_Knight = 5, PT_Archer, PT_Mage, }; enum MonsterType { None // => 재정의 에러 } double value = PT_Knight; => 전역으로 퍼짐. => 이름 재정의 문제 => 암묵적 변환 가능. *override virtual void Attack() override; virtual void Attack() const => OK => virtual 함수인지 알기 어렵다. => override 를 붙이면 기존 부모 virtual 함수를 제거했을 때, 컴파일러가 ERROR..

*Using typedef int id; using id = int; *무슨 차이점이 있을까?? 1. 선언 순서 차이 ( 직관성 ), 함수포인터 2. 템플릿과의 호환 template using List = std::list; 하지만, typedef 는 typedef std::list List ; => ( X ) ( 함수나 클래스 외부에서 선언할 수 없음. ) template struct ListT { typedef list type; }; ListT::type li; => typedef 는 간접적으로 struct 를 하나 더 만들어줘야함. 본 내용은 인프런의 루키스님 강의를 듣고 정리한 내용입니다. 강의 듣기 !!

*기존의 방식 0 NULL => #define 0 과 똑같다고 보면 됨. *왜 nullptr 이 필요했을까 ?? 1) 오동작 => 치명적일 수 있음. void Test(int a ) {} void Test(int* ptr) { } Test(0); Test(NULL); 2) 가독성 nullptr NULL *nullptr const class { public: // 그 어떤 타입의 포인터와도 치환 가능. template operator T* () const { return 0; } // 그 어떤 타입의 멤버 포인터와도 치환 가능. template operator T C::* () const { return 0; } private: //void operator&() const; // 주소값 &을 막는다. vo..

*auto auto a = 3; auto b = 3.14f; auto c = 1.23; auto d = Knight(); auto e = "test"; => 데이터 타입을 '추론' 해줌. => 형식 연역 ( type deduction ) *주의 => 기본적으로 auto 는 const , & 무시. => pointer ( * ) 는 판별 가능. int& ref = a; const int cst = a; int* iPtr = &a; auto test1 = ref; => int auto test2 = cst; => int auto test3 = iPtr; => int* *무엇이 문제일까 ?? => 어떻게 바꾸어야 할까?? auto&, int& vector v; v.push_back(1); v.push_back..

*중괄호 초기화 { } int a = 0; int b(0); int c{ 0 }; Knight k1; Knight k2 = k1; Knight k3{ k1 }; *어떤 '장점' 이 있는가 ?? 1. 컨테이너 초기화에 잘 어울림. vector v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); int arr[] = { 1,2,3,4 }; vector v2{ 1,2,3 }; 2. 축소 변환 방지 => 변수의 데이터 손실에 대한 에러를 발생시킴. int x = 0; double y(x); double z{ x }; '축소 변환' 은 가능한 값의 일부를 저장하지 못할 수도 있는 데이터 형식으로 값을 변경합니다. 예를 들어 소수 값은 정수 계열 형식으로 변환될 때 반..