눈물보다 땀을

실제로 os는 메모리를 페이지 맵핑을 하기 때문에 프로세스에서 관리하는 논리적 주소와 실제 물리적 주소는 다르다. 운영체제에게 메모리를 요청하면 최소 페이지 사이즈(4kb)로 할당 해준다. 프로세스에서 접근하는 메모리 주소는 맵핑된 주소기 때문에 절대 다른 프로세스와 중복되지 않으니 걱정하지 않고 써도 된다.

우리는 이 페이지 단위로 반환해주는 메모리 주소값에 데이터를 올려놓고 쓰면 된다.

https://jhnyang.tistory.com/290

그럼 페이지기법은 왜 나왔을까?

실제로 프로세스 메모리를 조작하기 위해서는 프로세스 메모리가 linear 한 상태가 되어야 한다.

그리고 물리적 메모리도 linear하게 매핑해서 쓰다보니 메모리 할당 반납하는 과정에서 메모리 파편화가 일어난다. 물리적 주소의 메모리 파편화를 external 파편화라고 한다. 그래서 중간에 페이지 맵핑 테이블을 두고 프레임(물리적 주소에서는 페이징을 프레임이라고 함)단위로 아무대나 할당하고 맵핑  테이블을 이용해서 프로세스에서는 linear한 생태로 사용하겠금한다.

반대로 이렇게 하면 논리적 메모리는 linear를 유지하기 떄문에 이쪽에도 파편화가 생길 수 있는데 이를 internal fragment라고 하고 이는 external fragment 보다 작기 때문에 페이징 방식을 쓴다.

결론

이후 단계를 보기 위해 이해해야 하는 내용은 다음과 같다.

- 논리주소를 liner한 상태로 유지하고 물리주소의 external 파편화를 줄이기 위해 페이징 단위로 테이블 참고하여 맵핑 하는 과정을 거친다.

- 뿐만 아니라 페이지 단위로 메모리에 속성을 부여하기도 한다(ex. 읽기용, 쓰기용 등) 왜냐하면 1바이트 단위로 메모리 속성을 지정하는 것은 그 속성 정보를 저장하기 위해서 그만큼의 메모리가 또 필요하기 때문에 비효율적.

이 글은 [인프런-게임서버 만들기 by rookiss]를 내용을 토대로 개인적으로 학습한 내용을 종합하여 정리 했습니다.

앞서 [CustomAllocator] 1단계_new, delete overloading에서 new, delete 오버로딩 하는 방법에 대해 학습했습니다.

오버로딩 하는 방법에는 크게 두 가지가 있습니다.

- 전역 오버로딩

- 클래스별 오버로딩

전역 오버로딩의 경우 모든 new, delete 연산자에 적용 되므로 위험한 방식 입니다. 그렇다면 메모리 관리를 하기 위해서는 클래스별 오버로딩을 쓰면 될까요? 가능합니다. 하지만 메모리 관리를 좀더 범용적으로 하려면 클래스별로 오버로딩을 작성하는 일도 여간 귀찮은 작업일 것 입니다. 매크로 등을 이용해서 조금은 개선 시킬 수 있지만요.

그래서 여기서는 저희만의 new, delete를 정의해서 사용하는 방법을 소개합니다. xnew, xdelete로 구현해 봅시다.

template<typename Type, typename... Args>
Type* xnew(Args&&... args)
{
	Type* memory = static_cast<Type*>( ::malloc(sizeof(Type) ); // 1단계 메모리 할당

	new(memory)Type(::forward<Args>(args)...); // 2단계 생성자 호출

	return memory; // 3단계 메모리 주소 반환
}

template<typename Type>
void xdelete(Type* obj)
{
	obj->~Type();    // 1단계 소멸자 호출
	::free(obj); // 2단계 메모리 반환
}

new, delete 동작 방식을 이해하고 있다면 위 코드를 이해하는 큰 어려움이 없습니다. 템플릿 코드로 바꿔준게 전부니까요. 이 코드를 이해 하기 위해서 new, delete 동작 방식 이외에 선수 지식이라면 템플릿 기초 문법, 템플릿 가변 매개변수, 전달참조(+forward) 정도 입니다. 위 코드가 이해되지 않는다면 해당 내용을 먼저 학습하고 위 코드를 보시면 어렵지 않게 이해할 수 있습니다.

본격적으로 메모리풀링을 하기 앞서 new, delete 연산자 흐름 가로채서 custom new, xdelete를 정의 했습니다. 이제 다음 단계에서 위 코드에 보이는 malloc 과 free 부분 역시 저희만의 메모리 할당기/해제기를 만들어 대체 해보도록 합시다.

이 글은 [인프런-게임서버 만들기 by rookiss]를 내용을 토대로 개인적으로 학습한 내용을 종합하여 정리 했습니다.

CustomAllocator를 만들기 앞서 핵심이 되는 new, delete 연산자 오버로딩에 대한 설명이 필요하다.

new, delete 연산자는 메모리를 할당, 해제하는 연산자로 이 연산자를 오버로딩 하여 메모리를 효과적으로 관리할 수 있다. 

하지만 다양한 메모리 할당 전략(컴파일러에 의한)을 모른다면 오히려 독이 될 수도 있다. 그러니 다양한 메모리 할당, 해제 원리나 정책을 이해하고 사용 했을 때 new, delete 오버로딩은 빛을 발할 것이다. 하지만 효율적인 메모리 관리 또는 순수한 학습용이 아니라도 디버깅(개발시)에 메모리 이슈를 해결하기 위한 안전 도구를 만드는데도 유용할 것으로 보인다. 실제로 이 글은 메모리를 효과적으로 관리하기 위한 기법과 메모리 이슈를 쉽게 잡아 내기 위한 기법 두가지를 설명하는 것을 목표로 한다.

자, 그럼 new, delete 연산자의 오버로딩에 대해서 알아보자.

new 와 delete의 구체적인 동작 방식

new 표현식

  Knight* knight = new Knight();

위 문장을 new-표현식이라고 합니다. 이 문장은 두가지 일을 합니다. 먼저 operator new를 호출하여 Knight 객체에 대한 메모리를 할당하고, 객체의 생성자를 호출합니다. 생성자 실행이 끝나고 나서야 객체에 대한 포인터가 리턴 됩니다.

실제로 어셈블러를 통해서 'operator new 호출 -> 생성자 호출 -> 객체 주소 리턴' 되는 과정을 알 수 있습니다.

흥미로운 점은 operator new가 실제로 void*를 반환하는데 이때 바로 객체의 포인터를 포인터 변수에 대입하지 않고 생성자 부터 호출되네요. 그리고 생성자가 호출되기 전에 cmp 비교를 통해서 분기가 나뉘는 것도 볼 수 있네요... 아직은 제가 이해하기 힘든 영역 입니다... 

delete 표현식

delete knight;

위 문장은 delete-표현식이라고 합니다. 이 문장 역시 new-표현식과 마찬가지로 두가지 일을 합니다. 먼저 소멸자를 호출하고 operator delete를 호출해서 메모리르 해제 합니다.

new 표현식과 다르게 'scalar deleting destructor'를 호출 하고 scalar deleting destructor 내부에서 소멸자와 operator delete를 호출하는 것을 확인 할 수 있습니다. scalar deleteting destructor는 컴파일러가 사용하는 함수라고 하는데 왜 new-표현식과 다르게 동작하는지는 잘 모르겠습니다.. 추측하자면 어떤 버전의 operator delete 연산자가 호출 될지는 호출된 operator new 버전에 따라 바뀌기 때문에 어떤 operator delete를 호출해야 할지에 대한 정보가 필요하기 때문에.. 이런 과정을 거치는게 아닐까 생각 해봅니다... 

요약하자면,

new-표현식은 ==> '메모리 할당 -> 생성자 호출'

delete-표현식은 ==>  '소멸자 -> 메모리 해제'

여기서 또 한가지 중요한 부분은 new, delete 표현식 자체는 오버라이딩 할 수 없습니다. 단지 new, delete 연산자를 오버로딩 하는 것 입니다. 즉 메모리 할당, 해제를 커스터마이징 할 수 있는 것이지요.

new 표현식과 operator new

new-표현식에는 여섯가지 종류가 있고, 각 버전마다 적용되는 operator new가 따로 있다.

그중 2개는 배치 new 연산자로 placement new operator라 부른다. 이 연산자를 사용하면 기존에 확보된 메모리에서 객체를 생성하고(생성자를 호출) 한다. 이는 메모리풀을 만들 때 유용하다. 또한 이 배치 new 연산자는 오버로딩이 금지되어 있다.

//일반
void* operator new(size_t size);
void* operator new[](size t_size);

//익센션
void* operator new(size_t size, const std::nothrow_t&) noexcept;
void* operator new[](size_t size, const std::nothrow_t&) noexcept;

//placement new operator(오버로딩 금지)
void* operator new(size_t size, void* p) noexcept;
void* operator new[](size_t size, void* p) noexcept;

delete 표현식과 operator delete

delete-표현식은 두가지 종류가 있다. 하지만 operator delete는 operator new와 동일하게 6종류가 있다. 왜 일까?

operator delete는 operator new와 항상 대응되어 호출된다. operator new 종류를 보면 일반버전 2개, 익센션버전2개, 배치버전 2개가 있다. operator new의 익센션 버전이 호출된단다면 operator delete 익센션 버전이 호출된다. 하지만 이는 개발자가 예측하고 처리하는 부분이 아니다. 따라소 익센션 버전 delete-표현식은 존재하지 않는다. 배치버전 delete-표현식 역시 이와 동일한 이유다.

// 일반
void operator delete(void* ptr) noexcept;
void operator delete[](void* ptr) noexcept;

// 익셉션
void operator delete(void* ptr, const std::nothrow_t&) noexcept;
void operator delete[](void* ptr, const std::nothrow_t&) noexcept;

// placement delete operator
void operator delete(void* p, void*) noexcept;
void operator delete[](void* p, void*) noexcept;

operator new와 operator delete 오버로딩 하기

특정 new, delete 연산자를 오버로딩하여 내부적으로는 전역 new,delete 연산자를 호출하는 예제입니다.

#include <iostream>
using namespace std;

class MemoryDemo
{
public:
    virtual ~MemoryDemo() = default;

    //normal.
    void* operator new(size_t size) { cout << "operator new" << endl; return ::operator new(size); }
    void operator delete(void* ptr) noexcept { cout << "operator delete" << endl; ::operator delete(ptr); }

    void* operator new[](size_t size) { cout << "operator new[]" << endl; return ::operator new[](size); }
    void operator delete[](void* ptr) { cout << "operator delete[]" << endl; ::operator delete[](ptr); }

    //exception.
    void* operator new(size_t size, const std::nothrow_t&) noexcept { cout << "operator new nothrow" << endl; return ::operator new(size, nothrow); }
    void operator delete(void* ptr, const std::nothrow_t&) noexcept { cout << "operator delete nothrow" << endl; ::operator delete(ptr, nothrow); }

    void* operator new[](size_t size, const std::nothrow_t&) noexcept { cout << "operator new[] nothrow" << endl; return ::operator new[](size, nothrow); }
    void operator delete[](void* ptr, const std::nothrow_t&) noexcept { cout << "operator delete[] nothrow" << endl; ::operator delete[](ptr, nothrow); }

    //placement new 는 오버로딩 불가능.
};



int main()
{
    MemoryDemo* mem = new MemoryDemo();
    delete mem;
    mem = new MemoryDemo[10];
    delete[] mem;
    mem = new (nothrow) MemoryDemo();
    delete mem;
    mem = new (nothrow) MemoryDemo[10];
    delete[] mem;
}

new, delete 연산자 오버로딩시 주의할 점

- 전역 operator new와 delete 는 교체하지 말 것. 최소한 교체 했다면 그 내부에서 또다시 new를 호출 하지 말 것. 무한 재귀가 될 수도 있다.

- operator new를 오버로딩 하면 반드시 대응되는 operator delete도 오버로딩 할 것. 대응되게 하지 않으면 기본 c++메모리 정책을 따르므로 할당-해제 정책이 달라지는 결과 초래한다.

- operator new, delete를 오버로딩 했다면 default, delete를 사용하여 operator new, delete 여러 타입들의 사용, 미사용 여부를 명확하게 할 것. 메모리 할당, 해제 정책의 일관성을 유지하기 위해서.

operator new와 operator delete에 매개변수를 추가하여 오버로딩하기

#include <iostream>
using namespace std;

class MemoryDemo
{
public:
    virtual ~MemoryDemo() = default;

    void operator delete(void* ptr) noexcept 
    { 
        cout << "operator delete" << endl; 
        ::operator delete(ptr); 
    }

    //custom
    void* operator new(size_t size, int extra)
    { 
        cout << "operator new with extra int : " << extra << endl; 
        return ::operator new(size); 
    }

    // 이 delete를 직접 호출할 순 없다. operator new호출 할때 그객체의 생성자에서 익셉션을 던져야 호출된다.
    void operator delete(void* ptr, int extra) noexcept  
    { 
        cout << "operator delete with extra int : " << extra << endl; 
        ::operator delete(ptr);
    }
};



int main()
{
    MemoryDemo* mem = new (__LINE__) MemoryDemo();
    delete mem;
}

짝꿍으로 custom 오버로딩한 operator delete는 직접 호출되지 않는다. 그래서 위 코드에서는 기본 delete가 호출된다.

이 부분은 아직 잘 이해를 못하겠다. 기본 delete를 정의하지 않으면 delete 키워드는 적절한 operator delete를 찾을 수 없다고 불평을 한다. 

매개변수를 추가하여 메모리 누수가 발생한 지점의 파일 이름, 줄번호 등을 받아서 로그를 남길 수도 있다.

관련 C 매크로

__FILE__ :: 파일이름

__LINE__ :: 줄번호

__FUNCTION__ or __func__ :: 함수 이름

operator delete에 메모리 크기를 매개변수로 전달 하도록 오버로딩 하기

주의 할점은 매개변수를 받지 않는 operator delete를 사용하면 매개변수 없는 버전이 먼저 호출 되므로 매개변수 있는 타입을 쓰려면 그 버전만 정의해라.

#include <iostream>
using namespace std;

class MemoryDemo
{
public:
    virtual ~MemoryDemo() = default;

    //custom
    void* operator new(size_t size)
    { 
        cout << "operator new " << endl; 
        return ::operator new(size); 
    }

    // 이 delete를 직접 호출할 순 없다. operator new호출 할때 그객체의 생성자에서 익셉션을 던져야 호출된다.
    void operator delete(void* ptr, size_t size)  
    { 
        cout << "operator delete with extra int : " << size << endl;
        ::operator delete(ptr);
    }
};



int main()
{
    MemoryDemo* mem = new MemoryDemo();
    delete mem;
}

:: 만 덜렁 쓰였을 때 의미는?

1. ::는 스코프 지정자.

2. 네임스페이스도 스코프의 일종.

3. 스코프 이름 없이 :: 만 쓰이면 글로벌 네임스페이스 스코프를 지정했음을 의미.

4. 글로벌 네임스페이스는 이름이 없다.

john nagle의 이름을 딴 알고리즘으로

네트워크 상에서 보내지는 수많은 패킷들을 줄여 TCP/IP 네트워크 효율성을 향상 시키는 알고리즘을 의미한다.

Winsock 라이브러리에서는 setsocket()함수를 이용하여 지정할 수 있다.

네이글 알고리즘 사용여부는 send() 함수 동작에도 영향이 있을 수 있다.

send() 함수는 기본적으로 send된 데이터의 바이트 수를 반환 하지만 이때 바이트 수는 정확히는 상대방이 수신한 바이트 수를 의미하지 않는다. 기본적으로 send 함수가 호출되면 커널 단의 send buffer에 등록된다.

send buffer를 비우고 실제로 데이터를 전송하는 시점은 send() 함수가 호출되는 시점과 다를 수 있다. 여러가지 이유가 있을 수 있지만 네이글 알고리즘 또한 그 중 하나다.

기본적으로 워드가 컴퓨터 연산의 기본 단위가 되는 정보양을 뜻하기 때문에 32bit 컴퓨터에서의 1워드는 4바이트, 64bit 컴퓨터에서의 1워드는 8바이트로 알고 있었다. 

하지만 공부를 하다보면 '워드'라는 표현이 상대적인 (cpu에 따라) 크기를 표현하기도 하지만 고정적인 크기를 표현하기도 한다는 걸 알았다.

그렇다면 word가 뭘까?

일반개념은 컴퓨터에서 연산의 기본 단위가 되는 정보 양. 즉 CPU에 따라 다른 크기를 갖는다.

그렇다면 워드가 2byte를 뜻하는 경우도 있던데 그건 왜일까?

인텔에서 16비트 시절 워드란 표현이 등장했고 이때 1워드는 2바이트를 의미했다. 해서 32bit에서 cpu에서도 동일한 동일한 워드란 단위는 혼동을 주기 때문에 DWORD(Double Word), 64bit cpu에서는 QWORD(Quadruple Word)를 사용하게 된 것 같다.

참고

https://namu.wiki/w/%EC%9B%8C%EB%93%9C

엔디언(endianness)란 컴퓨터의 메모리와 같은 1차원 공간에서 여러 개의 연속된 대상을 배열하는 방법을 뜻합니다.

빅에디안과 리틀에디안은 바이트 오더링 방식중 하나다.

빅엔디안(Big-Endian) - 최상위 바이트부터 차례로 저장하는 방식

리틀에디안(Little-Endian) - 최하위 바이트부터 차례로 저장하는 방식

빅엔디안

- 디버그시 편함(사람이 숫자를 읽는 순서와 동일하기 때문)

- 비교연산에서 유리

- 네트워크에서 사용

리틀엔디안

- 하위 바이트 사용시 유리. 

- 계산연산시 유리(두 숫자를 계산 할 경우 가장 낮은 자리수에 있는 숫자를 계산 해보고 자리 올림 수가 있는지 판단하기 때문에)

- 인텔계열 프로세스에서 사용.

때문에 데이터 통신할 때는 송,수신자가 같은 엔디안 방식으로 통일해야 합니다.

함수는 함수 포인터 변수로만 보관할 수 있고, 함수자(functor)는 객체 타입으로만 보관이 가능합니다.

std::function을 사용하면 모든 collable 들을 객체형태로 보관할 수 있습니다. 심지어 람다식도 보관할 수 있습니다.

여기서 collable은 소괄호를 이용하여 호출 가능한 모든형태를 말합니다.

물론 auto를 통해서도 collable 들을 보관할 수도 있습니다. auto와 std::function의 차이는 뒤에 설명하겠습니다. 

일단, 간단한 사용 예시를 봅시다.

간단한 사용 예시

#include <iostream>
#include <functional>
using namespace std;

int func(const string& a)
{
    cout << "func1 " << a << endl;
    return 0;
}

struct functor
{
    void operator() (char c)
    {
        cout << "functor : " << c << endl;
    }
};


int main()
{
    function<int(const string&)> f1 = func;
    function<void(char c)> f2 = functor();
    function<void(void)> f3 = []() { cout << "lamda func" << endl; };

    f1("hi");
    f2('k');
    f3();
}

C에서의 함수 포인터에서도 멤버변수를 보관할 떄 문법이 약간 달라졌던 것 처럼 std::function 을 이용할 때도 동일합니다. 당연히 멤버함수는 객체 의존적인 함수이기 떄문입니다. 멤버함수는 암무적으로 자신을 호출한 객체를 인자로 암묵적으로 받고 있기 때문에 std::functio에 타입에 멤버함수의 클래스타입을 첫번째 인자로 명시해야 합니다.

함수 포인터와 마찬가지로 멤버함수를 보관할 때는 명시적으로 멤버함수 앞에 &를 통해 함수 주소를 반환하고 있습니다. 이게 FM 이죠. 정적, 전역함수의 경우 컴파일러에 의해서 암묵적으로 함수이름이 함수주소를 반환해주고 있었던거니 까요.

멤버함수를 보관하는 std::function 객체

#include <iostream>
#include <functional>
using namespace std;


class Knight
{
public:
    void AttackByFist() const
    {
        cout << "AttackByFist" << endl;
    }

    void AttackBySword(int addDamage)
    {
        cout << "AttackBySword" << endl;
    }
};

int main()
{
    function<void(const Knight&)> attackByFist = &Knight::AttackByFist; // <void(Knight&)> 형태로도 const 멤버 함수를 보관됩니다. 이유는 모르겠습니다.
    function<void(Knight&, int)> attackBySword = &Knight::AttackBySword;

    Knight k;

    attackByFist(k);
    attackBySword(k, 100);
}

mem_fn

mem_fn 함수는 멤버함수 function 객체를 반환합니다.

언제 mem_fn 함수가 유용할 할까요?

먼저 문제가 되는 상황을 살펴 보겠습니다.

#include <iostream>
#include <functional>
using namespace std;


class Knight
{
public:
    Knight(string name) : _name(name) {};
public:
    void Print()
    {
        cout << "I am Knight :: " << _name << endl;
    }

private:
    string _name;
};

template<typename Func>
void func(Func f)
{
    Knight k("by func");
    f(k);
}


int main()
{
	func(&Knight::Print);   // 컴파일 에러
}

이 경우 '이름()' 형태로 호출되지 않기 때문에 func 함수 내부에서 'f(k)'는 동작하지 않습니다. 따라서 collable 형태로 사용 가능하도록 function 객체로 넘겨 주어야 합니다.

        function<void(Knight&)> f = &Knight::Print;
        func(f);

이처럼 funtion 객체로 받고 func 인자로 넘겨주면 collable 형태로 호출이 가능하기 떄문에 정상 작동합니다. 이 과정을 대신 할수 있는 방법에는 두가지가 있습니다. std::mem_fn을 사용하거나 람다식을 이용하는 방법입니다. 

mem_fn 사용

        func(mem_fn(&Knight::Print));

람다식 사용

        func([](Knight& k) {
            k.Print();
        });

개인적으로는 mem_fn 코드는 더 짧지만 functional 헤더를 추가 해야하고 람다는 함수객체를 선언과 동시에 collabe 형태로 전달도 가능합니다.

람다는 auto와 같이 사용될 때 막강한 편의성을 제공합니다.

std::function을 이용하여 collabe 타입을 명시적으로 지정하고 특정 타입의 collabe만 받는 함수객체를 관리하고 싶을 때 유용한것 같습니다.

std::bind

함수객체 생성과 동시에 디볼트 인자값을 지정할 수 있습니다. 사용빈도가 떨어지는 것 같아 생략.

함수 객체는 STL에 유용하게 사용된다.

C++11에서는 이런 함수 객체를 손쉽게 작성하는 '람다' 라는 기능을 제공한다.

람다에 의해 만들어진 실행시점 객체를 클로저(closure)라고 합니다.

사용법

    float ratio = 0.3;;

    auto addLamda = [&ratio](int a, int b) -> float {
        float ret = (a + b) / ratio;
        return ret;
    };

    float ret = addLamda(3, 4);  // 2.3333

[캡쳐](인자) -> 타입 { 구현부 }

캡쳐(capture)

함수 객체 내부에 변수를 저장하는 개념과 유사하다. '구현부'에서 외부 변수를 사용할 때 방식을 지정할 수 있다.

방식에는 복사방식, 참조방식이 있다. 

예)

[=] : 모든 값을 구현부에서 복사 방식으로 사용합니다.

[&] : 모든 값을 구현부에서 참조 방식으로 사용합니다.

[a, &b] : b변수를 참조 방식으로 사용합니다. a변수는 복사 방식으로 사용합니다.

인자

함수 매개변수와 동일한 형태로 매개변수를 받습니다.

예) [](int, int)

타입

'-> bool' 과 같은 형태로 지정하지만 실제로 구현부 return 값을 통해 자동 추론 되기 때문에 생략 가능 합니다.

구현부

일반 함수 구현부와 동일하게 작성됩니다.

주의점

MS에서는 캡쳐방식에 [=], [&] 사용을 지양합니다. 이는 명시적인 캡쳐 방식을 지정하지 않을 경우에 문제를 인식하기 쉽지 않기 때문입니다.

문제가 되는 경우를 아래 코드를 통해서 살펴 봅시다.

class Knight
{
    public:
        auto ResetHpJob()
        {
            // this 포인터가 복사된 형태
            // 캡터 부분만 봐서는 한눈에 알아보기 힘들다.
            auto f = [=]()
            {
                _hp = 200;
            };

            //auto f = [this]()
            //{
            //    this->_hp = 200;
            //};
            
            return f;
        }

    public:
        int _hp = 100;
};

해당 코드는 클래스 내부에서 람다를 정의하고 있습니다. 그리고 ResetHpJob 함수에서는 멤버변수를 접근하는 람다를 반환하고 있습니다. 이 람다를 외부에서 호출하게 되면 문제가 됩니다.

왜냐하면 람다 정의부분은 객체에 의존적인 변수에 접근하고 있고 람다가 호출되는 시점에 객체가 존재한다는 보장 이 없기 때문입니다.

이런 코드 작성을 미리 방지하려면 어떻게 해야 할까요??

클래스 내부이기 때문에 멤버변수를 의심없이 접근하고 있지만 실제로는 'this->멤버변수' 와 같은 형태로 접근 되어야 합니다. 따라서 캡쳐 방식을 지정해야 합니다. 이때 [=] 와 같은 방식으로 지정하게 된다면 '='가 this 포인터를 복사하기 위함인지 한눈에 파악하기 어렵습니다.

이런 이유로 캡쳐 방식을 지정할 때는 변수별로 별도로 지정하는 것이 코드 가독성을 높이고 이는 곧 디버깅을 쉽게 합니다.

다양한 초기화 방법

C++ 에서는 =,(),{} 와 같은 다양한 초기 방법이 있다.

(일반 자료형과 객체 타입 초기화 방식에는 약간의 차이가 있다.)

장점

- 축소 변환 방지(컴파일 에러)

- 배열의 초기화 문법 {}와 같이 생성자를 정의할 수 있다.

단점

- initializer_list<T> 생성자를 이용하여 stl container vector와 같은 방식으로 초기화 할 수 있다. 이때 일반적인 생성자 시그니처와 initailizer 초기화 방식의 시그니처가 동일한 경우 (), {}에 따라 다른 생성자가 호출된다. 이는 초기화 호출방식에 대한 혼란을 야기시킨다.

결론

• 소괄호 초기화
  • 전통적인 초기화 방식 → 거부가 없음
  • vector 등 특이한 케이스에 대해서면 {} 사용
• 중괄호 초기화 {}
  • 초기화 문법 일치화(intializer_list<T> 생성자를 이용) ⇒ 100% 대응하진 못함.
  • 축소 변환 방지
• 개인 생각
  • 중괄호 초기화 방식의 축소변환은 확실히 개발단계에서 장점이지만 이고 개인의 취향에 따른 선택사항이지만 중괄호 초기화로 인해 생성자 호출 방식에 있어서 분기점이 생긴다. 이는 팀단위 개발에서는 코드 가독성을 떨어뜨릴 것 같다. {}초기화는 약속된 특정 클래스에서만 합의하에 사용하는게 좋을 것 같다. 애초에 ms도 그렇게 사용하는 것(?) 같다.

#include <iostream>
#include <vector>

using namespace std;

class Knight
{
public:
	Knight()
	{
		cout << "Knight 기본 생성자" << endl;
	}

	Knight(const Knight& k)
	{
		cout << "Knight 복사 생성자" << endl;
	}


	Knight& operator = (const Knight& k)
	{
		cout << "Knight 대입 연산자" << endl;
		hp = k.hp;
		return *this;
	}

public:
	int hp = 100;

};

class Mage
{
public:
	Mage()
	{

	}

	Mage(int a, int b)
	{
		cout << "Mage(int int)" << endl;
	}

	Mage(initializer_list<int> li)
	{
		cout << "Mage(initailizer_list)" << endl;
	}
};

Knight Func()
{
	return Knight();
}

int main()
{
	// 다양한 초기 방법
	{
		// 일반 자료형
		int a = 0;

		int b(0);
		int c = (0);

		int d{ 0 };
		int e = { 0 };

		// 객체 타입
		Knight k1; // k1 기본 생성자
		Knight k2 = k1; // k2 복사 생성자

		Knight k3; // k3 기본 생성자
		k3 = k1; // k3 대입 연산자

		Knight k4{ k2 }; // k4 복사 생성자.
	}

	// !주의!
	{
		Knight k5(); // knight k5; 이 기본생성자를 호출하는 거고 knight k5()는 함수 선언문이다. void형 매개변수에 리턴값이 knight인 k5.
		Knight k6{}; // 이건 기본생성자 버전.
	}

	// {} 초기화 장점 - 축소 변환 방지
	{
		// 일반 초기화시 축소됨
		double x = 1.34;
		int y = x; // 컴파일에서 경고
		int z = { x }; // 컴파일에서 에러
	}

	// {} 초기화 장점 - 배열과 같은 방식을 객체 초기화 가능.
	{
		// 번거로운 초기화 방식
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);

		// {}를 이용한 초기화 방식. 마치 배열 초기화 방식과 유사
		int arr[] = { 1,2,3,4,5 };

		v1 = { 1,2,3,4 };

	}

	// {} 문제점 - 아래 두 초기화 방식은 다른 생성자를 호출한다. - why?
	{
		vector<int> v1{10 , 1}; // 벡터 크기를 10으로 지정하고 모든 요소를 1로 초기하는 생성자 호출.
		vector<int> v2(10, 1); // 벡터에 10, 1 두 값을 초기화하는 생성자 initalizer_list 생성자 호출.
	}


	// {} 문제점 재현
	{
		Mage m{ 3,4 }; // initailizer 생성자가 정의되어 있으면	Mage(int a, int b) 생성자는 호출되지 않습니다.
	}

	return 0;
}

공부한 내용을 개인적으로 복습하기 쉬운 형태로 정리했습니다.

잘못된 내용이 있는 경우 언제든 댓글 혹은 이메일로 지적해주시면 감사드립니다.

특징

- typedef 보다 직관적인 사용 방식

- 탬블릿 문법과 사용시 typedef 보다 더 궁합이 잘 맞는다.

- typedef 장점은.. 없다. 그냥 using 쓰세요..

사용 예제

#include <iostream>
#include <vector>
#include <list>
using namespace std;


// 직관성 - 가독성
typedef __int64 id;
using id2 = int; 

// 직관성 - 함수 포인터
typedef void (*MyFunc)(); // 매개변수와 리턴값이 없는 함수 포인터
using MyFunc2 = void(*)();

// tmeplate과의 궁합 - using (ok)
template<typename T>
using List = ::list<T>;

// tmeplate과의 궁합 - typedef (ok) - struct나 class로 typedef를 감싸는 등의 방법이 있긴하다.
//template<typename T>
//typedef list<T> List;

// typedef + template의 흉측한 모습
template<typename T>
struct List2
{
	typedef std::list<T> type;
};

int main()
{
	List<int> li;				// using + template => 깔끔
	List2<int>::type li2;		// typedef + template => 흉측

	return 0;
}

공부한 내용을 개인적으로 복습하기 쉬운 형태로 정리했습니다.

잘못된 내용이 있는 경우 언제든 댓글 혹은 이메일로 지적해주시면 감사드립니다.

특징

- 일종의 조커카드로 타입을 명시적으로 지정하지 않아도 타입을 추론 가능하게 하는 타입이다. 이를 형식추론 혹은 형식연역(type deduction, type inference)

- c+14 에서 함수 리턴값으로 auto 키워드가 사용 가능

주의

- const나 &가 붙은 타입은 auto로 정확하게 타입추론이 되지 않는다. 보통 const나 &를 무시한 나머지 타입을 근거로 추론하는 것 같다.

- 함수 매개변수 타입으로 사용 불가능

- auto 키워드를 사용하여 선언할 경우에 반드시 초기값이 있어야 한다.

사용 예제

#include <iostream>
#include <vector>

class Knight
{

};

// 함수 매개변수 타입으로 쓰인 경우 -> 컴파일 에러.
int Func(auto num1, auto num2) 
{

}

// 함수 리턴 타입으로 auto가 사용 가능.(c++14부터)
auto Func1(int num1, int num2)
{
    return num1 + num2;
}

int main()
{
    // 정상적으로 함수 추론이 가능한 경우.
    {
        auto a = 3; // int
        auto b = 3.14f; // float
        auto c = 1.23; // double
        auto d = Knight(); // class
        auto e = "rookiss"; // string literal
        auto f = Func1(1, 2); // int
    }

    // 컴파일 에러. auto 타입 사용시 반드시 초기값이 필요하다.
    {
        auto a; 
    }

    // const와 &가 포함된 타입은 정확하게 추론하지 못 하는 auto.
    {
        int a;
        int& ref = a;
        const int cst = a;

        auto refAuto = ref; // int 
        auto cstAuto = ref; // int
    }

    // auto 특성을 제대로 이해하고 사용된 예
    {
        std::vector<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);

        for (size_t i = 0; i < v.size(); i++)
        {
            //!주의! 이 경우 여전히 int 타입으로 추론합니다. 
            //auto data = static_cast<int&>(v[i]); 

            auto& data = v[i]; // int&
            data = 100;
        }
    }

    // stl literator에 사용된 auto
    {
        std::vector<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);

        // auto 사용 이전.
        for (std::vector<int>::iterator it = v.begin(); it < v.end(); it++)
        {
            *it = 1;
        }

        // auto 사용 후.
        for (auto& it : v)
        {
            it = 1;
        }
    }
}

결론

- 특별하게 타입이 길지 않는 이상 명시적으로 타입을 지정하는게 가독성 측면에서 좋은 것 같다.

- stl literator 같은 경우 사용 빈도가 높고 타입이 길어지는 경우가 많으니 auto를 사용하기 적합

- 태블릿과 같이 고급기법에서 auto가 활용 되기도 한다.

공부한 내용을 개인적으로 복습하기 쉬운 형태로 정리했습니다.

잘못된 내용이 있는 경우 언제든 댓글 혹은 이메일로 지적해주시면 감사드립니다.

특징

- 함수처럼 동작하는 객체

- () 연산자 오버로딩을 통해 함수와 비슷한 형태로 호출합니다.

- 함수자(Functor) 라고도 합니다.

함수 포인터와 함수 객체의 차이점

- 함수 포인터는 시그니처가 일치 하지 않으면 전달할 수 없지만 함수 객체는 객체를 전달하기 때문에 상관 없다.

- 함수 포인터는 정해진 시그니처에 맞게만 호출 가능하지만 함수 객체는 ()연산자 오버로딩을 통해 다양한 시그니처로 호출될 수 있다.

- 함수 객체는 객체의 특성을 모두 갖기 때문에 상태를 저장(람다에서의 캡쳐와 동일)할 수 있다.

- 함수 객체는 인라인 함수로 호출될 수 있습니다.

함수 객체 간단한 구현 예제

- 함수 객체는 () 오버라이딩과 객체기 떄문에 멤버변수를 갖을 수 다는 특징이 있습니다.

#include <iostream>
using namespace std;

class Functor
{
public:
    void operator() (int data)
    {
        _data = data;
        cout << "void (void) : " << _data << endl;
    }

    int operator() (int a, int b)
    {
        cout << "int (int, int)" << endl;
        return a + b;
    }

public:
    int _data;
};

int main()
{   
    Functor functor1;
    functor1(10);

    Functor functor2;
    cout << functor2(1, 2) << endl;

    return 0;
 }

함수 객체만 인라인 함수 호출이 가능하다는 건 무슨 얘기일까?

함수 객체는 ()연산자 함수를 inline으로 호출되게 할수 있습니다. 이 말인 즉슨 일반 함수 포인터를 사용하게 되면 해당 함수는 inline방식으로 호출할 수 없습니다.

여기서 inline 함수란 뭘까요? 인라인함수를 사용하면 컴파일 타임에 코드가 매크로와 같이 치환됩니다. 따라서 함수를 호출하는 오버헤드가 없지만, 소스코드양이 증가합니다. 따라서 코드가 짧고 자주 호출되는 함수를 inline으로 지정하는 것이 효율적입니다. 하지만 요즘 컴파일러는 최적하여 inline 적용 여부를 정합니다. 이떄 __forceiline 키워드를 이용하여 컴파일러에게 inline을 강제할 수도 있긴 하지만 이 경우에도 컴파일러가 판단하기에 비효율적이면 무시될 수도 있습니다.

그렇다면 왜 함수 객체를 이용하면 inline 사용을 컴파일러에게 유도할 수 있는 것일까요?

이는 inlline 적용 여부가 컴파일 단계에서 결정 되기 때문에 inline 시킬 대상(코드로 치환할)이 명확하게 컴파일러가 알수 있어야 합니다.

하지만 함수 포인터를 이용한 호출의 경우 시그니처가 동일한 함수가 여러개 정의 되어 있으면 컴파일러는 어떤 코드를 치환해야 할지 알수 없습니다.

아래 코드 실행시 생성되는 어셈블러 코드를 확인 하면 함수포인터로 호출된 함수는 무조건 일반함수 호출을 하는 것을 알 수 있습니다.

#include <iostream>
using namespace std;

void PFunc1()
{
    cout << "PFunc1" << endl;
}

inline void PFunc2()
{
    cout << "PFunc2" << endl;
}

class Functor
{
public:
    void operator() ()
    {
        cout << "Functor()" << endl;
    }

    inline void operator() (int num)
    {
        cout << "Functor(int)" << endl;
    }

};

int main()
{
    void (*pfunc)(void);
    pfunc = &PFunc1;
    pfunc(); // 일반함수 -> 일반함수 방식으로 호출(항상)

    pfunc = &PFunc2;
    pfunc(); // 인라인함수 -> 일반함수 방식으로 호출(항상)

    Functor functor;
    functor(); // 일반함수 -> 인라인 함수로 호출(컴파일러가 판단)
    functor(1); // 인라인 함수 -> 인라인 함수로 호출(컴파일러가 판단)

}

함수 객체의 의미

- 일감을 객체 형태로 정의(데이터, 로직)하고 실제 일감은 다른 로직을 통해 적절한 시기에 일감이 처리 되도록 할수 있다. 이는 일감을 정의하는 시점과 일감을 처리하는 시점을 구분할 수 있다는 것을 의미(커맨더 패턴) 하는 중요하는 개념이다.

- 템플릿과 같이 사용되어 콜백 함수 구현 등에 활용 된다.

콜백함수 구현 예제

#include <iostream>
using namespace std;

class Item
{
public:
    int _itemId = 0;
    int _rarity = 0;
    int _ownerId = 0;
};

//함수 객체
class FindByOwnerId
{
public:
    bool operator() (const Item* item)
    {
        return (item->_ownerId == _ownerId);
    }

public:
    int _ownerId;
};

//함수 객체
class FindByRarity
{
public:
    bool operator() (const Item* item)
    {
        return (item->_rarity == _rarity);
    }

public:
    int _rarity;
};

template<typename T>
Item* FindItem(Item items[], int itemCount, T selector)
{
    for (int i = 0; i < itemCount; i++)
    {
        Item* item = &items[i];

        if (selector(item))
        {
            return item;
        }
    }

    return nullptr;
}

int main()
{       
    Item items[10];
    items[3]._ownerId = 100;
    items[8]._rarity = 2;

    FindByOwnerId functor1;
    functor1._ownerId = 100;

    FindByRarity functor2;
    functor2._rarity = 2;

    Item* item1 = FindItem(items, 10, functor1);
    Item* item2 = FindItem(items, 10, functor2);

    return 0;
 }

결론

- 함수 객체(함수자)가 일반함수포인터를 사용하는 경우보다 장점이 훨씬 많습니다.

- 인라인 함수 호출 유도, 상태 저장, 템플릿과 궁합이 잘 맞는 등..

- STL에서 함수객체를 받는 이유도 inline 함수 호출을 유도하여 라이브러리단의 기능을 최적화 하려는 것으로 볼 수 있다.

공부한 내용을 개인적으로 복습하기 쉬운 형태로 정리했습니다.

잘못된 내용이 있는 경우 언제든 댓글 혹은 이메일로 지적해주시면 감사드립니다.

선언방법

int (*pfunc1)(int, int);   // 일반적인 방법         
typedef int (*pfunc2)(int, int); // 편의를 위해 typdef를 이용하여 별칭을 정의
using pfunc3 = int(*)(int, int); // 편의를 위해 using을 이용하여 별칭을 정의

정의

함수 이름은 배열이름과 같ㅌ이 함수의 위치를 가리키는 주소값을 나타낸다. (실제론 &를 사용해서 함수를 참고해야 하는 경우도 있으니 절대적이진 않다.)

따라서 함수포인터 변수를 통해 동일한 시그니처의 함수를 전달할 수 있다.

사용법

- 1. 함수 포인터 변수 = [함수이름]

- 2. 함수 포인터 변수 = &[함수이름]

- 1. 함수이름();

- 2. (*함수이름)();

#include <iostream>

int func(int a, int b)
{
    return a + b;
}

int main()
{
    int (*pfunc)(int, int);

    pfunc = func; // 방식1.배열이름과 같이 함수이름이 주소값을 나타낸다. 하지만 이는 C언어와의 호환성 때문에 컴파일러에서 지원 하는 기능이다.
    pfunc = &func; // 방식2. 위 방식보다 이게 FM 방식이다. 클래스 멤버함수를 변수에 전달할 때는 FM 방식을 따라야 하는 경우가 있다.
    
    pfunc(1,2); // 방식1.편의
    (*pfunc)(1, 2); // 방식2.FM
}

함수 포인터 변수가 아닌 일반 함수 변수는 사용하지 않을까?

- 함수 변수는 단순히 함수 선언부이다. 따라서 linking 과정에서 같은 시그니처(이름 포함) 정의부현을 찾아서 해당 함수가 호출된다.

- 변수에 다른 함수를 넘길 수 없다.

#include <iostream>
using namespace std;

int func(int a, int b)
{
    cout << "func()" << endl;
    return a + b;
}

int func1(int a, int b)
{
    cout << "func1()" << endl;
    return a + b;
}


int main()
{
    int (func)(int, int); // 일단적인 타입과 다르게 메모리에 적재 되지도 않음. 단순히 함수 선언부이다.

    {
        func = func1; // (x)
    }

    {
        func(); // func 함수 정의가 있다면 호출. 없다면 링킹에러.
    }
 }

따라서 아래와 같은 방식으로 사용된다.

#include <iostream>
using namespace std;

int func(int a, int b)
{
    return a + b;
}

int main()
{       
    // 선호 되는 방식
    {
        typedef int (*pfunc1)(int, int); 
        using pfunc2 = int(*)(int, int); 

        pfunc1 p1 = func;
        pfunc2 p2 = func;
    }

    // 비선호 되는 방식
    {
        typedef int (pfunc1)(int, int);
        using pfunc2 = int(int, int);

        pfunc1* p1 = func;
        pfunc2* p2 = func;
    }
 }

예외적인 사용법 - 멤버함수를 보관하는 함수

위와 같은 방식으로(전역, 정적 함수만 가능) 특정 클래스의 비정적 멤버함수를 변수에 받을 수 없다.

비정적 멤버함수를 변수로 받을 때는 전달방식, 호출방식 모두 차이가 있으니, 아래 코드를 통해 확인 하자.

#include <iostream>
using namespace std;

class Knight
{
public:
    int func(int a, int b)
    {
        cout << "Knight:func()" << endl;
        return a + b;
    }
};

int main()
{       
    int (Knight::*pmfunc)(int, int);

    {
        pmfunc = Knight::func; // 일반적인 방식으로 전달 불가.(컴파일 에러)
        pmfunc = &Knight::func; // FM으로 &연산자 사용 해야 함.
    }

    {
        Knight k1;

        k1.pmfunc(1, 2); // 불가
        (k1.*pmfunc)(1, 2); // 가능(FM)
    }

    {
        Knight* k1 = new Knight();
        (k1->pmfunc)(1, 2); // 불가
        (k1->*pmfunc)(1, 2); // 가능(FM)
    }
    
 }

공부한 내용을 개인적으로 복습하기 쉬운 형태로 정리했습니다.

잘못된 내용이 있는 경우 언제든 댓글 혹은 이메일로 지적해주시면 감사드립니다.

1.<<연산자

inserstion? 밀어넣기? 출력, 푸쉬 연산자?

+,-등과 같은 연산자 중 하나

c++에서는 프로그래머가 연산자 동작을 바꿀 수 있다 => 연산자 오버로딩

2.출력형식 지정 (Output formatting)

C vs C++

C

서식문자를 이용하여 출력서식 지정

 int num =10;
 printf("%#x\n", number);

C++

manipulator를 이용한 출력서식 지정

int number = 10;
cout << showbase << hex << number << endl;

C++의 Manipulator(조정자) 종류

* 조정자를 이용하여 출력서식 지정시 설정된 값이 이후 출력에도 적용되는 경우가 있으므로

출력서식을 기본값으로 바꿔놓는 걸 유념하기

기본 조정자

showpos/noshowpos

-pos는 positive를 의미하며 양수 기호를 출력할지 여부를 결정합니다.

int number = 123;
cout << showpos << number << endl;    //+123
cout << noshowpos << number << endl;  //123

number = -123;
cout << showpos << number << endl; //-123
cout << noshowpos << number << endl; //-123

dec/hex/oct

- 숫자 출력 진법을 지정합니다.

int number = 123;
cout << dec << number << endl; //123
cout << hex << number << endl; //7b
cout << oct << number << endl; //173

uppercase/nouppercase

- 대소 출력을 지정합니다(문자에는 지정되지 않습니다.)

int number = 123;
cout << uppercase << hex << number << endl; //7B
cout << nouppercase << hex << number << endl; //7b
char c = 'A';
cout << nouppercase << c << endl; // A ---- 문자에는 적용되지 않음

showbase/noshowbase

- 진법 base 출력을 지정합니다.

int number = 123;
cout << showbase << hex << number << endl; //0x7b
cout << noshowbase << hex << number << endl; //7b

showpoint/noshowpoint

- 유효한 소수점 자리까지만 출력할지 여부를 지정합니다.

float decimal1 = 100.0f;
float decmall2 = 100.12f;
cout << noshowpoint << decimal1 << " " << decmall2 << endl; //100 100.12
cout << showpoint << decimal1 << " " << decmall2 << endl; //100.000 100.120

fixed/scientific

- 소수점 표기 방법을 구분 합니다.

float number = 123.3456789f;
cout << fixed << number << endl; //123.345680
cout << scientific << number << endl; //1.233456e+02

boolalpha/noboolalpha

- boolean자료형 출력 형태를 지정합니다.

bool bReady = true; 
cout << boolalpha << bReady << endl; //true
cout << noboolalpha << bReady << endl; //1

iomanip.h에 정의되어 있는 조정자

setw()

- 정렬 형태를 지정합니다.

int number = -123;
cout << setw(6) << left << number << endl; //[-123  ]
cout << setw(6) << internal << number << endl; //[-  123]
cout << setw(6) << right << number << endl; //[  -123]

setfill()

- 빈공간을 지정한 문자로 채운다.

int number = 123;
cout << setfill('*') << setw(5) << number << endl; //[**123]

setprecision()

- 유효숫자 정확도 수준을 지정.

float number = 123.456789f;
cout << setprecision(7) << number << endl; //123.4568
cout << setprecision(10) << number << endl; //123.4567871

EXPRESS YOURSLEF

ISSUE 08 - Hobbies

ISSUE 09 - Jobs

7. Why not learn to enjoy the little things - there are so many of them?

> satisfaction 

> It means practicing gratitude for those everyday moments that are so easy to take for granted or forget (simple things). Because those little things are the things we often end up cherishing the most. 

> In the perspective of a mature person, we must learn how to appreciate little things. 

Why is it important to appreciate the little things? 

> You  are only keen to succeed in bigger goals we will eventually get so exhausted. 

> Appreciating the little things in life means that you focus your attention on what nurtures and sustains you in life.

8. What we enjoy, not what we have, constitutes our abundance.  

> Material wealth 

> This statement means that material wealth is not equal to our happiness 

> Appreciation of little things 

> We have to know that we can enjoy our life not by what we have, but by what we enjoy even though it's little things. 

Issue 9 

JOBS 


Skybel, 오후 4:37
At the mercy of  - no protection 

manipulation - control 

COMPREHENSION 

1. 

> They don't need to exert much effort 

> metal task 

2. workers// employees 



Skybel, 오후 4:47
EXPRESS YOURSELF 

2. It encourages me to improve more

EXPRESS YOURSLEF

ISSUE 08 - Hobbies

> Problems may just disappear by itself 

> To get rid of my problems I just work out and sleep deeply 

The Monk Who Sold his Ferrari 

3.   A lot of singers on TV are watching. Too bad they're not worth listening to. 

> Most of the singers these days performed well by adding choreography dance  


Skybel, 오후 4:24
4. 

> Living in a simple life is not easy, because people usually have a lot of difficult events to handle, this events make people's life more complicated and hard. 

> It I just act normally maybe people will regard me as a loser. 

> The trend in the modern society  changed rapidly, so if we keep on following this trend we will eventually get exhausted with it 

> In my case, I don't want to follow this belief 

5. 

> I agree, this is a very famous proverbs 

attainments 

idiomatic 


Skybel, 오후 4:37
6 

> People who have fishing hobbies are likely to exaggerate their fish just before missing one. 

> There are some cases people exaggerate things because they are looking for attention, they want to appear interesting, or they need others like them. 


Skybel, 오후 4:43
Emphasis is important in a conversation 

Hyperbole  = English exaggerated sentences 

It's raining cats and dogs. 

He's as skinny as a toothpick. 

I'm so hungry I could eat a horse.

EXPRESS YOURSLEF

ISSUE 08 - Hobbies

Express Yourself 

3. I prefer spending time alone 

> virtual 

4. I barely engage in hobbies these days because I am concentrating more on studies

> I spend whole day ~ 

Clients programming - it shows visual graphics 

Server programming - supports gaming systems / focuses more on logic 

> more maniac 
> better compensation 


Skybel, 오후 4:16
5. Gamers 

a team 

Can video/online  games be considered a sport? 

> athletic activity or sports requires good competition and great stamina 

> Esports has no showmanship 

no age limit 

6. advantages of having hobbies

a. It makes me feel better, it gives me an escape 


b. Strengthen you physically and mentally 

c. My body is transitioning better 

7. aerobic 

> cardiovascular 

> I just enjoy watching  

 >I asked my brother to play the game with me. 

> My brother and I 

USEFUL EXPRESSION 

1.  Fishing stimulates the brain-also the imagination. So, we can have enough time to think and imagine whatever we want while fishing. In other words, many problems will solve itself, if we forget about it and go fishing and catch good fishes.

EXPRESS YOURSLEF

ISSUE 07 - Friends

ISSUE 08 - Hobbies

5. Time separates the best of friends, but so does money—and marriage. 


Time separates the best of friends,  

* distance 

does - also can separate 


Skybel, 오후 4:10
6. A good friend is one who can tell you all his problems—but doesn’t.  

> I think it quite hard to agree with this statement completely, because every relation depends on a mutual understanding and emotion. 

> If my friend can open up his burdens on me, I can comfort him yet I would also be uncomfortable, or vice versa  

7. The more arguments you win, the fewer friends you’ll have.  

> It's a story about keeping our pride 

> If you are persistently eager to win ~

> humble 

8. Friendship is like money—easier made than kept 

> Earning money is harder than spending it 

> Keeping genuine friends is harder finding new one ~


Skybel, 오후 4:28
10. You can win more friends with your ears than with your mouth.

> We always know how to compromise 


Skybel, 오후 4:36
Issue 8 

Hobbies 

> I think this paragraph says about every persons' hobby 

> Each hobbies has it's bad sides 

> In short, hobbies can alleviate burdens  

COMPRHENSION 

1. relieving our burdens 
    killing time 

2. motivation 

EXPRESS YOURSLEF

ISSUE 07 - Friends

6. Out of mind and out of sight

> Constant communication 


Skybel, 오후 4:10
> We can be apart from each other physically, but sometimes our previous relation could still be the same. 

 


Skybel, 오후 4:16
7. Having female friends  completely differ from having male friends. 

> They could create more  intimate and personal relationship 


> Sometimes my ex-girlfriend doesn't like her 

> We've been friends for about two decades 


Skybel, 오후 4:25
8. When we're in our childhood stage, our mind and body changed so quickly, so I think we were all different person during those stages. 

> At those time, we could make tons of friends regardless of all the prejudices 

> Our behavioral aspects were improving 

> We could posses our on unique attitude 


Skybel, 오후 4:32
USEFUL EXPRESSION 

1. borrowing 

> The people that you think are you friends might not be when there's money involved.

2.  A friend that isn’t in need is a friend indeed. 

> People only need their friends when they need some help, it isn't a real friend 

> a friend who helps you when you really need help is a true friend.

3. The best recipe for making friends is to be one yourself. 

> If you want to have a genuine  friends you must get out from your shell 

> Being honest and open 

> straightforward 


Skybel, 오후 4:49
4. Having money and friends is easy. Having friends and no money is an accomplishment.

> Friendship is defined only for convenience 

EXPRESS YOURSLEF

ISSUE 07 - Friends

> I slept well , although I had a short sleep because  of the sun light. 

COMPREHENSION 

1.  A friend can't be known in Prosperity 

Prosperity  - success or wealth 

They relate this statement based on their personal experience, because it is more important to maintain the good relationship with friends not only the social convenience. 

> In my way of thinking, sincere friends could help me in times of trouble and I can express my burden and worries with them comfortably 

> If the friendship is rooted only in social convenience, it will be broken someday  


Skybel, 오후 4:19
>People often want to hide their real personality because of several personal motives 

> If you have a sincere friend you must get out from your shell first and express who you really are 


 get out from your shell - to show your true self 

2. Anyone 

3. counter examples - opposite example  

EXPRESS YOURSELF 

1. 

> Friendships have a huge impact on my mental health and happiness. 

> We can learn tons of life lessons with our friends, such as love, consideration, apology  and so on 

> This would help us become more human 

> Additionally, good friends relieve stress, provide comfort and joy, and prevent loneliness and isolation.


Skybel, 오후 4:33
2. 

> Honestly, I thought in the past it seemed to be fine with me. 

> However, lately I have realized that I am a conservative person 


3. 

> I met my best friend when we were in school. 

> I think school is the common ground for everyone to meet new people and acquaintances 

4. 

> feeling of mistrust 

> making disappointment with each others 


Skybel, 오후 4:47
5. 

> Open communication 
> Trust 

Phrases

size_t

-크기를 의미할 떄 주로 사용되는 자료형이다.

-운영체제 환경에 맞춰 가변적인 자료형을 대응하기 위해 typedef 된 자료형이다.

intptr_t, uintptr_t

-포인터의 주소를 저장하는데 사용 된다.

-다른 환경으로 이식이 가능하고, 안전한 포인터 선언 방법을 제공한다.

-시스템 내부에서 사용하는 포인터와 같은 크기다.

-포인터를 정수로 표현할 때 유용하게 사용 가능하다.

__cdecl

visual c/c++ 컴파일러에서 지원하는 calling convetion의 하나이다.

키워드 __cdecl을 사용하게 되면 stack cleanup 주체는 caller이고 

스택에 매개변수를 push 할때 매개변수 반대 순서로 스택에 저장하게 된다.

이외에도 다양한 calling convetion을 지정하는 키워드 들이 있다.

아래와 같이 visual studio에서 default calling covention을 설정하게 되면 calling convention을 생략하고 사용 가능하다.

아래와 같이 메인함수 지역변수 a,b는 주소값이 감소하는 반면

매개변수 aa,bb는 주소값이 증가하는 것을 확인할 수 있다.

하지만 64bit에서는 그렇지 않다!

이는 컴파일러가 64bit에서 스택프레임을 관리하는 방식이 다르기 때문인데 자세한 내용은 아래 문헌을 참고하자.

결론

__cdcel은 calling convertion을 지정하는 키워드 중의 하나로 __cdcel로 지정된 함수의 매개변수는 뒤에서 부터 스택에 쌓인다. 기본적으로 visual studio에 default convetion으로 등록되어 있다.

참고

std::

C++표준 이름공간 즉, namespace이다

using

using 자바의 import와  c#의 using과 비슷

타이핑 양을 줄인다.

#pragma once

링크 과정에서 header파일이 순환 참조 되는걸 막아준다.

<< insertion operator, 출력연산자

+,-와 같은 연산자 중 하나

c++에서는 프로그래머가 연산자의 동작을 바꿀 수 있다.

cout << "hi, banana" << endl;
cout << "hi, apple" << endl;
cout << "hi" << endl << "hello" << endl;  << 이와 같이도 사용 가능

점유율

활용분야

전통C++

specifics

string, 참조, 클래스, 연산자 오버로딩, 상속

모던 C++ (C++98/03)

specifics

bool 형, 벡터, 맵, 셋, 반복자, 알고리듬, 템플릿

features

-자바를 따라 가기 위한 잔재와 같은

-성능에 문제가 생기는 것들이 많아 외면을 받기도 함

최신 C++(C++11/14/17 3년 단위로 나오고 있음)

specifics

비정렬 맵 및 비정렬 셋, 

defualt/delete/final/override

키워드,람다,유니크,

포인터,공유포인터

features

성능에 문제 없게 하기 위해 노력 함

EXPRESS YOURSLEF

ISSUE 06 - Special Days

USEFUL EXPRESSION 

1. 

> mother's sacrifice for their children's happiness 

2.   

> It's a humorous sentence 

> This is an ironic statement, I think all spouses remember their wives special days, so this means forgetting someone's special day once, and remembering  it on second time around would to be more especial 

I will ask an apology and explained the reason ~~


Skybel, 오후 4:20
3. Men can accept their aging process easier than women 

> I can't agree with this statement because I don't know how women think 

> Nowadays, women are becoming more proud of themselves 

4. diplomatic - well respected personality 

He is just saying flattering words  ~

5. Guests complimentary remarks about the party is important ~

EXPRESS YOURSLEF

ISSUE 07 - Friends

Skybel, 오후 4:40
Issue 7 

FRIENDS 

No mispronounce words 

> This paragraph says  sincere friendship is worth having 

> Some friends are often mere lip service 

> genuine connection 


Skybel, 오후 4:48
Are your childhood friends those you have strongest bonds with are still in contact with you?

EXPRESS YOURSLEF

ISSUE 06 - Special Days

Issue 6 

Special Days

- This paragraph says people celebrate various special occasions. 

- It also mentions what people do

symbolize - meaning 

What does special day symbolize? 

It symbolizes various reasons for example marriage day/anniversary it symbolizes love// affections  

Independence day 

- it symbolizes freedom from colonizers 

Who are national figures? 

Heroes in the past 

- Her heroic sacrifice inspired many Koreans. 

activist 

She fought bravely 

Vocabulary

distinctive  - special or different characteristic 

commemorate  - honor and celebrate 

celebrate - enjoy the event or remember the event 

fragmented - break into pieces or become away 

scattered - being away or being apart from a group 


Skybel, 오후 4:30
Comprehension 

2. Just bow, and share special dishes 


Skybel, 오후 4:35
EXPRESS YOURSELF 

1. Wishing luck then give money 

2. New Year's resolutions


 50분 22초
 50분 50초