• 목차
• 이전 장으로
• 다음 장으로

제 3 장: C++ 첫 만남

3.1: 눈에 띄는 C와의 차이

3.1.1: `const' 키워드의 사용

const 키워드는 인자나 변수의 값이 불변임을 알리는 수식어이다. 다음 예제에서 ival 변수의 값을 바꾸려고 하지만 실패한다.

    int main()
    {
        int const ival = 3;     // 상수 int
                                // 3으로 초기화

        ival = 4;               // 할당하면
                                // 에러 메시지 출력
    }

const로 선언된 변수는 C와 대조적으로 다음 예제와 같이 배열의 크기를 지정할 수 있다.

    int const size = 20;
    char buf[size];             // 20 개의 문자 크기

    char const *buf;

다음 선언에서는

    char *const buf;

마지막으로 다음 선언도 역시 가능하다.

    char const *const buf;

const 키워드의 위치에 대하여 제일 원칙은 다음과 같다. 키워드 왼쪽에 나타나는 것은 무엇이든 바꿀 수 없다.

단순하지만 이 제일 규칙을 사용한다. 예를 들어, 비야네 스트롭스트룹(Bjarne Stroustrup)의 언급에 의하면 (참조 http://www.stroustrup.com/bs_faq2.html#constplacement):

"const"를 유형 앞에 두어야 할까 아니면 뒤에 두어야 할까?

본인은 앞에 놓지만 그것은 개인의 취향 문제이다. "const T"와 "T const"는 언제나 (둘 다) 허용되며 동등하다. 예를 들어:

    const int a = 1;        // 좋다.
    int const b = 2;        // 역시 좋다.

생각건대 첫 번째 버전이 좀 더 프로그래머에게 명료할 것이다 (``더 관용구적이다'').

선언이나 정의는 (const가 있든 없든) 언제나 변수나 함수 식별자로부터 유형 식별자 쪽으로 거슬러 읽어야 한다.

``Buf는 상수 문자를 가리키는 상수 포인터이다''

    char const *buf;

    int main()
    {
        char const *buf = "hello";

        ++buf;                  // 컴파일러가 수락
        *buf = 'u';             // 컴파일러가 거부
    }

마샬 클라인(Marshall Cline)의 C++ FAQ를 보면 비슷한 문맥에 같은 규칙을 적용하는 것을 볼 수 있다 (문단 18.5):

[18.5] "const Fred* p", "Fred* const p" 그리고 "const Fred* const p" 사이의 차이점은 무엇인가?

포인터 선언을 오른쪽에서 왼쪽으로 읽을 필요가 있다.

1. 변수의 이름에서 읽기를 시작한다.
2. 선언의 끝이나 (짝이 되는) 닫는 괄호에 도달할 때까지 최대한 읽는다.
3. 읽기를 시작한 곳으로 되돌아 온다. 그리고 선언의 시작이나 여는 괄호에 도달할 때까지 거꾸로 읽는다.
4. 열린 괄호에 도달했다면 2 단계에서 이전에 멈추었던 괄호를 넘어서 계속 읽는다.

    char const *(* const (*(*ip)())[])[]

                             ip          변수의 이름부터 시작한다.
                                             'ip'는

                             ip)         닫는 괄호를 만난다. 거꾸로 간다.
                             -->

                           (*ip)        짝이 되는 여는 괄호를 발견한다.
                           <-                '~를 가리키는 포인터이다'

                           (*ip)())      다음으로 짝 없는 닫는 괄호를 만난다.
                                -->          '함수를 (인자를 
                                              기대하지 않음)'

                         (*(*ip)())      짝이 되는 열린 괄호를 찾는다.
                         <-                  '~를 포인터로 돌려준다'

                         (*(*ip)())[])   다음의 닫는 괄호를 만난다.
                                   -->       '배열의'

                (* const (*(*ip)())[])   짝이 되는 열린 괄호를 찾는다.
                <--------                    '~를 가리키는 상수 포인터이다'

                (* const (*(*ip)())[])[] 끝까지 읽는다.
                                      ->     '배열의'

    char const *(* const (*(*ip)())[])[] 나머지를 거꾸로 읽는다.
    <-----------                             '상수 문자를 가리키는 포인터이다'

3.1.2: 이름공간

이름공간은 제 4 장에 더 자세하게 다룬다. 지금은 대부분의 컴파일러가 명시적으로 std라는 표준 이름공간의 선언을 요구한다는 사실을 지적하는 것으로 만족하겠다. 그래서 따로 표시하지 않는 한, 모든 예제는 이제 묵시적으로 다음 선언을 사용한다.

        using namespace std;

3.1.3: 영역 지정 연산자 ::

    #include <stdio.h>

    double counter = 50;                // 전역 변수

    int main()
    {
        for (int counter = 1;           // 이 변수는 
             counter != 10;             // 지역 변수를 가리킨다.
             ++counter)
        {
            printf("%d\n",
                    ::counter           // 전역 변수
                    /                   // 나누기
                    counter);           // 지역 변수
        }
    }

3.1.4: `cout'과 `cin' 그리고 `cerr'

• cout은 stdout,
• cin은 stdin,
• cerr은 stderr와 비교된다.

    #include <iostream>

    using namespace std;

    int main()
    {
        int     ival;
        char    sval[30];

        cout << "숫자를 입력하시오:\n";
        cin >> ival;
        cout << "문자열을 입력하시오:\n";
        cin >> sval;

        cout << "숫자: " << ival << "\n"
                "문자열: " << sval << '\n';
    }

• 표준 스트림은 iostream 헤더 파일에 선언되어 있다. 이 책의 예제에서 이 헤더 파일은 명시적으로 언급하지 않는다. 그렇지만 (직접적이든 간접적이든) 반드시 포함해야 이 스트림을 사용할 수 있다. using namespace std; 구문을 사용하듯이 표준 스트림이 사용되는 예제라면 반드시 #include <iostream>이 있을 것이라고 예상해야 한다.
• 스트림 cout과 cin 그리고 cerr는 이른바 클래스 유형의 변수이다. 이런 변수들을 객체라고 부른다. C++에서 널리 사용되는 클래스는 제 7장에 더 자세하게 논의한다.
• cin 스트림은 데이터를 스트림으로부터 추출하여 변수에 그 정보를 복사한다 (위의 예제에서는 ival에 복사함). 추출 연산자를 사용한다 (> 문자 두 개 즉, >>). 여기에서 보여주는 것처럼 C++에서 어떻게 연산자들이 이미 정의된 방식과 다르게 행위할 수 있는지 나중에 설명하겠다. 함수 중복정의는 이미 언급했다. C++의 연산자 역시 여러 정의가 있는데, 이를 연산자 중복정의라고 부른다.
• cin과 cout 그리고 cerr를 조작하는 연산자들은 다른 유형의 변수도 조작할 수 있다 (즉, >> 그리고 <<). 위의 예제에서 cout << ival는 결과적으로 정수 값을 인쇄한다. 반면에 cout << "Enter a number"는 문자열을 인쇄한다. 그러므로 연산자의 행위는 공급된 변수의 유형에 따라 달라진다.
• 추출 연산자 (>>)는 텍스트 스트림으로부터 그의 값을 `추출함으로써' 이른바 유형에 안전하게 변수를 할당한다. 추출 연산자는 추출될 값 앞에 있는 모든 공백 문자들을 무시하고 건너뛰는 경우가 보통이다.
• 특수한 상황에는 특수 심볼 상수가 사용된다. 한 줄은 "\n"이나 '\n'을 삽입하면 끝난다. 그러나 endl 심볼을 삽입하면 줄을 끝낸 후에 스트림의 내부 버퍼를 비운다. 그래서 좀 더 효율적인 코드를 위해 endl은 피하고 '\n'을 선호하기도 한다.

새-스타일의 스트림을 멀리하고 프로그램은 여전히 printf와 scanf 같은 구형-스타일의 함수를 사용할 수도 있다. 두 가지 스타일을 혼용해 사용할 수도 있다. 그러나 스트림은 여러 장점이 명백하다. 많은 C++ 프로그램은 완벽하게 구형 스타일의 C 함수들을 대신하여 사용한다. 스트림을 사용하여 얻는 장점은 다음과 같다.

• 삽입 연산자와 추출 연산자를 사용하면 유형에 안전하다. printf와 scanf에 사용되는 형식 문자열은 인자에 엉터리 형식 지정자를 정의할 수도 있다. 그럼에도 컴파일러가 경고조차 할 수 없는 경우가 있다. 대조적으로 cin과 cout 그리고 cerr에서는 컴파일러가 인자를 점검해 준다. 결과적으로 int 인자를 형식 문자열에 맞게 문자열 인자가 나타나야 할 곳에 배치해서 에러를 일으키는 일은 불가능하다. 스트림은 형식화 문자열이 필요하지 않다.
• printf 함수와 scanf 함수는 (형식화 문자열을 사용하는 다른 함수들도 마찬가지로) 사실 알고보면 실행 시간에 통역이 되는 미니-언어를 구현한 것이다. 대조적으로 C++ 컴파일러는 인자가 스트림으로 주어지면 입력을 수행할지 출력을 수행할지 정확하게 알고 있다. 여기에 미니 언어 같은 것은 전혀 없다.
• 삽입 연산자와 추출 연산자는 확장이 가능하다. 스트림이 처음부터 정의되어 있지 않더라도 존재하지 않는 클래스의 객체들을 스트림으로 삽입하거나 스트림으로부터 추출할 수 있다. printf 함수에 사용된 미니 언어는 확장이 불가능하다.
• 스트림의 문맥에서 좌우-쉬프트 연산자의 사용은 또다른 C++의 가능성을 보여준다. 연산자가 특정한 문맥에서 수행해야 할 행위를 연산자 중복정의로 재정의할 수 있다. C 세계에서 왔다면 연산자 중복정의가 약간 생소할 수 있지만 시간이 좀 지나면 이렇게 중복정의 연산자들이 편안하게 느껴질 것이다.
• 스트림은 작동해야 하는 매체(미디어)에 의존하지 않는다. (이 시점에서는 약간 뜬구름 같은 이야기처럼 들리겠지만) 이 언급은 같은 코드를 전혀 수정하지 않고 어떤 종류의 장치에도 인터페이스를 붙일 수 있다는 뜻이다. 스트림을 사용하는 코드는 장치가 디스크 위의 파일일 경우에도 사용할 수 있다. 인터넷 연결, 디지털 카메라, DVD 장치, 인공위성 연결, 등등 무엇이든 사용할 수 있다. 스트림으로 코드는 작동해야 할 장치에 의존하지 않아도 된다. 덕분에 새로운 상황에 같은 코드를 재사용할 수 있으며 더욱 손쉽게 유지관리할 수 있다.

3.2: 구조체에 포함되는 함수

아래의 조각 코드를 보면 구조체에 사람의 이름과 주소를 담을 데이터 필드가 있다. print 함수가 구조체 정의에 포함되어 있다.

    struct Person
    {
        char name[80];
        char address[80];

        void print();
    };

    void Person::print()
    {
        cout << "Name:      " << name << "\n"
                "Address:   " << address << '\n';
    }

다음과 같이 struct Person을 사용할 수 있다.

    Person person;

    strcpy(person.name, "Karel");
    strcpy(person.address, "Marskramerstraat 33");
    person.print();

3.2.1: 데이터 은닉: public과 private 그리고 class

C++는 데이터 은닉과 관련하여 private(비밀)과 protected(보호) 그리고 public(공개) 세 개의 키워드가 있다. 이런 키워드를 구조체의 정의에 사용할 수 있다. public 키워드는 다음에 오는 구조체의 모든 필드에 모든 코드가 접근할 수 있도록 허용한다. private 키워드는 구조체 자체에서만 잇따르는 필드에 접근할 수 있도록 허용한다. protected 키워드는 제 13장에 다룬다. 지금의 연구 주제에서 약간 벗어나기 때문이다.

따로 명시적으로 언급하지 않는 한, 구조체에서 모든 필드는 공개이다. 이 지식을 활용하면 struct Person을 다음과 같이 확장할 수 있다.

    struct Person
    {
        private:
            char d_name[80];
            char d_address[80];
        public:
            void setName(char const *n);
            void setAddress(char const *a);
            void print();
            char const *name();
            char const *address();
    };

    Person fbb;

    fbb.setName("Frank");         // 좋다. setName은 공개 함수이기 때문이다.
    strcpy(fbb.d_name, "Knarf");  // 에러이다. x.d_name이 비밀이기 때문이다.

struct Person의 멤버 함수의 두 가지 예를 아래에 보여준다.

    void Person::setName(char const *n)
    {
        strncpy(d_name, n, 79);
        d_name[79] = 0;
    }

    char const *Person::name()
    {
        return d_name;
    }

데이터 은닉의 개념을 보여주는 또다른 예는 다음과 같다. 데이터를 메모리에 보관하는 멤버 함수의 대안으로서 데이터를 파일에 저장하는 멤버 함수를 특징으로 하는 라이브러리를 개발할 수 있다. Person 구조체를 메모리에 저장하는 프로그램을 디스크에 저장하는 프로그램으로 변환하려면 특별한 변경이 필요하지 않다. 프로그램을 다시 컴파일해 새 라이브러리에 링크하고 나면 메모리 저장에서 디스크 저장으로 변환된다. 이 예제는 데이터 은닉보다 더 넓은 개념을 보여준다. 캡슐화(encapsulation)를 보여준다. 데이터 은닉은 일종의 캡슐화이다. 일반적으로 캡슐화는 프로그램에서 서로 다른 부분들 사이의 겹합도를 줄여준다. 이 덕분에 결과로 나온 소프트웨어의 재사용성과 유지관리성이 크게 개선된다. 구조체에 실제 저장 매체를 캡슐화해 넣으면 그 구조를 사용하는 프로그램은 실제 저장 매체에 얽매이지 않게 된다.

데이터 은닉은 구조체를 사용하여 구현할 수 있지만 대신에 (거의 언제나) 클래스가 훨씬 더 자주 사용된다. 클래스는 일종의 구조체이다. 단, 클래스는 비공개 접근이 기본이고 구조체는 공개 접근이 기본이다. 그러므로 class Person의 정의는 위에 보여준 정의와 동일하다. 단, class 키워드가 struct 키워드를 대신했고 처음의 private: 절을 생략할 수 있다. 클래스 이름의 철자 규칙은 (Person처럼) 대문자로 시작하고 나머지는 소문자를 사용하라고 제안한다 (그리고 프로그래머가 정의하는 다른 유형의 이름들도 마찬가지로 이 철자 규칙을 따르기를 제안한다).

3.2.2: C 구조체와 C++ 구조체

    /* 구조체 PERSON의 정의    C로 구현됨   */
    typedef struct
    {
        char name[80];
        char address[80];
    } PERSON;

    /* PERSON 구조체를 조작하기 위한 함수들 */

    /* 이름과 주소로 필드를 초기화한다    */
    void initialize(PERSON *p, char const *nm,
                       char const *adr);

    /* 정보를 인쇄한다    */
    void print(PERSON const *p);

    /* etc..    */

C++는 관련 함수의 선언을 구조체나 클래스의 정의 안에 배치한다. 어느 구조체가 관련되어 있는지 알려주는 인자는 더 이상 사용하지 않는다.

    class Person
    {
        char d_name[80];
        char d_address[80];

        public:
            void initialize(char const *nm, char const *adr);
            void print();
            // etc..
    };

    PERSON x;

    initialize(&x, "some name", "some address");

    Person x;

    x.initialize("some name", "some address");

3.3: C 문법에 추가된 것들

3.3.1: 참조

    int int_value;
    int &ref = int_value;

    ++int_value;
    ++ref;

참조는 C++에서 중요한 기능이다. 변경 가능한 인자를 함수에 건네는 도구로 사용된다. 예를 들어 표준 C에서는 함수가 그의 인자의 값을 5만큼 늘리고 아무것도 돌려주지 않는다면 포인터 매개변수가 필요하다.

    void increase(int *valp)    // int를 가리키는
    {                           // 포인터를 기대함
        *valp += 5;
    }

    int main()
    {
        int x;

        increase(&x);           // x의 주소를 건넴
    }

    void increase(int &valr)    // int를 참조함
    {                           
        valr += 5;
    }

    int main()
    {
        int x;

        increase(x);            // 참조를 건넴
    }

배경 뒤에서 참조는 포인터를 사용하여 구현되어 있다. 그래서 컴파일러의 눈에는 C++의 참조는 그저 상수 포인터일 뿐이다. 그렇지만 참조가 있으면 프로그래머는 간접 참조의 깊이에 관하여 알 필요도 없고 신경쓸 필요도 없다. 평범한 포인터와 참조 사이의 중대한 차이는 물론 참조로는 절대로 간접 참조가 일어나지 않는다는 것이다. 예를 들어:

    extern int *ip;
    extern int &ir;

    ip = 0;     // ip를 재할당, 이제 0-포인터
    ir = 0;     // ir은 변경 안됨, 이를 참조하는 int 변수는
                // 이제 0임.

혼동을 피하려면 다음 사실에 중심을 두기를 바란다.

• 함수가 내장 유형이나 포인터 유형인 그의 매개변수를 변경하지 않는 상황에서는 값 매개변수를 사용할 수 있다.

  void some_func(int val)
  {
      cout << val << '\n';
  }
  
  int main()
  {
      int x;
  
      some_func(x);       // 사본이 건네진다.
  }
  

• 함수가 명시적으로 그의 인자 값을 바꾸어야 한다면 포인터 매개변수가 좋다. 이 포인터 매개변수는 그 함수의 최초 매개변수가 되는 것이 좋다. 이를 인자로 반환이라고 부른다.

  void by_pointer(int *valp)
  {
      *valp += 5;
  }
  

• 함수가 그의 클래스 또는 구조체 유형의 인자 값을 변경하지 않거나, 또는 인자를 변경하더라도 부작용이 별로 없으면 (예를 들어, 인자가 스트림이면) 참조를 사용할 수 있다. 함수가 인자를 변경하지 않으면 상수-참조를 사용해야 한다.

  void by_reference(string const &str)
  {
      cout << str;    // str 변경 없음
  }
  
  int main ()
  {
      int x = 7;
      by_pointer(&x);         // 포인터가 건네짐
                              // x는 변경 가능
      string str("hello");
      by_reference(str);      // str 변경 불가
  }
  

  참조는 인자가 함수에 의해서 변경되지 않지만 매개변수를 초기화하기 위해 인자를 복사하는 것이 바람직하지 않을 경우에 중요한 역할을 한다. 거대한 객체를 함수에 인자로 건네거나 함수가 돌려줄 경우에 복사 연산이 중대한 요소가 되는 경향이 있다. 왜냐하면 전체 객체를 복사해야 하기 때문이다. 당연히 참조가 바람직하다.

  인자를 함수가 변경하지 않는다면 또는 호출자가 반환된 정보를 변경하지 말아야 한다면 const 키워드를 사용해야 한다. 다음 예제를 연구해 보자:

  struct Person                   // 좀 큰 구조체
  {
      char    name[80];
      char    address[90];
      double  salary;
  };
  
  Person person[50];          // 개인 데이터베이스
  
                              // printperson 함수는 구조체에 대한
                              // 참조를 기대하지만 
                              // 변경하지는 않을 것이다.
  void printperson (Person const &p)
  {
      cout << "Name: " << p.name << '\n' <<
              "Address: " << p.address << '\n';
  
  }
                              // indexvalue로 개인 기록 검색
  Person const &person(int index)
  {
      return person[index];   // 참조가 반환됨,
  }                           // person[index]의 사본이 아님
  
  int main()
  {
      Person boss;
  
      printperson (boss);     // 포인터가 건네지지 않음,
                              // 그래서 변수는 함수가
                              // 변경하지 않을 것이다.
      printperson(person(5));
                              // 사본이 아니라
                              // 여기에서는 참조가 건네짐
  }
  

• 객체를 함수에 인자로 건넬 때 참조를 사용하는 또다른 이유가 있음을 눈여겨보라. 객체를 참조로 건네면 복사 생성자가 활성화되지 않는다. 복사 생성자는 제 9장에 다룬다.

결과적으로 참조는 정말 '보기 흉한' 코드가 될 가능성이 있다. 함수는 변수를 참조로 건넬 수 있는데, 다음 예제를 보면:

    int &func()
    {
        static int value;
        return value;
    }

    func() = 20;
    func() += func();

포인터와 참조 사이의 여러 차이점들을 아래 리스트에 요약한다.

• 참조는 그 자체로 존재할 수 없다. 즉, 참조 대상이 있어야 한다.
  int &ref;
  위와 같은 참조의 선언은 허용되지 않는다. ref가 과연 무엇을 참조할 것인가?
• 참조는 external로 선언할 수 있다. 이런 참조는 어디에선가 초기화되어 있어야 한다.
• 참조는 함수의 매개변수로 존재할 수도 있다. 해당 함수가 호출될 때 초기화된다.
• 참조는 함수의 반환 유형에 사용될 수도 있다. 그 경우 반환 값이 무엇을 참조하는지는 함수가 결정한다.
• 참조는 클래스의 데이터 멤버로 사용될 수도 있다. 이 사용법에 관해서는 나중에 다룬다.
• 포인터는 그 자체로 변수이다. 포인터는 무언가 구체적인 것을 가리키거나 아니면 그냥 ``아무것도'' 가리키지 않을 수 있다.
• 참조는 다른 변수에 대한 별명이며 또다른 변수에 대하여 다시 또 별명을 가질 수 없다. 일단 참조가 정의되면 그 변수만 참조한다.
• (상수 포인터는 제외하고) 포인터는 또다른 변수를 가리키도록 재할당이 가능하다.
• 주소 연산자 &를 참조에 사용하면 그 표현식은 참조가 적용된 변수의 주소를 산출한다. 대조적으로 보통의 포인터는 그 자체로 변수이다. 그래서 포인터 변수의 주소는 그 포인터가 가리키는 주소와 아무 상관이 없다.

3.3.2: Rvalue 참조

rvalue 참조라는 이름은 할당 서술문으로부터 파생되었다. 할당할 때 할당 연산자의 왼쪽에 있는 변수를 lvalue라고 부르고 오른쪽에 있는 표현식은 rvalue라고 부른다. 종종 rvalue는 임시의 익명 값으로서 함수가 돌려주는 값과 같다.

이런 비유로 C++ 참조는 lvalue 참조라고 간주해야 한다 (typename & 표기법 사용). rvalue 참조와 대조적이다 (typename && 표기법 사용).

rvalue 참조를 이해하는 열쇠는 익명 변수라는 개념이다. 익명 변수는 이름이 없다. 눈에 띄는 특징이 있다. 컴파일러는 선택해야 할 때 자동으로 그 익명변수를 rvalue 참조에 연관짓는다. 흥미로운 구조를 소개하기 전에 먼저 lvalue 참조가 사용되는 대표적인 상황을 살펴 보자. 다음 함수는 임시의 이름없는 값을 돌려준다.

    int intVal()
    {
        return 5;
    }

    int &ir = intVal();         // 실패: 임시값을 참조함
    int const &ic = intVal();   // 허용: 변경불능 임시 값 참조
    int *ip = &intVal();        // 실패: lvalue 값이 없음

intVal이 돌려주는 임시 값을 변경하는 것은 확실하게 불가능하다. 그러나 이제 다음 함수들을 연구해 보자:

    void receive(int &value)            // 주의: lvalue 참조
    {
        cout << "int value parameter\n";
    }
    void receive(int &&value)           // 주의: rvalue 참조
    {
        cout << "int R-value parameter\n";
    }

    int main()
    {
        receive(18);
        int value = 5;
        receive(value);
        receive(intVal());
    }

    int R-value parameter
    int value parameter
    int R-value parameter

    void receive(int &&value)
    {
        ++value;
        cout << "int R-value parameter, now: " << value << '\n';
            // 각각, 19와 6을 화면에 보여준다.
    }

그렇지만 void receive(int &value)가 void receive(int value)로 교체되면 컴파일러는 문제에 봉착한다. 값 매개변수인지 참조 매개변수인지 (lvalue인가 rvalue인가) 컴파일러는 결정을 내리지 못하고 모호하다고 보고한다. 실제 상황에 이것이 문제는 아니다. rvalue 참조가 추가된 것은 두 가지 형태의 참조를 구별하기 위해서였다. 이름붙은 (lvalue 참조) 값과 이름없는 (rvalue 참조) 값을 구분하기 위해서였다.

이동 의미구조와 완벽한 전달의 구현은 이 구별 덕분이다. 이 시점에서는 이동 의미구조를 완전히 다룰 수는 없다 (깊은 연구는 9.7절 참고). 그러나 그 아래의 아이디어를 보여주는 것이 좋을 것 같다.

함수가 struct Data를 돌려주는데 그 안에 동적으로 할당된 문자들을 가리키는 포인터가 담겨 있는 상황을 연구해 보자. 게다가 구조체에는 copy(Data const &other) 멤버 함수가 정의되어 있어서 또다른 Data 객체를 받아 다른 객체의 데이터를 현재 객체 안에 복사한다. (부분적으로) struct Data를 정의하면 대략 다음과 같을 것이다 (눈이 날카로운 독자들에게 이 예제에서 Data::copy()를 사용한 결과로 인한 메모리 누수는 무시합시다):

    struct Data
    {
        char *text;
        size_t size;
        void copy(Data const &other)
        {
            text = strdup(other.text);
            size = strlen(text);
        }
    };

    Data dataFactory(char const *txt)
    {
        Data ret = {strdup(txt), strlen(txt)};
        return ret;
    }

    int main()
    {
        Data d1 = {strdup("hello"), strlen("hello")};

        Data d2;
        d2.copy(d1);                        // 1 (본문 참고)

        Data d3;
        d3.copy(dataFactory("hello"));      // 2
    }

• 반환 값은 임시 객체이다. 생존의 유일한 이유는 그의 데이터를 d3에 건네는 것이다. 이제 d3은 분명히 좀 끈질기게 살아 남아 있는 그 임시 객체의 데이터를 복사한다.
• copy()를 호출하고 나서 임시의 Data 객체는 사라진다. 불행하게도 동적으로 할당된 그의 데이터는 사라지고 그 때문에 메모리 누수가 일어난다.

    struct Data
    {
        char *text;
        size_t size;
        void copy(Data const &other)
        {
            text = strdup(other.text);
        }
        void copy(Data &&other)
        {
            text = other.text;
            other.text = 0;
        }
    };

• 깊은 복사를 하는 대신에 ((1) 상황에 필수) 그냥 포인터 값을 새로운 소유자에게 넘긴다.
• other.text는 동적으로 할당된 메모리를 더 이상 가리키지 않으므로 메모리 누수를 방지한다.

*this에 대한 rvalue 참조와 그리고 rvalue로 클래스 객체를 초기화하는 것은 아직 g++ 컴파일러가 지원하지 않는다.

3.3.2.1: Rvalue 심화 연구

역사적으로 C 언어는 lvalue와 rvalue를 구분한다. 이 용어는 할당 표현식에 근거가 있는데, 할당 연산자의 왼쪽이 값을 받는 반면에 (예를 들어, 변수 처럼 값을 써 넣을 수 있는 메모리의 위치를 참조한다) 오른쪽은 값을 나타낼 뿐이기 때문이다 (임시 변수나 상수 값 또는 변수 안에 저장된 값이 될 수 있다):

    lvalue = rvalue;

C++는 이 기본적인 구분 방식에다 값을 참조하는 여러가지 방식을 새로 추가했다.

• lvalue:

  C++에서 lvalue는 C에서의 의미와 같다. 마치 변수나 변수에 대한 참조 또는 역참조 포인터처럼 값을 저장할 수 있는 위치를 참조한다.

• xvalue:

  xvalue는 소멸 값을 표시한다. 소멸 값은 곧바로 사망할 객체를 참조한다 (제 7장). 그런 객체는 (동적으로 할당된 메모리와 같이) 자신이 소유한 자원도 역시 확실하게 소멸시켜야 한다. 그러나 그런 자원은 객체가 사망하기 전에 또다른 위치로 이동할 경우가 있어서 소멸을 방해할 가능성이 있다.

• gvalue:

  gvalue는 일반화된 lvalue이다. 일반화된 lvalue는 값을 받는 것은 무엇이든 참조한다. lvalue이거나 아니면 xvalue이다.

• prvalue:

  prvalue는 순수한 rvalue이다. (1.2e3과 같이) 문자 그대로의 값 또는 변경 불능 객체 (불변 std::string 함수로부터 반환된 값 (제 5장))

표현식의 값은 다음과 같은 경우 xvalue이다.

• 함수가 돌려주는 값이 객체에 대한 rvalue 참조일 경우;
• rvalue 참조로 유형이 변환되는 객체;
• 비-정적 클래스 데이터 멤버에 접근하는 표현식. 이 객체는 다음과 같이
  • xvalue이거나 아니면
  • .* (멤버를 가리키는 포인터) 표현식이다 (제 16장). 이 표현식에서 왼쪽 피연산자는 xvalue이고 오른쪽 피연산자는 데이터 멤버를 가리키는 포인터이다.
  이 규칙에 따라 이름 있는 rvalue 참조는 lvalue로 취급되고 객체에 대한 익명의 rvalue 참조는 xvalue로 취급된다.
  함수에 대한 rvalue 참조는 익명이든 아니든 lvalue로 취급된다.

다음은 작은 예제이다. 다음의 간단한 구조체를 연구해 보자:

    struct Demo 
    {
        int d_value;
    };

    Demo &&operator+(Demo const &lhs, Demo const &rhs);
    Demo &&factory();

    Demo demo;
    Demo &&rref = static_cast<Demo &&>(demo);

다음과 같은 표현식은 xvalue이다.

    factory();
    factory().d_value;
    static_cast<Demo &&>(demo);
    demo + demo

    rref;

많은 경우 실제로 어떤 종류의 gvalue 또는 rvalue가 사용되었는지 아는 것은 별로 중요하지 않다. C++ 주해서에서 lhs (left hand side)라는 용어는 이항 연산자의 왼쪽에 씌여지는 피연산자를 표시하기 위해 사용하고 rhs (right hand side)라는 용어는 오른쪽 피연산자를 표시하기 위해 사용한다. lhs 피연산자와 rhs 피연산자는 실제로는 (보통의 변수를 나타내는) gvalue일 수 있지만, (덧셈 연산자로 더해진 숫자 값과 같이) prvalue일 수도 있다. lhs와 rhs가 glvalue 인지의 여부는 언제든지 사용되는 문맥에 따라 결정할 수 있다.

3.3.3: 강력하게 유형이 정의되는 열거체

현재의 enum 유형에 관련한 또다른 문제는 값이 열거 유형의 이름 자체에 제한되는 것이 아니라 열거체가 정의된 영역에 제한된다는 것이다. 결과적으로 두 개의 열거체가 영역이 같으면 동일한 이름을 가질 수 없다.

그런 문제는 열거형 클래스를 정의하면 해결된다. enum class는 다음 예제와 같이 정의할 수 있다.

    enum class SafeEnum
    {
        NOT_OK,     // 0, 묵시적
        OK          = 10,
        MAYBE_OK    // 11, 묵시적
    };

    enum class CharEnum: unsigned char
    {
        NOT_OK,
        OK
    };

직접 데이터 유형을 지정하면 (기본값이 int임에 주목) 열거형 클래스를 전방 선언에 사용할 수 있다. 예를 들어,

    enum Enum1;                 // 불법: 크기가 지정이 안됨
    enum Enum2: unsigned int;   // 적법: 명시적으로 선언된 유형

    enum class Enum3;           // 적법: 기본 int 유형이 사용됨
    enum class Enum4: char;     // 적법: 명시적으로 선언된 유형

강력하게 유형이 정의되는 열거형의 심볼 연속을 생략 구문을 사용하여 switch 문에 나타낼 수도 있다. 이것을 다음 예제에 보여준다.

    SafeEnum enumValue();

    switch (enumValue())
    {
        case SafeEnum::NOT_OK ... SafeEnum::OK:
            cout << "Status is known\n";
        break;

        default: 
            cout << "Status unknown\n";
        break;
    }

3.3.4: 초기화 리스트

C++는 이 개념을 확장한다. initializer_list<Type> 유형을 도입했다. 여기에서 Type은 초기화 리스트에 사용된 값들의 유형 이름으로 교체된다. C++에서 초기화 리스트는 C의 초기화 리스트를 닮았다. 그래서 다-차원 배열과 구조체 그리고 클래스와 함께 사용할 수 있다.

initializer_list를 사용하려면 먼저 <initializer_list> 헤더를 포함시켜야 한다.

C에서처럼 초기화 리스트는 활괄호로 둘러싼 값 리스트로 구성된다. 그러나 C와는 다르게 함수에 초기화 리스트 매개변수를 정의할 수 있다. 예를 들어,

    void values(std::initializer_list<int> iniValues)
    {
    }

    values({2, 3, 5, 7, 11, 13});

    void values2(std::initializer_list<std::initializer_list<int>> iniValues)
    {}

    values2({{1, 2}, {2, 3}, {3, 5}, {4, 7}, {5, 11}, {6, 13}});

    void values(initializer_list<int> iniValues)
    {
        cout << "Initializer list having " << iniValues.size() << "values\n";
        for
        (
            initializer_list<int>::const_iterator begin = iniValues.begin();
                begin != iniValues.end();
                    ++begin
        )
            cout << "Value: " << *begin << '\n';
    }

초기화 리스트는 클래스 객체를 초기화하는 데에도 사용된다 (7.5절).

3.3.5: `auto'를 사용하여 유형 추론하기

그리고 auto를 저장 클래스 지정자로 사용하는 것은 이제 더 이상 C++에서 지원하지 않는다. auto int var와 같이 변수를 정의하면 컴파일 에러이다.

이것은 변수의 유형을 미리 결정하기가 매우 어려운 상황에 아주 유용할 수 있다. 이런 상황이 템플릿의 문맥에서 가끔 일어난다. 이 주제는 제 18장부터 제 23장에 걸쳐 다룬다. 또 알고는 있지만 이름이 몹시 길고 컴파일러에게 자동으로 알려지는 경우라면 auto를 사용해 기다란 유형 정의를 피할 수도 있다.

이 시점에서는 간단한 예제만 제공할 수 있다. 또 auto 키워드의 일반적인 사용법에 관하여 약간의 힌트만 제공한다. auto 키워드와 더불어 (decltype 함수와 관련된) 더 자세한 정보는 21.1.2 목을 참고하라.

int variable = 5로 변수를 정의하고 초기화하면 초기화 표현식의 유형이 잘 드러난다. 그 유형은 int이고 프로그래머의 의도에 어긋나지 않는 한, 이 유형을 사용하여 variable의 유형을 정의할 수 있다 (물론 정상적인 상황에서는 코드의 명료성을 개선하기보다 가리기 때문에 사용하면 좋지 않다):

    auto variable = 5;

다음은 auto를 사용하면 유용할 만한 예제들이다. 제 5장에 반복자(iterator)라는 개념을 소개한다 (제 12장과 18장). 반복자는 유형이 길게 정의되는 경우가 자주 있다. 예를 들어

    std::vector<std::string>::const_reverse_iterator

    std::vector<std::string>::const_reverse_iterator begin();

    std::vector<std::string>::const_reverse_iterator iter = begin();    // 1
    auto iter = begin();                                                // 2

    auto start = iter;

참조 유형이 요구되면 auto & 또는 auto &&를 사용하면 된다. 마찬가지로 auto 키워드 자체와 조합하여 const 와 포인터 지정을 사용할 수 있다. 다음은 몇 가지 예제이다.

    int value;
    auto another = value;   // 'int another'가 정의된다.

    string const &text();
    auto str = text();      // 단순 유형으로서 문자열이다. 그래서
                            // string str로 정의되며,
                            // string const str로 정의되지 않는다.
    str += "...";           // 그래서 OK이다.

    int *ip = &value;
    auto ip2 = ip;          // int *ip2가 정의된다.

    int *const &ptr = ip;
    auto ip3 = ptr;         // int *ip3이 정의된다, const &가 생략된다.
    auto const &ip4 = ptr;  // int *const &ip4가 정의된다.

마지막의 auto 지정은 int *를 산출한다. 그러나 auto에 의하여 유형정의에 const &가 추가된다. 그래서 int *const &ip4가 정의된다.

단순히 auto를 사용하면 언제나 그 결과는 비-참조 유형이다. auto가 참조 유형을 참조해야 한다면 auto &&를 사용하면 된다.

기존의 변수를 사용하여 start를 즉시 초기화할 수 없으면 decltype 키워드와 함께 잘 알려진 변수나 함수를 사용할 수 있다. 예를 들어:

    decltype(iter) start;
    decltype(begin()) spare;

auto와 다르게 decltype으로 도출된 유형은 값이거나 아니면 참조 유형이다. 이는 decltype에 건넨 표현식의 유형에 따라 달라진다. 예를 들어 int intVal와 int &&intTmp()를 사용할 수 있다면

    decltype(intVal)     iv(3);         // iv는 int이다.
    declType( (intVal) ) iref(intVal);  // iref는 int &이다.
    declType(intTmp())   tmpRef(f());   // tmpRef는 int &&이다.

게다가 C++14는 decltype(auto) 규격을 지원한다. 이 경우 decltype의 규칙에 auto가 적용된다. 예를 들어

    decltype(auto) iref2((intVal));     // iref2는 int &이다.
    auto iref3((intVal));               // iref3는 int이다.

함수의 반환 유형을 나중에 정의하는 데에도 auto 키워드를 사용할 수 있다. 10개의 int를 포인터로 돌려주는 intArrPtr 함수의 선언은 다음과 같다.

    int (*intArrPtr())[10];

auto를 사용하여 위의 함수를 선언하려면:

    auto intArrPtr() -> int (*)[10];

auto 키워드는 auto에 연관된 실제 유형과 관련하여 정의된 유형에도 사용할 수 있다. 다음은 몇 가지 예이다.

    vector<int> vi;
    auto iter = vi.begin();     // 표준: auto는 vector<int>::iterator임
    auto &&rref = vi.begin();   // auto는 반복자 유형에 대한 rvalue 참조이다.
    auto *ptr = &iter;          // auto는 반복자 유형을 가리키는 포인터이다.
    auto *ptr = &rref;          // 동일

auto를 돌려주는 함수에 대하여 C++14 표준은 더 이상 늦은 반환 유형의 지정을 요구하지 않는다. 그런 함수는 다음과 같이 선언할 수도 있다.

    auto autoReturnFunction();

• 여러 개의 return 서술문이 함수 정의에 사용되면 모두 유형이 같아야 한다.
• 단순히 auto만 돌려주는 함수는 컴파일러가 그의 정의를 보기 전에는 사용할 수 없다. 그래서 단순히 선언만으로는 사용할 수 없다.
• auto를 돌려주는 함수를 재귀 함수로 구현할 때 재귀 호출 전에 적어도 하나의 return 서술문은 보여야 한다. 예를 들어,

      auto fibonacci(size_t n)
      {
          if (n <= 1)
              return n;
          return fibonacci(n - 1) + fibonacci(n - 2);
      }
  

3.3.5.1: 구조화된 묶기 선언 (C++17)

여러 값을 돌려 주어야 할 때 보통은 구조체를 사용한다. 그러나 std::pair (12.2절) 또는 std::tuple (22.6절)을 사용해도 된다. 다음은 간단한 예이다. fun 함수는 데이터 필드가 두 개 있는 구조체를 돌려준다.

    struct Return
    {
        int first;
        double second;
    };
    
    Return fun()
    {
        return Return{ 1, 12.5 };
    }

또다른 fun 함수 호출은 전통적으로 fun의 반환 유형과 유형이 같은 변수를 정의한다. 그리고 그 변수의 필드를 사용하여 first와 second에 접근한다. 타자하기가 귀찮다면 auto를 사용해도 된다.

    int main()
    {
        auto r1 = fun();
        cout << r1.first;
    }    

    int main()
    {
        auto [one, two] = fun();
        cout << one;                // one과 two: 이제 정의됨
    }    

    int main()
    {
        auto &&[rone, rtwo] = fun();
    }    

    Return &fun2()
    {
        static Return ret{4, 5};
        return ret;
    }

    int main()
    {
        auto &[lone, ltwo] = fun2();    // OK: ret의 필드를 참조
    }    

구조화된 묶기 선언을 초기화할 때 함수가 반드시 구조체 안에 여러 값을 돌려줄 필요는 없다. 구조체를 익명으로 정의할 수도 있다:

    int main()
    {
        auto &[lone, ltwo] = Return{4, 5}; 
    }    

또 어떤 상황에서는 for 내포 서술문이나 선택 서술문에서 지역적으로 정의된 다른 유형의 변수들을 사용함으로써 혜택을 누릴 수 있다. 그런 변수들은 구조화된 묶기 선언을 사용하여 쉽게 정의할 수 있다. 이름없는 구조체나 페어 또는 터플로 초기화된다. 다음은 이를 보여주는 예제이다.

    // 적절한 구조체를 정의한다 (또는 --상황에 따라-- 페어나 터플로 정의한다):
    struct Three
    {
        size_t year;
        double firstAmount;
        double interest;
    };
        // 다음으로 유형이 다른 지역 변수를 사용하는
        // for-서술문을 정의한다.
    for (
        auto [year, amount, interest] = Three{0, 1000, .03};
            year <= 10; 
                ++year, amount *= (1 + interest)
    )
        cout << "Year " << year << ": amount = " << amount << '\n';
    
    /* 간략하게 출력:
		Year 0: amount = 1000
		Year 1: amount = 1030
		Year 2: amount = 1060.9
		...
		Year 9: amount = 1304.77
		Year 10: amount = 1343.92
    */

3.3.6: 유형의 선언과 'using' 선언

    unsigned long long int compute(double, int);

    unsigned long long int (*pf)(double, int);

    typedef unsigned long long int (*PF)(double, int);

    PF pf = compute;        // 다음과 같은 함수를 가리키는 포인터로 초기화한다.
                            // 'compute'
    void fun(PF pf);        // fun 함수는 다음과 같은 함수를 포인터로 기대한다.
                            // 'compute'

    typedef unsigned long long int FUN(double, int);

    FUN *pf = compute;      // 이제 pf는 확실히 포인터이다.

typedef 말고도 C++는 using 키워드를 제공한다. 유형과 식별자를 연관지을 수 있다. 실제로 typedef와 using은 서로 바꾸어 사용할 수 있다. using 키워드가 유형을 좀 더 읽기 쉽게 정의한다. 다음 세 가지 (동등한) 정의를 연구해 보자:

• 전통적인 C 스타일의 유형 정의. 유형 이름을 정의 안에 내장한다 (변수 이름을 유형 이름으로 변환):

typedef unsigned long long int FUN(double, int);

• 유형 이름을 정의 앞으로 이동함으로써 using을 적용해 유형 이름의 가시성을 개선한다. :

  using FUN = unsigned long long int (double, int);
  

• 또다른 생성 방법으로서 늦게-지정되는 반환 유형을 사용한다. (3.3.5항):

  using FUN = auto (double, int) -> unsigned long long int;
  

3.3.7: 범위-기반의 for-회돌이

    for (init; cond; inc)
        statement

전통적인 구문외에도 C++에서는 for-서술문에 새로운 구문이 추가된다. 범위-기반의 for-회돌이가 그것이다. 이 새로운 구문은 한 범위 안의 모든 원소들을 순서대로 처리한다. 범위는 세 가지 유형으로 구분된다.

• 평범한 배열 (예, int array[10]);
• 초기화 리스트;
• 표준 컨테이너 (또는 그 비슷한 것) (제 12장);
• begin()과 end() 함수를 제공하여 이른바 반복자를 돌려주는 기타 유형 (18.2절).

    // int array[30]이라고 가정
    for (auto &element: array)
        statement

공식적으로 auto를 사용해야 할 필요가 있는 것은 아니지만 auto를 사용하면 유용할 상황이 아주 많다. 범위가 복잡한 유형의 원소들을 가리키거나 또는 범위 안의 원소들을 가지고 무엇을 해야 할지는 알지만 유형의 정확한 이름은 신경쓰고 싶지 않을 경우에 사용하면 무척 유용하다. 위의 예제에서는 int를 사용해도 된다.

참조 심볼(&)은 다음과 같은 경우에 중요하다.

• 내포된 서술문에 있는 원소들을 변경하고 싶을 때
• 원소 자체가 구조체일 때 (또는 클래스일 때, 제 7장 참고)

    struct BigStruct
    {
        double array[100];
        int    last;
    };

    BigStruct data[100];    // 어디에선가 적절하게 초기화되었다고 간주한다.

    int countUsed()
    {
        int sum = 0;
                            // const &: 이 원소들은 변경되지 않는다.
        for (auto const &element: data)
            sum += element.last;
        return sum;
    }

3.3.8: 날 문자열 기호상수

어떤 경우 (예를 들어, XML의 문맥에서) 문자열 피신을 피하는 것이 유용할 경우가 있다. 이 목적을 위해 C++는 날 문자열 기호상수를 제공한다.

날 문자열 기호상수는 R이 오고 다음에 겹따옴표가 오고 그 다음에 라벨이 오며 ((가 아닌 문자열) 다음에 (으로 시작한다. 날 문자열은 닫는 괄호 )와 다음에 라벨이 따라 오며 그 다음에 겹따옴표로 끝난다. 예를 들어:

    R"(A Raw \ "String")"
    R"delimiter(Another \ Raw "(String))delimiter"

날 문자열 기호상수는 (사용법 정보라든가 기다란 html-연속열의 경우와 같이) 복잡하고 기다란 ascii-문자가 사용될 때 아주 편리하다. 요약해 말하면 기다란 NTBS 연속열에 딱맞춤이다. 코드와 분리하는 것이 가독성을 높이고 코드를 유지 관리하는 데 좋다.

예를 들어 bisonc++ 파서 생성기는 --prompt 옵션을 지원한다. 이 옵션을 지정하면 디버깅이 필요할 때 bisonc++에 의하여 생성된 코드가 주의 코드를 삽입해 준다. 주의 코드를 처리하는 함수 안으로 날 문자열 기호상수를 직접적으로 삽입하면 그 결과 아주 읽기 어려운 코드가 만들어진다.

    void prompt(ostream &out)
    {
        if (d_genDebug)
            out << (d_options.prompt() ? R"(
            if (d_debug__)
            {
                s_out__ << "\n================\n"
                           "? " << dflush__;
                std::string s;
                getline(std::cin, s);
            }
    )"              : R"(
            if (d_debug__)
                s_out__ << '\n';
    )"
                    ) << '\n';        
    }

소스 파일의 익명 이름공간에 NTBS로 이름을 붙여 날 문자열 기호 상수를 정의하면 가독성이 크게 개선된다 (제 4장):

    namespace {
    
    char const *noPrompt = 
    R"(
            if (d_debug__)
                s_out__ << '\n';
    )";
    
    char const *doPrompt = 
    R"(
            if (d_debug__)
            {
                s_out__ << "\n================\n"
                           "? " << dflush__;
                std::string s;
                getline(std::cin, s);
            }
    )";
    
    } // 익명 이름공간
    
    void prompt(ostream &out)
    {
        if (d_genDebug)
            out << (d_options.prompt() ? doPrompt : noPrompt) << '\n';        
    }

3.3.9: 이진 상수

이진 상수는 비트-깃발(flag) 같은 문맥에 사용하면 편리하다. 어느 비트-필드가 설정되어 있는지 즉시 보여주기 때문이다. 반면에 다른 표기법으로는 정보를 얻을 수 없다.

3.3.10: 컴파일러 속성

C++ 표준은 다음 속성이 정의되어 있다.

• [[noreturn]]:

  [[noreturn]] 함수가 반환되지 않는다는 사실을 가리킨다. 이 속성으로 선언되어 있는 함수가 실제로 반환될 경우 [[noreturn]]의 행위는 정의되어 있지 않다. 표준 함수들은 다음과 같은 속성이 있다. std::_Exit, std::abort, std::exit, std::quick_exit, std::unexpected, std::terminate, std::rethrow_exception, std::throw_with_nested, std::nested_exception::rethrow_nested.

  다음은 [[noreturn]] 속성을 사용하여 함수를 선언하고 정의하는 예이다.

      [[noreturn]] void doesntReturn();
  
      [[noreturn]] void doesntReturn()
      {
          exit(0);
      }
  

• [[carries_dependency]]:

  이 속성은 아직 이 책에서 다루지 않았다. 이 시점에서는 무시해도 좋다.

• [[deprecated]]:

  이 속성은 (그리고 그의 다른 형태 [[deprecated("reason")]]는) C++14 표준부터 사용할 수 있다. 이 속성으로 선언된 객체나 이름을 사용해도 좋다는 뜻이기는 하다. 그러나 어떤 이유로 사용하지 않는 것이 좋다. 이 속성은 클래스, typedef-이름, 변수, 비-정적 데이터 멤버, 함수, 열거체, 그리고 템플릿 특정화에 사용할 수 있다. 기존의 비추천이 아닌 객체는 비추천으로 재선언할 수 있지만 일단 비추천으로 선언되면 철회할 수는 없다. [[deprecated]] 속성을 만나면 컴파일러는 경고를 보여준다. 예를 들어,

      demo.cc:12:24: warning: 'void deprecatedFunction()' is deprecated 
                      [-Wdeprecated-declarations] deprecatedFunction();
  
      demo.cc:5:21: note: declared here
                       [[deprecated]] void deprecatedFunction()
  

  대안 형태를 사용하면 (예를 들어 [[deprecated("do not use")]] void fun()) 컴파일러는 겹따옴표 사이에 경고 텍스트를 보여준다. 예를 들어,

      demo.cc:12:24: warning: 'void deprecatedFunction()' is deprecated: 
          do not use [-Wdeprecated-declarations] 
       deprecatedFunction();
  
      demo.cc:5:38: note: declared here
           [[deprecated("do not use")]] void deprecatedFunction()
  

3.3.11: (C++17) 초기화자가 있는 선택 서술문

C++17은 이 개념을 선택 서술문까지 확장한다. 이미 if 서술문과 switch 서술문의 조건절에서 변수들을 정의하고 초기화할 수 있지만, C++17부터 정의와 할당을 가를 수 있게 되었다. 그래서 초기화 절을 선택 서술문에 사용할 수 있다.

표준 입력 스트림으로부터 읽어 들인 다음 줄이 go!와 같을 경우에 어떤 조치를 취해야 한다고 가정해 보자. 안에 다음 줄을 되도록이면 많이 담도록 문자열을 지역화할 생각일지라도, 함수 안에 사용될 때는 다음과 같이 구성해야 한다.

    void function()
    {
        // ... 서술문 나열
        {
            string line;    // line을 지역화
            if (getline(cin, line))
                action();
        }
        // ... 서술문 나열
    }

    void function()
    {
        // ... 서술문 나열
        if (string line; getline(cin, line))
            action();
        // ... 서술문 나열
    }

if-서술문처럼 switch-서술문도 선택적인 초기화 절을 지원한다. 프로그램이 명령어를 처리한다고 생각해 보자. 표준 입력으로 줄들이 들어 오고 convert 함수가 그 명령어를 열거 값으로 변환한다. 초기화 절을 switch 서술문에 적용하면, 모든 명령어들은 다음과 같이 처리될 것이다.

    void process()
    {
        while (true)
        {
            switch (string cmd; int select = convert(getline(cin, cmd)))
            {
                case CMD1:
                    ...
                break;

                case CMD2:
                    ...
                break;

                ... 
            }
        }
    }

3.4: 새로운 언어-정의 데이터 유형

void, char, short, int, long, float 그리고 double

bool, wchar_t, long long 그리고 long double

32-비트로 개발된 어플리케이션의 골격구조를 64비트로 변환할 때 알아야 할 미묘한 문제가 있다. long 유형과 포인터 유형만 크기가 32비트에서 64비트로 바뀐다. int 유형은 크기가 그대로 32비트이다. 이 때문에 포인터나 long 유형을 int 유형으로 변환할 때 데이터가 잘려 나갈 가능성이 있다. 또한, int보다 짧은 유형을 사용하여 표현식을 unsigned long이나 포인터에 할당할 때 부호 확장의 문제가 일어날 수 있다. 이 문제에 관한 더 상세한 정보는 여기에서 얻을 수 있다.

이런 내장 유형 외에도 클래스 유형의 string을 문자열 처리에 사용할 수 있다. 데이터 유형 bool과 wchar_t는 다음 절에 다룬다. string 데이터 유형은 제 5장에 다룬다. 최신 버전의 C라면 이런 새 데이터 유형을 이미 채택하고 있을 수도 있다 (bool과 wchar_t에 주목). 그렇지만 전통적으로 C는 그것들을 지원하지 않는다. 그러므로 여기에서 언급한다.

이제 새로운 유형을 소개했으므로 기호문자(letters)에 대한 기억을 되살려 보자. 다양한 유형의 기호 상수에 사용할 수 있다.

• b 또는 B:

  십육진 값을 나타내는 외에도 이진 상수도 정의할 수 있다. 예를 들어 0b101는 십진수 5와 동등하다. 0b 접두사는 C++14 표준부터 이진 상수를 지정한다.

• E 또는 e:

  부동 소수점 기호 상수 값에서 지수 문자. 예를 들어 1.23E+3. 여기에서 E 이하는 10의 3승(제곱)이라고 읽고 번역해야 한다. 그러므로 1.23E+3는 값 1230을 나타낸다.

• F

  비-정수형 상수 뒤에 접미사로 붙어 float 유형의 값을 나타낸다. 기본값인 double이 아니다. 예를 들어 12.F (점은 12를 부동 소수점 값으로 변환한다); 1.23E+3F (앞 예제 참조. 1.23E+3는 double 값이다. 반면에 1.23E+3F는 float 값이다).

• L

  접두사로 사용해 문자열이 wchar_t 유형의 문자로 구성되어 있음을 나타낸다. 예를 들어 L"hello world".

• L

  정수 값에 접미사로 사용해 long 유형의 값을 나타낼 수 있다. 기본 값인 int가 아니다. short 유형을 나타내는 데는 기호가 없음을 주목하자. 그를 위해서는 static_cast<short>()를 사용해야 한다.

• p

  십육진 부동소수점수에서 지수를 지정한다. 예, 0x10p4. 지수 자체는 십진 상수로 읽는다. 그러므로 0x로 시작할 수 없다. 지수부는 2의 제곱으로 번역된다. 그래서 0x10p2는 (십진수) 64와 동등하다. 16 * 2^2.

• U

  정수 값 뒤에 접미사로 사용하면 int가 아니라 unsigned 값을 나타낸다. 접미사 L과 조합하면 unsigned long int 값을 생산할 수도 있다.

3.4.1: `bool' 데이터 유형

        // 정수에서 부울 값으로:
    boolValue = intValue ? true : false;

        // 부울 값에서 정수로:
    intValue = boolValue ? 1 : 0;

    cout << "A true value: "  << true << "\n"
            "A false value: " << false << '\n';

bool-유형을 사용하는 것이 int를 사용하는 것보다 더 명확하다. 다음 원형을 연구해 보자:

    bool exists(char const *fileName);  // (1)
    int  exists(char const *fileName);  // (2)

    if (exists("myfile"))
        cout << "myfile exists";

필자는 다음을 제일 규칙으로 삼기를 제안한다. 함수가 그의 호출자에게 성공이나 실패 여부를 알려주어야 한다면 그 함수에게 bool 값을 돌려주도록 한다. 함수가 다양한 유형의 에러 유형이나 성공 여부를 돌려주어야 한다면 그 함수에게 enum 값을 사용하도록 한다. 다양한 심볼 상수로 상황을 문서화한다. 함수가 개념적으로 의미 있는 정수 값을 돌려줄 때만 (두 int 값을 더한 결과) 그 함수가 int 값을 돌려주도록 한다.

3.4.2: 데이터 유형 `wchar_t'

Java의 char 데이터 유형은 C++의 wchar_t 유형에 비교된다는 것에 주목하라. 그렇지만 Java의 char 유형은 2 바이트 너비이다. 반면에 Java의 byte 데이터 유형은 C++의 char 유형과 비교된다. 1 바이트이다. 혼란스럽다!

3.4.3: 유니코드 인코딩

C++는 또 8, 16 그리고 32 비트 유니코드 인코드 문자열을 지원한다. 게다가, 두 개의 데이터 유형을 새로 도입했다. char16_t와 char32_t가 그것으로서 각각 UTF-16 유니코드 값과 UTF-32 유니코드 값을 저장한다.

그리고 char 유형의 값은 utf_8 유니코드 값에 딱 맞는다. 값이 256 개를 넘어가면 (char16_t이나 char32_t처럼) 광폭 유형을 사용해야 한다.

유니코드 인코딩의 다양한 유형에 대하여 문자열 기호상수는 (그리고 연관 변수는) 다음과 같이 정의할 수 있다.

    char     utf_8[] = u8"이것은 UTF-8 인코드.";
    char16_t utf16[] = u"이것은 UTF-16 인코드.";
    char32_t utf32[] = U"이것은 UTF-32 인코드.";

    char     utf_8[] = u8"\u2018";
    char16_t utf16[] = u"\u2018";
    char32_t utf32[] = U"\u2018";

3.4.4: `long long int' 데이터 유형

3.4.5: `size_t' 데이터 유형

size_t를 사용하면 개념적 유형이라는 장점이 있다. 수식자로 변경이 되는 표준 유형이 아니다. 그래서 소스 코드의 자가 문서화의 가치를 개선한다.

어떤 경우 함수가 명시적으로 unsigned int를 사용하기를 요구하는 경우가 있다. 예를 들어, amd-골격구조에서 X-windows 함수인 XQueryPointer는 그의 인자 중 하나로 unsigned int 변수를 가리키는 포인터를 명시적으로 요구한다. 그렇다면 size_t 변수를 가리키는 변수를 사용할 수 없다. unsigned int 주소를 제공해야 한다. 그렇지만 그런 경우는 예외적인 경우이다.

다른 유용한 비트-표현 유형도 존재한다. 예를 들어, uint32_t는 32-비트 무부호 값을 보유한다고 보증한다. 비슷하게 int32_t는 32-비트 부호 값을 보유한다고 보증한다. 상응하는 유형이 8, 16 그리고 64 비트 값에도 존재한다. 이런 유형은 헤더 파일 cstdint에 정의되어 있다.

3.4.6: C++14: 자릿수 구분자

    1'000'000
    3.141'592'653'589'793'238'5
    ''123       // 컴파일 안됨
    1''23       // 역시 컴파일 불가

3.5: 유형변환을 위한 새 구문

        (typename)expression

C 스타일의 유형변환은 이제 추천하지 않는다. C++ 프로그램은 새 스타일의 C++ 유형변환을 사용해야 한다. 유형변환을 인지하는 컴파일러가 검증하도록 편의를 제공하기 때문이다. 이 편의기능은 고전적인 C-스타일의 유형변환에서 제공하지 않는다.

자주 사용되는 생성자 표기법과 유형변환을 서로 혼동하면 안된다.

    typename(expression)

유형변환이 실제로 필요하면 여러 새-스타일의 유형변환 중에 하나를 사용해야 한다. 이 새 스타일의 유형변환을 다음 절에 소개한다.

3.5.1: `static_cast'-연산자

다음은 static_cast를 사용할 수 있는 (또는 사용해야 하는) 상황의 예이다.

• int를 double로 변환할 때
  

  예를 들어 이런 일은 두 개의 int 값으로 나눗셈에서 분수 부분을 잃지 않고 몫을 계산해야 할 경우에 일어난다. sqrt 함수를 두 개의 다음 분수로 호출하면 2를 반환한다.

  int x = 19;
  int y = 4;
  sqrt(x / y);
  

  반면에 다음과 같이 static_cast를 사용하면 2.179를 반환한다.

  sqrt(static_cast<double>(x) / y);
  

  여기에서 눈여겨볼 점은 그의 expression의 표현을 목표 유형이 사용하는 표현으로 바꾸는 데 static_cast가 허용된다는 것이다.

  또 주목할 것은 나눗셈은 유형변환 표현식의 바깥에 배치되어 있다는 사실이다. (static_cast<double>(x / y)과 같이) 나눗셈이 유형변환의 expression 안에서 수행되면 정수 나눗셈이 먼저 수행되고 나서 피연산자의 유형을 double 유형으로 변환할 기회를 가진다.

• enum 값을 int 값으로 변환할 때 (방향에 상관 없음).
  

  여기에서 두 유형은 표현이 같지만 의미구조가 다르다. 평범한 enum 값을 int에 할당하면 유형을 변환하지 않아도 된다. 그러나 강력하게 유형이 정의되는 열거체라면 유형을 변환해야 한다. 반대로 int 값을 열거체 유형의 변수에 할당할 때 static_cast가 요구된다. 다음은 예이다.

  enum class Enum
  {
      VALUE
  };
  
  cout << static_cast<int>(VALUE);    // 숫치 값을 보여준다.
  

• 관련 포인터를 서로 변환할 때
  

  클래스 상속의 문맥에서 이른바 `파생 클래스'를 가리키는 포인터를 그의 `바탕 클래스'를 가리키는 포인터로 변환하는 데 static_cast가 사용된다 (제 13장). 관련 없는 유형을 서로 변환하는 곳에는 사용할 수 없다 (예를 들어 short를 가리키는 포인터를 int를 가리키는 포인터로 변환하는 데 static_cast를 사용할 수 없다).

  void *는 총칭 포인터이다. C 라이브러리 함수에 자주 사용된다 (예를 들어 memcpy(3)). 총칭 포인터이기 때문에 다른 모든 포인터와 관련이 있으므로 static_cast를 사용하여 void *를 원하는 목표 포인터로 변환해야 한다. 이것은 C로부터 물려 받은 약간 고약한 유산인데 아마도 그 문맥 안에서만 사용되어야 할 것이다. 다음은 한 예이다.

  C 라이브러리의 qsort 함수는 두 개의 void const * 매개변수가 있는 (비교) 함수를 포인터로 기대한다. 실제로 이 매개변수들은 배열에서 정렬될 데이터 원소들을 가리킨다. 그래서 비교 함수는 반드시 void const * 매개변수를 정렬될 배열 원소들을 가리키는 포인터로 변환해야 한다. 그래서 배열이 int array[]이고 비교 함수의 매개변수가 void const *p1과 void const *p2이라면 비교 함수는 다음과 같이 p1이 가리키는 int의 주소를 얻는다.

  static_cast<int const *>(p1);
  

• 유형이 int인 변수의 부호-수식자를 해제하거나 도입할 때 (표현식의 표현을 바꾸는 데 static_cast가 허용된다는 사실을 기억하라!).
  

  다음은 한 예이다. C 언어의 tolower 함수는 unsigned char 값을 나타내는 int를 요구한다. 그러나 char는 기본으로 부호가 있는 유형이다. char ch를 사용하여 tolower를 호출하려면 다음과 같이 사용해야 한다.

          tolower(static_cast<unsigned char>(ch))
  

3.5.2: `const_cast'-연산자

        const_cast<type>(expression)

전통적으로 그래야 할 경우에도 언제나 상수를 인지하지 못하는 표준 C 라이브러리의 함수와 조합해 사용하면 const_cast가 필요할 경우가 있다. strfun(char *s) 함수도 사용이 가능하다. 실제로 s가 가리키는 문자들을 변경하지 않고 char *s 매개변수에 연산을 수행한다. char const hello[] = "hello";를 strfun에 건네면 경고가 일어난다.

        passing `const char *' as argument 1 of `fun(char *)' discards const

        strfun(const_cast<char *>(hello));

3.5.3: `reinterpret_cast'-연산자

        reinterpret_cast<pointer type>(pointer expression)

reinterpret_cast를 공용체를 제공하는 유형변환이라고 생각하라. 같은 메모리 위치를 완전히 다르게 해석할 수 있다.

예를 들어 reinterpret_cast는 스트림에 사용가능한 write 함수와 조합하여 사용된다. C++에서 스트림은 디스크-파일보다 선호되는 인터페이스이다. std::cin과 std::cout 같은 표준 스트림도 객체이다.

쓰기용 스트림은 (cout 같은 `출력 스트림') write 멤버를 제공한다. 원형은 다음과 같다.

        write(char const *buffer, int length)

    cout.write(reinterpret_cast<char const *>(&value), sizeof(double));

유형변환은 무엇이든 잠재적으로 위험하다. 그 중에서도 reinterpret_cast가 가장 위험하다. 효과적으로 컴파일러에게 알린다. 되돌아가 보면 우리는 무엇을 하고 있는지 알고 있으므로 추론을 멈춘다. 원점으로 되돌아가 다음과 같은 상황에 우리가 무엇을 하고 있는지 알아 두는 게 좋다. 해당 사례로서 다음 코드를 연구해 보자:

    int value = 0x12345678;     // 32-비트 int로 간주

    cout << "Value's first byte has value: " << hex <<
            static_cast<int>(
                *reinterpret_cast<unsigned char *>(&value)
                            );

제일 규칙으로서 유형을 변환해야 한다면 확실하게 그 이유를 코드에 문서화하라. 유형변환으로 인해 결국 프로그램이 잘못 행동하지는 않는지 거듭 확인하라. 사용하지 않아도 된다면 reinterpret_casts는 피하는 게 좋다.

3.5.4: `dynamic_cast'-연산자

        dynamic_cast<type>(expression)

아직 이 시점에서 dynamic_cast는 광범위하게 다룰 수 없지만 14.6.1항에 다시 이 주제를 다룬다.

3.5.5: 'shared_ptr' 객체 형변환

shared_ptr 클래스의 문맥에서 이는 18.4절에 다루는데, 여러 새 스타일의 유형변환을 더 사용할 수 있다. 이런 특수 목적의 유형변환은 실제로 나중으로 미루어서 18.4.5항에 다룬다.

다음과 같은 특수 유형변환이 있다.

• static_pointer_cast - 파생 클래스 객체의 바탕-클래스 부분을 가리키는 shared_ptr을 돌려준다.
• const_pointer_cast - 상수 객체를 가리키는 shared_ptr 비-상수 객체를 가리키는 shared_ptr을 돌려준다.
• dynamic_pointer_cast - 바탕 클래스를 가리키는 shared_ptr로부터 파생 클래스 객체를 가리키는 shared_ptr을 돌려준다.

3.6: C++의 키워드와 예약어

alignas  char32_t     enum     namespace        return        typedef  
alignof  class        explicit new              short         typeid   
and      compl        export   noexcept         signed        typename 
and_eq   concept      extern   not              sizeof        union    
asm      const        false    not_eq           static        unsigned 
auto     const_cast   float    nullptr          static_assert using    
axiom    constexpr    for      operator         static_cast   virtual  
bitand   continue     friend   or               struct        void     
bitor    decltype     goto     or_eq            switch        volatile 
bool     default      if       private          template      wchar_t  
break    delete       import   protected        this          while    
case     do           inline   public           thread_local  xor      
catch    double       int      register         throw         xor_eq   
char     dynamic_cast long     reinterpret_cast true                   
char16_t else         mutable  requires         try                    

주의:

• export 키워드는 더 이상 C++에서 자주 사용되지 않지만 키워드로 유지되고 있고 미래의 사용을 위해 예약되어 있다.
• C++17 표준부터 register 키워드는 더 이상 사용되지 않는다. 그러나 여전히 예약어로 남아 있다. 다시 말해 다음과 같이 정의하면

      register int index;
  

  컴파일 에러가 일어난다. 또 register는 더 이상 저장 클래스 지정자(storage class specifier)로 간주되지 않는다 (저장 클래스 지정자로는 extern, thread_local, mutable 그리고 static이 있다).
• 연산자 키워드: and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor 그리고 xor_eq는 각각 &&, &=, &, |, ~, !, !=, ||, |=, ^ 그리고 ^= 심볼로 대체된다.
• C++는 final과 override를 특별한 식별자로 인지한다. 이 식별자들은 다형적 함수나 클래스를 정의할 때 특별한 의미가 있다. 14.4절에 더 자세하게 다룬다.

키워드는 의도된 목적으로만 사용할 수 있으며 다른 개체를 위한 (예를 들어, 변수나 함수, 클래스 이름 등등) 이름으로 사용할 수 없다. 키워드와 더불어 밑줄로 시작하고 전역 이름공간에 존재하는 식별자는 (즉, 명시적인 이름공간을 사용하지 않거나 단순히 :: 이름공간만을 사용하는 식별자) 또는 std 이름공간에 존재하는 식별자는 구현자 전용으로 사용된다는 점에서 예약된 식별자나 다름없다.

• 목차
• 이전 장으로
• 다음 장으로