C++ auto 키워드: 예제로 설명하는 타입 추론

타입은 컴파일러가 고르게 하라

이전 페이지에서 모든 C++ 변수가 고정된 타입 - int, double, std::string 등 - 을 가진다는 것을 보았습니다. 그 타입을 손으로 적는 것은 int count = 0; 정도면 괜찮지만, 타입이 길어지면 지저분해집니다. auto 키워드(C++11 이후)는 컴파일러가 여러분이 대입하는 값으로부터 타입을 추론 하게 해주므로, 값을 한 번만 적으면 나머지는 컴파일러가 채워줍니다.

#include <iostream>
using namespace std;

int main() {
    auto count = 0;        // int
    auto price = 3.99;     // double
    auto letter = 'A';     // char
    auto greeting = "hi";  // const char*

    cout << count << " " << price << " " << letter << " " << greeting << "\n";
    return 0;
}

핵심 개념: auto는 동적 타이핑이 아닙니다. 각 변수는 여전히 컴파일 시점에 고정되는 하나의 구체적인 타입을 가집니다. auto는 단지 그것을 적는 수고를 덜어줄 뿐입니다.

auto가 제 몫을 하는 이유

짧고 명백한 타입이라면 auto count = 0;과 int count = 0;은 똑같이 읽기 좋습니다. auto가 진짜로 효과를 보는 곳은 길고 반복적인 타입 이름 - 표준 라이브러리의 컨테이너와 반복자에서 나오는 종류 - 에서입니다.

장황한 버전과 auto 버전을 비교해 보세요.

// auto 없이 - 사실상 타입을 두 번 적는 셈
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// auto로 - 컴파일러는 이미 타입을 안다
auto it = scores.begin();

둘 다 정확히 같은 반복자 타입을 선언합니다. 두 번째 것이 읽기 더 쉽고, 나중에 scores를 다른 컨테이너로 바꿔도 어긋나지 않습니다.

완전한 프로그램 안에서 보면 다음과 같습니다.

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

int main() {
    vector<pair<string, int>> scores = {{"Ada", 90}, {"Boris", 85}};

    for (auto it = scores.begin(); it != scores.end(); ++it) {
        cout << it->first << ": " << it->second << "\n";
    }
    return 0;
}

범위 기반 for 루프에서의 auto

auto를 가장 흔히 만나는 곳은 범위 기반 for 루프입니다. 요소 타입을 손으로 적고 싶은 경우는 거의 없으며, auto를 어떻게 적느냐에 따라 복사본을 얻을지 참조를 얻을지가 결정됩니다.

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

int main() {
    vector<string> names = {"Ada", "Boris", "Rosa"};

    // const auto& - 읽기 전용, 복사 없음. 읽을 때의 일반적인 기본값.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

여러분이 보게 될 세 가지 변형과 각각의 의미:

• for (auto x : v) - x는 각 요소의 복사본입니다. int에는 저렴하지만 큰 객체에는 낭비입니다.
• for (auto& x : v) - x는 참조입니다. 요소를 제자리에서 수정할 수 있습니다.
• for (const auto& x : v) - x는 읽기 전용 참조입니다. 읽기만 하면 될 때 사용하세요.

다음 프로그램은 auto&를 통해 컨테이너를 수정합니다.

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

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto& n : nums) {
        n *= 10;        // 실제 요소를 수정한다
    }

    for (const auto& n : nums) {
        cout << n << " ";   // 10 20 30
    }
    cout << "\n";
    return 0;
}

함정: 그 루프에서 for (auto n : nums)(& 없이)라고 적으면 n *= 10은 조용히 복사본만 바꾸고 nums는 건드리지 않습니다. 컴파일러는 경고하지 않습니다. 루프는 그냥 아무 쓸모 있는 일도 하지 않을 뿐입니다.

auto가 떼어내는 것

평범한 auto는 값으로 전달되는 함수 매개변수와 똑같은 방식으로 타입을 추론합니다. 즉, 최상위 const, 참조, volatile을 떼어냅니다. 이는 달리 요청하지 않는 한 auto가 항상 새롭고 수정 가능한 복사본을 준다는 뜻입니다.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // 타입은 int, const int가 아니다
    copy = 100;             // 완전히 합법 - const가 떼어내졌다

    cout << original << " " << copy << "\n";  // 42 100
    return 0;
}

const를 유지하거나 복사를 피하고 싶다면 한정자를 직접 붙입니다. 요령은 어떤 타입을 꾸미듯이 auto를 똑같이 꾸미는 것입니다.

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

int main() {
    string name = "Ada";

    const auto& ref = name;   // const std::string& - 복사 없음, 읽기 전용
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // 오류: ref는 const다
    return 0;
}

그러니 auto는 기본 타입을 추론하고, &, const, *는 그 위에 더하는 손잡이입니다. auto가 타입이고, const auto&는 그것에 대한 읽기 전용 참조입니다.

흔한 실수와 함정

auto는 타이핑 수고를 없애주지, 타입을 이해할 필요까지 없애주지는 않습니다. 초보자를 잡는 몇 가지 함정이 있습니다.

반드시 초기화해야 합니다. auto는 빈 선언에서는 추론할 것이 없으므로 이것은 명백한 컴파일 오류입니다.

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // 괜찮음

정수 리터럴은 int이지 double이 아닙니다. auto half = 1 / 2;는 int를 추론하고 0을 저장합니다. 1 / 2는 auto가 그것을 보기 전에 정수 나눗셈이기 때문입니다. 타입은 값을 따라갑니다.

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // 정수 나눗셈 -> 0
    auto right = 1.0 / 2;    // double -> 0.5

    cout << wrong << " " << right << "\n";  // 0 0.5
    return 0;
}

auto는 참조를 떼어냅니다 - 댕글링 복사 사고를 조심하세요. 함수가 참조를 반환하는데 이를 평범한 auto로 받으면 복사본을 얻게 되며, 이는 뜨거운 루프에서 때때로 진짜 성능 버그가 됩니다(반복마다 큰 객체의 깊은 복사). "보되 가져가지는 마라"라는 뜻일 때는 const auto&에 손을 뻗으세요.

중요할 때는 타입을 숨기지 마세요. auto result = compute();는 compute의 반환 타입이 문맥에서 명백할 때는 괜찮지만, 읽는 사람이 result가 실제로 무엇인지 찾아 헤매야 한다면 타입을 적어주는 편이 더 친절한 선택일 수 있습니다. auto는 잡음을 줄이기 위한 것이지, 의도를 숨기기 위한 것이 아닙니다.

다음: 상수와 const

이제 auto가 유지를 요청하지 않는 한 의도적으로 const를 떼어낸다는 것을 보았습니다. 그러면 자연스러운 질문이 떠오릅니다. const는 실제로 무엇을 보장하며, 애초에 언제 값을 변경 불가로 표시해야 할까요? 다음 페이지에서는 const, 상수 표현식, 그리고 "기본적으로 const로 만들어라"가 왜 C++에서 가장 유용한 습관 중 하나인지를 깊이 파고듭니다.