프로그래머휴식처

얼마전 새로운 사실을 알게된것 같다.

Effective C++ 에서 봤던대로 초기화는 초기화 리스트에서 진행해야한다. 그렇게 봤기 떄문이다.

그렇기에 최대한 모든 맴버 변수를 초기화 리스트에 넣었다. 하지만 의문이 든것도 사실이다.

맴버 변수가 객체로 이루어져있으면 초기화 리스트에서 진행하는게 맞아보였다 .하지만 기본 자료형은 어떨까?

단순 자료형만 있고 이것을 그냥 0으로 초기화하는것인데 이게 차이가 있을까 하는것이였다. 물론 객체가 존재하면 얘기는 다르겠지만 단순 자료형만으로 이루어진 클래스일때는 어떨까 하는 것이였다.

그러던중 어셈블리로 코드를 볼 기회가 생겼고 그것에서 기본 자료형만 있을때는 차이가 없다는 결과가 나왔다.

class A
{
    public:
        A():m_Num(0),
        m_double(0.0)
        {}

   private:
        int m_Num;
        double m_double;
};

class B
{
    public:
        B()
        {
            m_Num = 0;
            m_double = 0.0;
        }
   private:
        int m_Num;
        double m_double;
};

코드는 위와 같이 구성을 했고 해당 부분을 어셈블리로 보면

this$ = 8
A::A(void) PROC                                  ; A::A, COMDAT
        mov     QWORD PTR [rsp+8], rcx
        mov     rax, QWORD PTR this$[rsp]
        mov     DWORD PTR [rax], 0
        mov     rax, QWORD PTR this$[rsp]
        xorps   xmm0, xmm0
        movsd   QWORD PTR [rax+8], xmm0
        mov     rax, QWORD PTR this$[rsp]
        ret     0
A::A(void) ENDP                                  ; A::A

this$ = 8
B::B(void) PROC                                  ; B::B, COMDAT
        mov     QWORD PTR [rsp+8], rcx
        mov     rax, QWORD PTR this$[rsp]
        mov     DWORD PTR [rax], 0
        mov     rax, QWORD PTR this$[rsp]
        xorps   xmm0, xmm0
        movsd   QWORD PTR [rax+8], xmm0
        mov     rax, QWORD PTR this$[rsp]
        ret     0
B::B(void) ENDP                                  ; B::B

위처럼 결과값이 같은것으로 나왔다. 혹시나 해서 객체로도 테스트를 해보았지만 결과는 초기화 리스트를 써야한다는 것이였다.

이걸로 결과가 차이가 없다는걸 확인하긴 하였지만 그래도 두가지 방식을 사용하면 햇갈릴수 있으므로 초기화 리스트를 쓰는게 나은 선택일 것이다.

std::pair 는 하나의 변수에 두개의 데이터 타입을 저장할떄 사용한다. 

기본적인 형식은 아래와 같다.

std::pair<타입1, 타입2> 변수명{타입 1 값, 타입2 값};

하지만 변수 선언으로만 사용하기엔 뭔가 부족해 보인다. 그렇다면 어떤게 좋을까? 예전에 값을 리턴할때 두가지 형식을 한번에 리턴하면 좋겠다는 생각이 든 적이 있다. 

현재 함수가 올바르게 동작된지 확인가능한 boolean  과 함수의 결과값을 동시에 ..

다른 방식으로도 가능한 방법은 많다 하지만 그때는 이 방식이 있으면 좋지 않을까 생각했고 그방식을 std::pair로 구현할 수 있다.

//answer, Errorcode
std::pair<int, int> TestDivide(int a, int b)
{
	if(b == 0)
    		return std::make_pair<int, int>(a/ b, -1);
	return std::make_pair<int, int>(a / b, 0);
}

int main()
{
	auto pair_test = TestDivide(5, 2);
    
    
    //호출 형식
    std::cout << pair_test.first << std::endl;
    std::cout << pair_test.second << std::endl;
}

std::tuple은  std::pair와 비슷하지만 여러개의 인자를 설정할수 있고 변수로도 선언 할수 있고 그것을 리턴 받는 식으로 사용할수 있다. 

std::tuple<int, int, int> get_content()
{
	return std::make_tuple(0, 0, 1);
}

하지만 받는 형식은 여러가지가 있다.

int main(
	auto auto_tuple = get_content();

	std::cout << std::get<0>(auto_tuple) << std::endl;
	std::cout << std::get<1>(auto_tuple) << std::endl;
	std::cout << std::get<2>(auto_tuple) << std::endl;

	int nInt1, nInt2, nInt3;

	std::tie(nInt1, nInt2, nInt3) = get_content();

	//C++17
	auto [nNum1, nNum2, nNum3] = get_content();
   
   return 0;
    
  }

모든 방식이 되지만 개인적으로 실전에서 사용은 안해서 뭐가 좋을지는 아직 모르겠다.

C++11 의 알기 쉬운 키워드로 auto  가 있다. 하지만 C++11에서는 데이터를 선언할때만 auto를 쓸수 있고 함수반환값에서는 사용이 안되었다. 

하지만 C++14로 오면서 이부분이 해결되었다.

int TestNum()			//C++11
{
	return 10;
}

auto TestNumAuto()		//C++14
{
	return 10;
}

위와같이 return 타입을 auto로 하여도 컴파일러가 데이터 타입을 유추하여 타입을 지정한다.

하지만 몇가지 오류는 조심해야한다.

auto TestErr(int nNum)		// return 타입이 int 타입과 double 타입이 존재하여 오류
{
	if(nNum > 10)
    	return 0;
	return 0.0;
}


auto Recursion(int nNum)	//재귀 함수 호출시 첫 return 에서 데이터 형식을 유추 할수없어 오류
{
	if(nNum > 10)
    	return Recursion(nNum - 1);
    return nNum;    
}

decltype는 주어진 변수의 타입을 알려주는 키워드로 기본적인 구조는 다음과 같다.

	auto a = 100;		
	auto* b = &a;
	auto k = 100;

	decltype(a) c = 50;		//변수 a의 타입인 int
	decltype(b) d = &k;		//변수 b의 타입인 int*

해당 키워드는 auto로 return 되어 데이터 형식의 구분이 어려울때 사용하면 유용하게 쓸수 있을꺼 같다.