C++11 키워드) nullptr(널포인터), auto(오토), decltype(디클타입), lvalue(좌측값)와 rvalue(우측값)

nullptr (널포인터)

- 포인터 타입의 상수로, 포인터가 어떤 유효한 메모리 주소도 가리키지 않음을 명시적으로 표현한다.

- 포인터가 유효한 메모리 주소를 가리키지 않을 때 사용하는 값으로, 0이나 NULL을 대신하여 사용된다

- nullptr를 사용하면 함수 오버로딩에서 명확하게 타입을 구분할 수 있다. 이는 NULL이 정수형으로 취급되기 때문에 발생할 수 있는 혼동을 피할 수 있다.

 

#include <iostream>

int main() {
    int* ptr = nullptr;

    if (ptr == nullptr) {
        std::cout << "Pointer is null" << std::endl;
    }

    // nullptr와의 비교는 타입 안전하게 수행됩니다.
    if (ptr != nullptr) {
        std::cout << "Pointer is not null" << std::endl;
    }

    return 0;
}

- ptr이 nullptr과 비교할 때, 비교 연산자는 포인터 타입에 맞게 안전하게 수행된다.

  이는 nullptr가 포인터 타입과 명확히 연관되어 있기 때문이다.

 

 

 

auto (오토)

- 타입 선언을 간소화하여 코드를 간결하게 할 수 있다.

- 복잡한 타입이나 템플릿 사용 시 안전하게 타입을 추론한다

- 반복자나 복잡한 타입의 변수를 쉽게 다룰 수 있다.

- auto를 사용하면 변수의 타입을 명시적으로 선언하지 않고, 변수의 초기값에 따라 타입을 자동으로 추론한다.

- 변수의 타입을 컴파일러가 자동으로 추론하도록 허용한다. 이를 통해 코드의 가독성을 높이고, 타입 선언을 간소화할 수 있다. auto는 특히 복잡한 타입이나 템플릿 사용 시 코드의 유지보수성을 향상시키는 데 도움을 준다.

 

 

<주로 사용되는 상황>

 

1. 반복자 (Iterators) 사용

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // auto를 사용하여 반복자의 타입을 자동으로 추론
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;

- auto it = vec.begin();에서 it의 타입은 std::vector<int>::iterator로 자동으로 추론됨

- 이를 통해 반복자의 타입을 명시적으로 선언할 필요가 없음

 

 

2. 복잡한 타입의 변수 선언

#include <iostream>
#include <map>
#include <string>

int main() {
    std::map<std::string, int> my_map;
    my_map["apple"] = 3;
    my_map["banana"] = 5;

    // auto를 사용하여 맵의 요소를 반복
    for (auto& pair : my_map) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

- auto& pair : my_map에서 pair의 타입은 std::pair<const std::string, int>로 자동으로 추론됨

- 복잡한 타입을 명시적으로 선언할 필요가 없어 코드가 간결해짐

 

 

3. 함수 반환 타입

#include <iostream>
#include <vector>

auto getVector() -> std::vector<int> {
    return std::vector<int>{1, 2, 3, 4, 5};
}

int main() {
    auto vec = getVector(); // vec는 std::vector<int>로 추론됨

    for (const auto& element : vec) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

- auto getVector() -> std::vector<int> 구문에서 함수 getVector의 반환 타입을 auto와 후행 반환 타입 표기법으로 지정

- auto vec = getVector();에서 vec의 타입은 std::vector<int>로 자동으로 추론됨

 

 

auto의 단점

• 명확성: 타입 추론이 예상과 다를 수 있으며, 초기값이 필요하다
• 가독성: 과도한 사용은 코드의 가독성을 저하시킬 수 있다.

 

 

 

decltype (디클타입)

- 변수나 표현식의 타입을 추론하는 경우 사용됨

- 변수 선언에서 타입을 명시적으로 지정할 필요 없이, 표현식의 타입을 자동으로 추론할 수 있게 해준다.

- 이 기능은 타입 추론을 통해 더 유연하고 안전한 코드 작성을 지원

- auto와의 차이점으로는, decltype는 표현식의 타입을 추론하여 변수나 함수의 타입을 자동으로 결정한다는 점이다.

 

decltype(expression) variable_name;

: expression의 타입이 variable_name에 할당된다.

 

 

1. 변수의 타입 추론

#include <iostream>

int main() {
    int x = 10;
    decltype(x) y = 20;  // y의 타입은 int로 추론됨

    std::cout << "y: " << y << std::endl;

    return 0;
}

• decltype(x) y = 20;에서 decltype(x)는 x의 타입을 추론하므로, y의 타입은 int가 된다

 

2. 함수의 반환 타입 추론

#include <iostream>

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

decltype(add(1, 2)) subtract(int a, int b) {
    return a - b;
}

int main() {
    auto result = subtract(10, 5);  // result의 타입은 int로 추론됨
    std::cout << "Result: " << result << std::endl;

    return 0;
}

• decltype(add(1, 2))는 add 함수의 반환 타입을 추론. subtract 함수는 add와 같은 반환 타입을 가지므로, result는 int 타입으로 추론된다

 

3. 복잡한 표현식의 타입 추론

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // auto를 사용하여 반복자 타입 추론
    auto it = vec.begin();

    // decltype을 사용하여 반복자 타입 추론
    decltype(vec.begin()) it2 = vec.begin();

    std::cout << "Using auto: " << *it << std::endl;
    std::cout << "Using decltype: " << *it2 << std::endl;

    return 0;
}

• auto it = vec.begin();와 decltype(vec.begin()) it2 = vec.begin();에서 it와 it2는 std::vector<int>::iterator 타입으로 추론됨

 

4. 함수와 람다 표현식의 타입 추론

#include <iostream>
#include <functional>

int main() {
    // 람다 표현식 정의
    auto lambda = [](int a, int b) { return a + b; };

    // decltype을 사용하여 람다의 타입 추론
    decltype(lambda) another_lambda = [](int a, int b) { return a - b; };

    std::cout << "Lambda result: " << lambda(5, 3) << std::endl;
    std::cout << "Another lambda result: " << another_lambda(5, 3) << std::endl;

    return 0;
}

• decltype(lambda)는 람다 표현식의 타입을 추론. another_lambda는 동일한 타입의 람다로 정의됨

 

 

 

decltype(x)와 decltype((x))의 차이

 

은 C++에서 표현식의 타입을 추론할 때 사용되지만, 이 두 가지는 타입 추론에 있어 중요한 차이점이 있다.

이 차이점은 특히 변수의 타입이 참조인 경우나 표현식이 복합적인 경우에 중요한 역할을 함

 

1. decltype(x):
   • x가 참조 타입이 아니면 x의 타입을 그대로 추론합니다.
   • x가 참조 타입이 아니면 decltype(x)는 x의 실제 타입을 반환합니다.
2. decltype((x)):
   • x가 참조 타입이라면, decltype((x))는 참조 타입을 포함합니다.
   • x가 참조 타입이 아니라면, decltype((x))는 x를 괄호로 감싸서 표현식으로 취급하므로 x의 타입이 참조가 아닌 타입으로 추론됩니다.

정리:

• decltype(x)는 단순히 변수 x의 타입을 추론
• decltype((x))는 x를 표현식으로 다루며, x의 참조 타입을 포함하는 경우가 있음

 

 

 

lvalue와 rvalue

 

lvalue:

• 메모리의 특정 위치를 가리키는 표현식으로, 그 위치에서 값을 읽거나 쓸 수 있다. 대입 연산자의 좌측에 위치 
  • 위치: 메모리의 특정 위치를 가리킴.  값을 읽고 쓸 수 있는 위치 (좌측에 위치).
  • 예: 변수, 배열의 요소.
  • 예시: int x = 5; x = 10;에서 x는 lvalue
  • 메모리의 위치를 참조할 수 있는 값으로, 주로 변수나 객체의 멤버를 나타낸다. 

 

rvalue:

• 임시 값을 나타내는 표현식으로, 그 값을 읽을 수만 있으며, 직접적으로 값을 쓸 수는 없다.대입 연산자의 우측에 위치
  • 위치: 임시(일시)적인 값. 메모리 위치가 없고, 값만 존재한다. 임시적인 값 (우측에 위치).
  • 예: 리터럴, 연산 결과.
  • 예시: x + 5 또는 10은 rvalue
  • 임시적이며 메모리 위치를 가지지 않는 값으로, 주로 상수나 연산 결과를 나타낸다.

int x = 10; // 10은 rvalue 
x = x + 5; // x + 5는 rvalue