The Gamegrammer | 게임하는 프로그래머

유니티(Unity) | 시야각(FieldOfView) 만들기 | 01 | 2D 시야각

Muramasa — Tue, 10 Oct 2017 22:08:40 +0900

완성된 동작 모습

완성된 스크립트 모습

유니티 시야각 만들기 그 첫번째 시간, 2D 시야각 만들기입니다.
2D는 Z축으로만 회전하기 때문에 X, Y, Z 모든 축으로 회전 할 수 있는 3D에 비해 생각해야할 것이 적어 만들기가 간단합니다. 그럼 바로 시작해보도록 하겠습니다.

──────────────────────────────────

먼저 Sight2D라는 스크립트를 만들어서 열어줍니다.

public class Sight2D : MonoBehaviour {
    [SerializeField] private bool m_bDebugMode = false;
 
    [Header("View Config")]
    [Range(0f, 360f)]
    [SerializeField] private float m_horizontalViewAngle = 0f;
    [SerializeField] private float m_viewRadius          = 1f;
    [Range(-180f, 180f)]
    [SerializeField] private float m_viewRotateZ         = 0f;
 
    [SerializeField] private LayerMask m_viewTargetMask;
    [SerializeField] private LayerMask m_viewObstacleMask;
 
    private List<Collider2D> hitedTargetContainer = new List<Collider2D>();
 
    private float m_horizontalViewHalfAngle = 0f;
 
    private void Awake()
    {
        m_horizontalViewHalfAngle = m_horizontalViewAngle * 0.5f;
    }

다음 위와 같이 기본적인 변수들을 선언해주고 Awake에서 값을 세팅 해줍니다.
m_horizontalViewAngle은 시야각을 담는 변수이고 시야각의 최소 값은 0, 최대 값은 360 밖에 될 수 없으므로 Range 어트리뷰트를 이용해 최소 값, 최대 값을 제한해줍니다.
m_viewRotateZ는 후에 만들 AngleToDirZ 함수에 이용하기 위해 -180~180으로 값을 제한합니다.
LayerMask들은 Physics 함수에 사용할 변수들로 '볼 수 있는 타겟'과 '시야를 가로막는 오브젝트'를 지정해주는데 사용됩니다.

m_viewRatateZ는 tramsform의 rotation을 변경하지 않고 시야각을 회전 시키는데 이용하는 변수로 위 이미지에서처럼 캐릭터의 방향과 시야의 방향이 달라야 할 경우 이용할 수 있습니다.

// 입력한 -180~180의 값을 Up Vector 기준 Local Direction으로 변환시켜줌.
private Vector3 AngleToDirZ(float angleInDegree)
{
    float radian = (angleInDegree - transform.eulerAngles.z) * Mathf.Deg2Rad;
    return new Vector3(Mathf.Sin(radian), Mathf.Cos(radian), 0f);
}

다음 입력한 Angle(-180~180)을 Up Vector 기준 Direction으로 변환해주는 AngleToDirZ 함수를 만듭니다. Angle에 eulerAngles.z를 빼주는 이유는 입력한 Angle을 Local Direction으로 변환 시켜주기 위해서입니다.

Z축을 시계 방향(오른쪽)으로 돌리면 회전 값이 음수로 나온다.

더하기가 아닌 빼기를 하는 이유는 우리가 만든 함수는 시계 방향(오른쪽)이 양수, 반시계 방향(왼쪽)이 음수라고 보고 계산을 하지만 유니티에서 Z축은 시계 방향(오른쪽)이 음수, 반시계 방향(왼쪽)이 양수로 반대이기 때문에 빼기(-)를 통해 음수를 양수로, 양수를 음수로 만들어 연산해주는 것 입니다.

-15-(-20) = 5

만일 eulerAngles.z가 -20(오른쪽으로 20도)일 때 angleInDegree가 -15(왼쪽으로 15도)라면 식이 -15-(-20) = -15+20이 되어 5가 나오므로 월드 좌표 기준으로 오른쪽으로 5도 돌린(내가 보는 방향에서 -15도 돌린) Direction이 나올 것입니다.

private void OnDrawGizmos()
{
    if (m_bDebugMode)
    {
        m_horizontalViewHalfAngle = m_horizontalViewAngle * 0.5f;
 
        Vector3 originPos = transform.position;
 
        Gizmos.DrawWireSphere(originPos, m_viewRadius);
 
        Vector3 horizontalRightDir = AngleToDirZ(-m_horizontalViewHalfAngle + m_viewRotateZ);
        Vector3 horizontalLeftDir  = AngleToDirZ(m_horizontalViewHalfAngle + m_viewRotateZ);
        Vector3 lookDir = AngleToDirZ(m_viewRotateZ);
 
        Debug.DrawRay(originPos, horizontalLeftDir * m_viewRadius, Color.cyan);
        Debug.DrawRay(originPos, lookDir * m_viewRadius, Color.green);
        Debug.DrawRay(originPos, horizontalRightDir * m_viewRadius, Color.cyan);
    }
}

다음은 OnDrawGizmos 함수를 만들어 줍니다. DrawWireSphere를 통해 인식할 수 있는 범위를 그려주고 우리가 만든 AngleToDirZ 함수를 통해 시야각을 방향 값으로 변환시켜 DrawRay로 그려줍니다. Angle값에 m_viewRotateZ를 더해줌으로 m_viewRatateZ 값에 따라 시야각을 더 회전시킬 수 있습니다.

eulerAngles.z가 0일 때 HalfAngle이 10이라면 시야각이 -10~10이지만 m_viewRotateZ가 10이라면 시야각은 오른쪽으로 10도 더 돌린 0~20도가 될 것입니다.

빌드 한 스크립트를 넣어본 모습

여기까지해서 빌드 후 빈 오브젝트에 스크립트를 넣어보면 처음에 보여드린 완성된 모습과 똑같은 모습이 나오게 됩니다. 이제 시야각 안에 들어온 대상을 인식할 수 있는 기능만 추가하면 완성입니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public Collider2D[] FindViewTargets()
{
    hitedTargetContainer.Clear();
 
    Vector2      originPos    = transform.position;
    Collider2D[] hitedTargets = Physics2D.OverlapCircleAll(originPos, m_viewRadius, m_viewTargetMask);
        
    foreach (Collider2D hitedTarget in hitedTargets)
    {
        Vector2 targetPos = hitedTarget.transform.position;
        Vector2 dir     = (targetPos - originPos).normalized;
        Vector2 lookDir = AngleToDirZ(m_viewRotateZ);
 
        // float angle = Vector3.Angle(lookDir, dir)
        // 아래 두 줄은 위의 코드와 동일하게 동작함. 내부 구현도 동일
        float dot   = Vector2.Dot(lookDir, dir);
        float angle = Mathf.Acos(dot) * Mathf.Rad2Deg;
 
        if (angle <= m_horizontalViewHalfAngle)
        {
            RaycastHit2D rayHitedTarget = Physics2D.Raycast(originPos, dir, m_viewRadius, m_viewObstacleMask);
            if (rayHitedTarget)
            {
                if (m_bDebugMode)
                    Debug.DrawLine(originPos, rayHitedTarget.point, Color.yellow);
            }
            else
            {
                hitedTargetContainer.Add(hitedTarget);
 
                if (m_bDebugMode)
                    Debug.DrawLine(originPos, targetPos, Color.red);
            }
        }
    }
 
    if (hitedTargetContainer.Count > 0)
        return hitedTargetContainer.ToArray();
    else
        return null;
}
Colored by Color Scripter
cs

대상의 인식은 총 3단계의 확인 과정을 거쳐야 합니다.
1. 나의 인식 범위 안에 들어온 대상이 있는가?
2. 인식 범위 안에 들어온 대상이 나의 시야각 안에 있는가?
3. 시야각 안에 들어온 대상을 볼 수 없게 가로 막는 장해물이 존재하는가?

1
2

Vector2      originPos    = transform.position;
Collider2D[] hitedTargets = Physics2D.OverlapCircleAll(originPos, m_viewRadius, m_viewTargetMask);

먼저 Pysics2D.OverlapCircleAll 함수를 통해 인식 범위 안에 들어온 대상이 있는지 확인합니다. 이때 LayerMask인 m_viewTargetMask를 넣어줌으로써 원하는 타켓만 선별적으로 인식할 수 있습니다.

Vector2 targetPos = hitedTarget.transform.position;
Vector2 dir       = (targetPos - originPos).normalized;
Vector2 lookDir   = AngleToDirZ(m_viewRotateZ);
 
// float angle = Vector3.Angle(lookDir, dir)
// 아래 두 줄은 위의 코드와 동일하게 동작함. 내부 구현도 동일
float dot   = Vector2.Dot(lookDir, dir);
float angle = Mathf.Acos(dot) * Mathf.Rad2Deg;
 
if (angle <= m_horizontalViewHalfAngle)
{
}

Colored by Color Scripter

대상이 시야각 안에 들어왔는지 알려면 먼저 내 위치에서 상대방 위치로의 방향 벡터를 구해야합니다. 다음 AngleToDirZ 함수를 통해 시야각이 바라보고 있는 방향 벡터를 구하여 두 방향 벡터의 내적을 구하고, 구한 내적을 Acos에 넣어 Degree값으로 변환시켜주면 시야각이 바라보고 있는 방향에서 타켓의 위치까지의 각도가 나오게 됩니다. 이때 각도는 무조건 양수로만 나오기 때문에 실제론 -45(왼쪽으로 45도)라도 양수인 45도가 나오게 됩니다. 구한 각도가 HalfAngle보다 작거나 같다면 타켓은 내 시야각 안에 들어와있는 것입니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if (angle <= m_horizontalViewHalfAngle)
{
    RaycastHit2D rayHitedTarget = Physics2D.Raycast(originPos, dir, m_viewRadius, m_viewObstacleMask);
    if (rayHitedTarget)
    {
        if (m_bDebugMode)
            Debug.DrawLine(originPos, rayHitedTarget.point, Color.yellow);
    }
    else
    {
        hitedTargetContainer.Add(hitedTarget);
 
        if (m_bDebugMode)
            Debug.DrawLine(originPos, targetPos, Color.red);
    }
}
cs

타겟이 내 시야각 안에 있다는 것이 확인되면 마지막으로 대상을 가리고 있는 오브젝트가 있는지 Raycast로 확인합니다. 이때 LayerMask인 m_viewObstacleMask를 넣어줌으로써 시야 방해물을 선별적으로 지정해줄 수 있습니다. 이를 이용해 '투시가 가능한 벽'과 '투시가 불가능한 벽'을 간단히 구분지어 줄 수 있습니다. Raycast에 뭔가 맞은게 있다는 것은 타겟을 보지 못하게하는 방해물이 있다는 소리고 결과적으로 타겟을 보지 못한다는 것입니다. 반대로 Raycast에 맞은게 없다는 것은 시야 방해물이 없다는 소리이므로 타겟을 볼 수 있다는 것입니다. 이 경우 Container에 타겟을 넣어줍니다. 결국 Container에는 '내 인식 범위 안에 있고, 시야각 안에 있으며, 시야 방해물이 없어 확실히 볼 수 있는' 타켓만 들어가게 됩니다.

if (hitedTargetContainer.Count > 0)
    return hitedTargetContainer.ToArray();
else
    return null;

마지막으로 타겟들에 대한 모든 확인(foreach)이 끝났을 때 Container가 비어있지 않다면 Array로 return을, 비어 있으면 null을 return 해주면 끝이나게 됩니다.

private void OnDrawGizmos()
{
    if (m_bDebugMode)
    {
        m_horizontalViewHalfAngle = m_horizontalViewAngle * 0.5f;
 
        Vector3 originPos = transform.position;
 
        Gizmos.DrawWireSphere(originPos, m_viewRadius);
 
        Vector3 horizontalRightDir = AngleToDirZ(-m_horizontalViewHalfAngle + m_viewRotateZ);
        Vector3 horizontalLeftDir  = AngleToDirZ(m_horizontalViewHalfAngle + m_viewRotateZ);
        Vector3 lookDir = AngleToDirZ(m_viewRotateZ);
 
        Debug.DrawRay(originPos, horizontalLeftDir * m_viewRadius, Color.cyan);
        Debug.DrawRay(originPos, lookDir * m_viewRadius, Color.green);
        Debug.DrawRay(originPos, horizontalRightDir * m_viewRadius, Color.cyan);
 
        FindViewTargets();
    }
}

Colored by Color Scripter

OnDrawGizmos 함수 if 문 맨 아래에 FindViewTargets 함수를 써줍니다. 이를 통해 디버그 모드 일 때 누가 내 시야에 들어와있고 어디에 시야가 막혔는지 확인할 수 있습니다. 그럼 빌드를 하고 각종 설정을 해준 뒤 결과물을 보도록 하겠습니다.

Layer 추가

View Target Mask 및 Obstacle Target Mask 설정

Enemy 객체 Layer 설정

위 설정들의 결과

사진에 나와있듯 모든 것이 다 제대로 작동이 됩니다. 시야에 가려진 타겟은 노란 선으로 볼 수 없다는 것이 표시가 되고, 가려지지 않은 타겟은 빨간선으로 볼 수 있다는 것이 표시가 됩니다.

──────────────────────────────────

이렇게해서 2D 시야각 만들기가 끝이났습니다. 코드도 짧고 어려운 알고리즘도 없어서 이해하기 어렵지 않으셨을거라 생각합니다. 3D 시야각은 좀 더 생각해야할 것이 많지만 2D 코드에서 많은 변화가 있는 것이 아니기에 마찬가지로 이해하는데 어려움이 없으실 겁니다. 그럼 시야각(FieldOfView) 만들기 2편, 3D 시야각 만들기에서 다시 뵙겠습니다.

C++ 후위 표기식 계산기 (음수, 양수, 제곱 지원)

Muramasa — Mon, 9 Oct 2017 01:20:18 +0900

C++로 만든 후위 표기식 계산기입니다.
네이버나 구글에 C++ 후위 표기식으로 검색해보면 죄다 파일만 cpp지 C 스타일로 만들어놔서 "이게 뭐야?"싶은 마음에 만들었습니다.
짧거나 긴 식들을 넣어서 계산 시켜본 결과 네이버 계산기와 결과가 똑같았기에 계산은 정확합니다.
음수와 양수 표기, 제곱도 지원합니다. 식에 문제가 있을 때의 예외 처리도 돼있습니다.
위의 모든 처리가 다 돼있다 보니 일반적으로 돌아다니는 후위 표기식 계산기보다는 코드가 조금 더 복잡합니다.
다 만들고 보니 코드가 좀 어지 로운데다 좀 더 깔끔하고 효율적으로 수정할 여지가 있는 것 같네요.
개인적으로 좀 마음에 안드네요. 시간이 나면 좀 더 다듬어서 수정본을 올려봐야겠습니다.
코드에 대한 질문이나 의견은 댓글로 남겨주세요.

Postfix.zip

──────────────────────────────────────────────────

stdfx.h

1
2
3
4
5
6
7
8
9
10
11
12
#pragma once

#include "targetver.h"

#include <iostream>
#include <string>
#include <tuple>
#include <stack>
#include <sstream>
#include <cmath>

#include "Calculator.h"
cs

Calculator.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#pragma once

template <class T>
constexpr auto ToUType(T enumerator) noexcept
{
    return static_cast<std::underlying_type_t<T>>(enumerator);
}

class Calculator
{
private :
    enum class Symbol : char
    {
        None = 0,
        LeftParenthesis = '(', RightParenthesis = ')',
        Plus     = '+',  Minus = '-',
        Multiply = '*', Divide = '/',
        Square   = '^',
        Space    = ' ',
    };

    static const std::string kNumbers;
    static const std::string kSymbols;
    static const std::string kSpecialSymbol;

    static std::stack<char> m_stack;

private :
    static const size_t GetPriority(char cipher);

public :
    Calculator() = delete;

    static const std::tuple<bool, std::string> InfixToPostfix(const std::string& infix);
    static const std::tuple<bool, double, std::string> Calculate(const std::string& equation);
};
Colored by Color Scripter
cs

Calculator.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
#include "stdafx.h"

const std::string Calculator::kNumbers         = "1234567890.";
const std::string Calculator::kSymbols         = "()+-*/^";
const std::string Calculator::kSpecialSymbol = "+-";

std::stack<char> Calculator::m_stack;

const size_t Calculator::GetPriority(char cipher)
{
    int priority = 0;
    const Symbol symbol = static_cast<const Symbol>(cipher);

    switch (symbol)
    {
    case Symbol::Square :
        priority = 0;
        break;

    case Symbol::Multiply :
    case Symbol::Divide :
        priority = 1;
        break;

    case Symbol::Plus :
    case Symbol::Minus:
        priority = 2;
        break;

    case Symbol::LeftParenthesis:
        priority = 3;
        break;

    default :
        break;
    }

    return priority;
}

const std::tuple<bool, std::string> Calculator::InfixToPostfix(const std::string& infix)
{
    std::stack<char> stack;
    std::string         postfix;
    char chiper;

    for (int i = 0; i < infix.length(); i++)
    {
        chiper = infix[i];

        if (kNumbers.find(chiper) != std::string::npos)
        {
            postfix += chiper;
            continue;
        }
        else if (kSpecialSymbol.find(chiper) != std::string::npos)
        {
            if ((i == 0) ||
                ((kSymbols.find(infix[i - 1]) != std::string::npos) &&
                (kNumbers.find(infix[i + 1]) != std::string::npos)))
            {
                postfix += chiper;
                continue;
            }
        }
        else if (kSymbols.find(chiper) == std::string::npos)
            return std::make_tuple(false, std::string("식이 잘못됐습니다."));

        if (chiper == ToUType(Symbol::LeftParenthesis))
            m_stack.emplace(chiper);
        else if (chiper == ToUType(Symbol::RightParenthesis))
        {
            while (!m_stack.empty() && (m_stack.top() != ToUType(Symbol::LeftParenthesis)))
            {
                postfix += ToUType(Symbol::Space);
                postfix += m_stack.top();
                m_stack.pop();
            }

            if (m_stack.empty())
                return std::make_tuple(false, std::string("식이 잘못됐습니다."));
            else
                m_stack.pop();
        }
        else
        {
            postfix += ToUType(Symbol::Space);
            while (!m_stack.empty() && (GetPriority(m_stack.top()) <= GetPriority(chiper)))
            {
                postfix += m_stack.top();
                postfix += ToUType(Symbol::Space);
                m_stack.pop();
            }
            m_stack.emplace(chiper);
        }
    }

    while (!m_stack.empty())
    {
        if (m_stack.top() == ToUType(Symbol::LeftParenthesis))
            return std::make_tuple(false, "식이 잘못됐습니다.");
        else
        {
            postfix += ToUType(Symbol::Space);
            postfix += m_stack.top();
            m_stack.pop();
        }
    }

    return std::make_tuple(true, postfix);
}

const std::tuple<bool, double, std::string> Calculator::Calculate(const std::string& equation)
{
    auto inToPostResult = InfixToPostfix(equation);
    if (!std::get<0>(inToPostResult))
        return std::make_tuple(std::get<0>(inToPostResult), 0, std::get<1>(inToPostResult));

    std::stack<double> stack;
    std::string chiper = "";
    std::stringstream equationStream(std::get<1>(inToPostResult));
    std::stringstream numberStream;

    double tempNum = 0;
    double rNum       = 0;
    double lNum    = 0;

    while (!equationStream.eof())
    {
        equationStream >> chiper;
        if (kSymbols.find(chiper) == std::string::npos)
        {
            numberStream.str(chiper);
            numberStream.clear();
            numberStream >> tempNum;
            stack.emplace(tempNum);
        }
        else
        {
            if (stack.size() < 2)
                return std::make_tuple(false, 0, std::string("식이 잘못됐습니다."));

            rNum = stack.top();
            stack.pop();
            lNum = stack.top();
            stack.pop();

            Symbol symbol = static_cast<const Symbol>(chiper[0]);
            switch (symbol)
            {
            case Symbol::Plus :
                stack.emplace(lNum + rNum);
                break;

            case Symbol::Minus :
                stack.emplace(lNum - rNum);
                break;

            case Symbol::Multiply :
                stack.emplace(lNum * rNum);
                break;

            case Symbol::Divide :
                stack.emplace(lNum / rNum);
                break;

            case Symbol::Square :
                stack.emplace(pow(lNum, rNum));
                break;

            default:
                break;
            }
        }
    }

    return std::make_tuple(true, stack.top(), std::string());
}
Colored by Color Scripter
cs

Main.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include "stdafx.h"

int main()
{
    while (true)
    {
        std::string infix = "";

        std::cout << "수식을 입력해주세요 : ";
        std::cin >> infix;

        auto resultTuple = Calculator::Calculate(infix);
        if (std::get<0>(resultTuple))
        {
            double        result = std::move(std::get<1>(resultTuple));
            std::string postfix = std::move(std::get<1>(Calculator::InfixToPostfix(infix)));

            std::cout << "Infix : " << infix << std::endl;
            std::cout << "Postfix : " << postfix << std::endl;
            std::cout << "Result : " << result << std::endl << std::endl;
        }
        else
            std::cout << std::get<2>(resultTuple) << std::endl << std::endl;
    }
    return 0;
}
Colored by Color Scripter
cs

C++11 난수(Random)

Muramasa — Mon, 9 Oct 2017 01:11:04 +0900

[The C++ Programming Language에서 발췌]

난수는 테스트, 게임, 시뮬레이션, 보안 등의 많은 상황에서 유용하다. <random>에서 표준 라이브러리가 제공하는 폭넓은 난수 생성기의 선택 폭은 이러한 응용 영역의 다양성을 대변하는 것이다. 난수 생성기는 두 부분으로 구성된다.

[1] 난수나 의사 난수 값의 시퀸스를 생성하는 엔진

[2] 이러한 값들을 일정 범위의 수학적 분포로 매피아는 분포

분포 예로는 uniform_int_distribution(생성되는 모든 정수가 동일한 확률을 갖는다.), normal_distribution('종형 곡선'), exponential_distribution(지수 성장 곡선)이 있는데, 각각은 어떤 특정한 범위를 나타낸다. 다음의 예를 살펴보자.

1
2
3
4
5
6
7
8
using my_egine = default_random_engine;                // 엔진의 타입
using my_distirbution = uniform_int_distribution<>; // 분포의 타입
 
my_engine re {};
my_distribution one_to_six {1, 6};
auto die = bind(one_to_six, re); // one_to_six(re)와 동일함
 
int x = die();
Colored by Color Scripter
cs

표준 라이브러리 함수 bind()는 두 번째 인자를 인자로 해서 첫 번째 인자를 호출할 것이다. 따라서 die() 호출은 one_to_six(re)를 호출하는 것과 동일하다.

범용성과 성능에 대한 철저한 집중 덕택에 한 전문가는 표준 라이브러리의 난수 구성 요소를 '모든 난수 라이브러리가 궁극적으로 원하는 목표'라는 의견을 밝힌 바 있다. 하지만 표준 라이브러리의 난수 구성 요소가 '초심자에게 친숙'하다고 보기는 어려울 수 있다. using문은 기존의 방식을 좀 더 명확하게 표현해준다. 그 방법 대신에 단순히 다음과 같이 작성할 수도 있다

1
auto die = bind(uniform_int_distribution<>{1, 6}, default_random_engine{});
cs

어떤 버전이 좀 더 이해하기 쉬운가는 전적으로 상황과 독자에 따라 다르다.

초심자에게는 난수 라이브러리에 대해 완벽하게 범용적인 인터페이스는 상당히 난관이 될 수 있다. 많은 경우에는 간단한 균등 난수 발생기로 시자개도 충분하다. 예를 들면 다음과 같다.

1
2
Rand_int rnd {1, 10}; // [1:10]에 대한 난수 발생기를 만든다.
int x = rnd();          // x에 [1:10]에 속하는 숫자다.
cs

그러면 이것들을 어디에서 얻는단 말인가? die() 같은 건 Rand_int 클래스에서 얻어야 한다.

1
2
3
4
5
6
7
8
9
10
11
12
class Rand_int
{
private :
    default_random_engine re;
    uniform_int_distribution<> dist;
 
public :
    Rand_int(int low, int high)
        : dist {low, high} {}
 
    const int operator()() { return dist(re); }
}

Colored by Color Scripter
cs

이러한 정의는 여전히 '전문가 수준'이지만, Rand_int()는 C++ 초보자 코스에 첫 번째주에서도 활용할 수 있다. 다음의 예를 살펴보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int main()
{
    Rand_int rnd {0, 4};          // 균등 난수 발생기를 만든다.
    
    vector<int> histogram(5); // 크기 5의 벡터를 만든다.
    for (int i = 0; i != histogram.size(); i++)
        ++histogram[rnd()];   // 히스토그램을 [0:4] 범위 숫자의 등장 빈도로 채운다.
 
    for (int i = 0; i != histogram.size(); i++) // 막대 그래프를 출력한다.
    {
        cout << i << '\t';
        for (int j =0; j != histogram[i]; j++)
            cout << endl;
    }
}
Colored by Color Scripter
cs

출력은 균등 분포다.

0 ******************************

1 ***************************

2 *********************

3 ***************************

4**************************

─────────────────────────────────

[예제 코드]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <functional>
#include <random>
using std::cout;
using std::endl;
using std::bind;
 
auto main(void) -> int
{
    // 랜덤 디바이스 생성
    std::random_device randDeivce;    
    // 예측 불가능 난수 엔진 생성 및 랜덤 디바이스 세팅
    std::default_random_engine randEngine{ randDeivce() };
    
    // -3부터 3까지의 랜덤 정수 출력
    std::uniform_int_distribution<int> dist1{ -3, 3 };
    cout << dist1(randEngine) << endl;
 
    // 1.5부터 3.5까지의 랜점 실수 출력
    std::uniform_real_distribution<double> dist2{ 1.5, 3.5 };
    cout << dist2(randEngine) << endl;
 
    // 정규 분포 (평균, 표준 편차)
    std::normal_distribution<double> dist3{ 2.0, 1.0 };
    cout << dist3(randEngine) << endl;
 
    // 베르누이 분포, (확률(0.0 ~ 1.0)), 성공하면 true를 실패하면 false를 반환함. 
    std::bernoulli_distribution dist4{ 0.7 };
    cout << dist4(randEngine) << endl;
 
    // 베르누이 분포, (시도 횟수, 확률(0.0 ~ 1.0)), 성공한 횟수를 반환 
    std::binomial_distribution<int> dist5{ 100, 0.5 };
    cout << dist5(randEngine) << endl;
 
    // bind함수로 난수 클래스와 엔진을 하나로 묶는다.
    auto bindDist = bind(std::uniform_int_distribution<int> { -1, 1 }, randEngine);
    cout << bindDist() << endl;
}
Colored by Color Scripter
cs

C++11 시간 Chrono

Muramasa — Mon, 9 Oct 2017 01:09:25 +0900

[The C++ Programming Language에서 발췌]

표준 라이브러리는 시간을 다루기 위한 기능을 제공한다. 예를 들면 뭔가의 시간을 맞추는 기본적인 방법은 다음과 같다.

1
2
3
4
5
6
using namespace std::chorono;
 
auto t0 = high_resolution_clock::now();
do_work();
auto t1 = high_resolution_clock::now();
cout << duration_cast<milliseconds>(t1 - t0).count() << "msec\n";;
cs

시계는 time_point(시간상 어떤 지점)를 반환한다. 두 개의 time_point로 뺄셈을 수행하면 duration(시간의 기간)이 얻어진다. 다양한 시계들이 다양한 시간의 단위로 결과를 보여주므로(여기서 사용한 시계는 nameseconds 단위를 사용했다), 대체적으로 duration을 알려진 단위로 변환하는 편이 바람직하다. duration_cast가 하는 일이 발 그것이다.

시간을 다루는 표준 라이브러리 기능은 <chrono>에 들어 있는 부분 네임스페이스 std::chrono에서 찾을 수 있다.

먼저 시간을 측정해보지도 않고 코드의 '효율성'에 대해 단정하지 말기 바란다. 성능에 대한 측정은 대부분 신뢰하기 힘들다.

─────────────────────────────────

[예제 코드]

[진행 시간 출력]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
#include <iostream>
#include <chrono>
using namespace std::chrono;
using std::cout;
using std::endl;
 
auto main(void) -> int
{
    steady_clock::time_point startTime = steady_clock::now(); // 물리적 고정 시간
    // system_clock::time_point startTime = system_clock::now(); 컴퓨터 시스템 시간
 
    while (true)
    {
        steady_clock::time_point endTime = steady_clock::now();
        duration<double> currentTime = endTime - startTime;
        cout << currentTime.count() << endl;
    }
}
Colored by Color Scripter
cs

[시간을 초 단위로 출력]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <chrono>
using namespace std::chrono;
using std::cout;
using std::endl;
 
auto main(void) -> int
{
    steady_clock::time_point startTime = steady_clock::now(); // 물리적 고정 시간
    // system_clock::time_point startTime = system_clock::now(); 컴퓨터 시스템 시간
 
    while (true)
    {
        steady_clock::time_point endTime = steady_clock::now();
        seconds currentSeconds = duration_cast<seconds>(endTime - startTime);
        // duration_cast<seconds> 시간을 초 단위로 캐스팅
        cout << currentSeconds.count() << endl;
    }
}
Colored by Color Scripter
cs

[시간을 분 단위로 출력]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <chrono>
using namespace std::chrono;
using std::cout;
using std::endl;
 
auto main(void) -> int
{
    steady_clock::time_point startTime = steady_clock::now(); // 물리적 고정 시간
    // system_clock::time_point startTime = system_clock::now(); 컴퓨터 시스템 시간
 
    while (true)
    {
        steady_clock::time_point endTime = steady_clock::now();
        minutes currentSeconds = duration_cast<minutes>(endTime - startTime);
        // duration_cast<minutes> 시간을 분 단위로 캐스팅
        cout << currentSeconds.count() << endl;
    }
}
Colored by Color Scripter
cs

[시간을 시 단위로 출력]

#include <iostream>
#include <chrono>
using namespace std::chrono;
using std::cout;
using std::endl;
 
auto main(void) -> int
{
    steady_clock::time_point startTime = steady_clock::now(); // 물리적 고정 시간
    // system_clock::time_point startTime = system_clock::now(); 컴퓨터 시스템 시간
 
    while (true)
    {
        steady_clock::time_point endTime = steady_clock::now();
        hours currentSeconds = duration_cast<hours>(endTime - startTime);
        // duration_cast<minutes> 시간을 시 단위로 캐스팅
        cout << currentSeconds.count() << endl;
    }
}

Colored by Color Scripter

[나노초 단위로 출력]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <chrono>
using namespace std::chrono;
using std::cout;
using std::endl;
 
auto main(void) -> int
{
    steady_clock::time_point startTime = steady_clock::now(); // steady_clock은 물리적 시간
    // system_clock::time_point startTime = system_clock::now(); 컴퓨터 시스템 시간
 
    while (true)
    {
        steady_clock::time_point endTime = steady_clock::now();
        nanoseconds currentSeconds = duration_cast<nanoseconds>(endTime - startTime);
        // duration_cast<minutes> 시간을 나노초 단위로 캐스팅
        cout << currentSeconds.count() << endl;
    }
}
Colored by Color Scripter
cs

[high_resolution_clock과 밀리초 단위로 출력]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <chrono>
using namespace std::chrono;
using std::cout;
using std::endl;
 
auto main(void) -> int
{
    high_resolution_clock::time_point startTime = high_resolution_clock::now();
    // high_resolution_clock는 해당 플랫폼(Windows, Mac 등)에서 가장 짧은 단위의 시간
 
    while (true)
    {
        high_resolution_clock::time_point endTime = high_resolution_clock::now();
        milliseconds currentSeconds = duration_cast<milliseconds>(endTime - startTime);
        // duration_cast<minutes> 시간을 밀리세컨드 단위로 캐스팅
        cout << currentSeconds.count() << endl;
    }
}
Colored by Color Scripter
cs

C++11 별칭(using)

Muramasa — Mon, 9 Oct 2017 00:58:02 +0900

[The C++ Programming Language에서 발췌]

뜻밖에도 타입이나 템플릿에 대해 별명을 도입하는 것이 유용할 때가 많다. 예를 들어 표준 헤더 <cstddef>에는 아마도 다음과 같은 별칭 size_t에 대한 정의가 포함돼 있을 것이다.

1
using size_t = unsigned int;;
cs

size_t란 이름이 붙은 실제의 타입은 구현별 정의 사항이므로, 다른 구현에서는 size_t가 unsigned long일 수도 있다. 별칭 size_t를 쓰면 프로그래머가 이식 가능한 코드를 작성하는데 도움이 된다.

타입의 템플릿 인자와 관련된 타입 별칭은 많은 경우 매개변수화 타입에 의해 제공된다. 예를 들면 다음과 같다.

1
2
3
4
5
6
template<typenae T>
class Vector {
public :
    using value_type = T;
    //...
}
cs

실제로 모든 표준 라이브러리 컨테이너는 자신의 값 타입의 이름으로 value_type을 제공한다. 이 덕택에 이런 규약을 따르는 모든 컨테이너에서 동작되는 코드를 작성할 수 있다. 예를 들면 다음과 같다.

1
2
3
4
5
6
7
8
template<typename C>
using Value_type = typename C::value_type;
 
void algo(Container& c)
{
    Vector<value_type<Container>> vec;
    // ... vec를 사용한다 ...
}
Colored by Color Scripter
cs

별칭 메커니즘은 템플릿 인자의 일부 또는 전부를 연결해서 새로운 템플릿을 정의하는데 사용될 수 있다. 예를 들면 다음과 같다.

1
2
3
4
5
6
7
8
template<typename Key, typename Value>
class Map {
    // ...
}
 
template<typename Value>
using String_map = Map<string, Value>;
String_map<int> m; // m은 Map<string, int>ㅣ다.
cs

C++11 가변 인자 템플릿

Muramasa — Sun, 8 Oct 2017 22:48:53 +0900

[The C++ Programming Language에서 발췌]

템플릿은 임의의 타입의 인자를 임의의 개수만큼 받아들이도록 정의될 수 있다. 그러한 템플릿을 가변 인자 템플릿이라고 부른다. 예를 들면 다음과 같다.

1
2
3
4
5
6
7
void f() {}
template<typename T, typename... Tail>
void f(T head, Tail... tail)
{
    g(head);
    t(tail...);
}
Colored by Color Scripter
cs

가변 인자 템플릿 구현이 핵심은 그것에 인자 리스트를 전달할 때 첫 번째 인자를 나머지와 분리할 수 있다는 점에 주목하는 것이다. 여기서는 첫 번째 인자(head)에 뭔가를 한 다음, 나머지 인자(tail)로 재귀적으로 f()를 호출한다. 생략 부호...은 리스트의 '나머지'를 나타내기 위해 사용됐다. 물론 결국에 가서는 tail이 비워지게 되고 그것을 처리하기 위해 별도의 함수가 필요하게 될 것이다. 이 f(0는 다음과 같이 호출 될 수 있다.

1
2
3
4
5
6
7
8
9
int main()
{
    cout << "first: ";
    f(1, 2.2, "hallo");
 
    cout << "\nsecond: ";
    f(0.2, 'c', "yuck!", 0, 1, 2);
    cout << "\n";
}
cs

이렇게하면 순서대로 f(1, 2.2, "hello")를 호출하고, 이것은 call f(2.2, "hello")를 호출하고, 이것은 f("hello")를 호출하고, 이것은 f()를 호출하게 될 것이다. g(head)를 호출하면 어떻게 될 것인가? 당연히 실제 프로그램에서는 각 인자에 대해 우리가 원하는 처리를 수행하게 될 것이다. 예를 들면 그것의 인자(여기서는 head)를 출력하게 만들 수 있다.

1
2
3
4
5
template<typename T>
void g(T x)
{
    cout << x << " ";
}
cs

이 경우 출력은 다음과 같을 것이다.

first : 1 2.2 hello

second: 0.2 c yuck! 0 1 2

f(0는 세 줄짜리 코드와 관련된 선언문으로 구현돼 있어 임의의 리스트나 값을 출력하는 printf()의 간단한 변형처럼 보인다.

가변 인자 템플릿의 강점은 우리가 그것에 부여하려는 어떤 인자든지 받아들일 수 있다는 점이다. 약점은 인터페이스의 타입 체크가 번거로운 템플릿 프로그램이 될 수도 있다는 점이다.

C++11 상수 constexpr

Muramasa — Sun, 8 Oct 2017 22:47:18 +0900

[The C++ Programming Language에서 발췌]

constexpr은 대략 '컴파일 타임에 평가될 예정'이라는 의미다. 이것은 주로 상수를 지정하는 데 사용되며, 데이터가 읽기 전용 메모리내에 저장되도록 해주고 성능을 높여준다. 다음의 예를 살펴보자.

1
2
3
4
5
6
7
8
9
const int dmv = 17;                          // dmv는 이름을 가진 상수
int var = 17;                                // var는 상수가 아니다.
constexpr double max1 = 1.4 * square(dmv);   // square(17)이 상수 표현식인 경우 OK
constexpr double max2 = 1.4 * square(var);   // 오류 : var는 상수 표현식이 아니다.
const double max3 = 1.4 * square(var);       // OK, 런타임에 평가될 수 있다.
double sum(const vector<double>&);           // sum은 자신의 인자를 수정하지 못할 것이다.
vector<double> v { 1.2, 3.4, 4.5 };          // v는 상수가 아니다.
const double s1 = sum(v);                    // OK, 런타임에 평가될 수 있다.
constexpr double s2 = sum(v);                // 오류 : sum(v)는 상수 표현식이 아니다.
cs

함수가 상수 표현식, 즉 컴파일러에 의해 평가될 표현식 내에서 사용되려면 constexpr로 정의돼야 한다. 예를 들면 다음과 같다.

1
constexpr double square(double x) { return x * x; }
cs

constexpr이 되려면 함수는 상당히 간단해야 한다. 즉, 값을 계산하는 return문일 경우에만 가능하다. constexpr 함수는 상수가 아닌 인자에 대해 사용될 수도 있지만, 그런 경우의 결과는 상수 표현식이 아니다. constexpr 함수는 상수 표현식을 요구하지 않는 상황에서만 상수가 아닌 표현식 인자로 호출될 수 있으므로, 실질적으로 동일한 함수를 두번 정의할 필요는 없다. 한 번은 상수 표현식에 대한, 한 번은 변수에 대한 식으로 정의할 필요가 없다는 뜻이다.

몇 가지 경우에는 언어 규칙에서 상수 표현식을 요구한다.(예를 들면 배열 경계, case 레이블, constexpr를 이용해서 선언된 상수). 어떠 경우에는 컴파일 타임 평가가 성능을 위해 필요하기도 하다. 성능 이유는 제쳐두고라도 불변성의 개념은 설계에서 중요한 고려 사항이다.

[C++14부턴 constexpr 함수 내부 지역 변수와 연산이 존재해도 상관없음]

C++11 auto와 decltype

Muramasa — Sun, 8 Oct 2017 22:43:49 +0900

[The C++ Programming Language에서 발췌]

C++는 표현식으로부터 타입을 추론하기 위해 두 가지의 매커니즘을 제공한다.

● 초기화 식으로부터 객체의 타입을 추론하기 위한 auto로, 타입은 변수, const, constexpr의 타입이 될 수 있디.

● 함수의 반환 타입이나 클래스 멤버의 타입 같이 간단한 초기화 식이 아닌 뭔가의 타입을 추론하기 위한 decltype(expr)이다.

여기서 수행되는 추론은 매우 간단한다. 즉, auto와 decltype()은 컴파일러가 이미 알고 있는 표현식의 타입을 알려주기만 할 뿐이다.

1.1 auto 타입 지정자

변수의 선먼문에 초기화 식이 있을 때는 타입을 명시적으로 지정할 필요가 없다. 대신 변수가 자신의 초기화 식에 해당하는 타입을 갖게 할 수 있다. 다음을 살펴보자.

1
2
3
int  a1 = 123;
char a2 = 123;
auto a3 = 123; // 3의 타입은 "int"
cs

정수 리터럴 123의 타입은 int이므로 a3는 int다. 즉, auto는 초기화 식 타입의 보관 장소다. 123처럼 간단한 표현식에서 int 대신에 auto를 사용하는 건 큰 도움이 되지 않는다. 타입이 쓰기 어렵고 파악하기 어려울수록 auto가 좀 더 빛을 발한다. 예를 들어 다음과 같다.

1
2
3
4
5
6
7
8
9
10
template <typename T>
void f1(vector<T>& arg)
{
    for (typename vector<T>::iterator p = arg.bggin(); p != arg.end(); p++)
        *p = 7;
 
    for (auto p = arg.begin(); [ != arg.end(); p++)
        *p = 7;
}
 
Colored by Color Scripter
cs

auto를 사용하는 루프가 작성하기도 좀 더 편하고 읽기에도 좀 더 편하다. 또한 코드 변경에도 좀 더 유연하게 대응할 수 있다. 이를테면 arg를 list로 바꿔도 auto를 사용하는 루프는 정확히 동작하는 반면, 첫 번째 루프는 재작성이 필요할 것이다. 그러므로 특별한 이유가 있지 않는 한 auto는 작은 유효 범위로 사용하기 바란다.

유효 범위가 지나치게 넓으면 타입을 명시적으로 언급함으로써 오류의 영향을 줄일 수 있다. 즉, 구체적인 타입을 사용하는 방식과 비교할 때 auto를 사용하면 타입 오류의 탐지를 지연시킬 수 있다. 예를 들면 다음과 같다.

1
2
3
4
5
6
7
8
void f(complex<double> d)
{
    // ...
    auto   max = d + 7;
    double min = d - 9;
    // ...
}
 
cs

auto가 문제를 일으키면 최선의 태처법은 대개 함수를 좀 더 작게 만드는 것인데, 이 방식은 어쨋든 대부분 의 경우 좋은 방법이다.

추론된 타입은 const나 & 같은 지정자나 수정자로 장식할 수 있다. 예를 들면 다음과 같다.

1
2
3
4
5
6
7
void f(vector<int>& v)
{
    for (const auto& x : v) // x는 const int&
    {
        // ...
    }
}
Colored by Color Scripter
cs

여기서 auto는 v의 원소 타입으로 결정되는데, 즉 int다.

참조는 표현식에서 암시적으로 역참조되기 때문에 표현식의 타입은 절대로 참조가 될 수 없다는 점에 유의하다.

1
2
3
4
5
void g(int& v)
{
    auto  x = v; // x는 int
    auto& y = v; // y는 int&
}Colored by Color Scripter
cs

1.2 auto와 {} 리스트

초기화하는 객체의 타입을 명시적으로 지정하는 경우 두 개의 타입을 고려해야 하는데, 객체의 타입과 칙화 식의 타입이 그것이다. 다음 예를 살펴보자.

1
2
3
char v1 = 12345; // 12345는 int
int  v2 = 'c';   // 'c'는 char
T v3 = f();
cs

그러한 정의에 {} 초기화 식 문법을 사용함으로써 우려스러운 변환의 가능성을 최소화한다.

1
2
3
char v1 { 12345 }; // 오류 : 축소
int  v2 { 'c' };   // 문제없음 : 암시적 char->int 변환
T    v3 { f() };   // f()의 타입이 묵시적으로 T로 변환 가능할 때만 동작
cs

auto를 사용할 때는 오직 하나의 타입, 즉 초기화 식의 타입만이 연관되며, = 문법을 안전하게 사용할 수 있다.

1
2
3
auto v1 = 12345; // v1은 int
auto v2 = 'c';   // v2는 char
auto v3 = f();   // v3는 적절한 어떤 타입
cs

실제로는 auto를 =와 함께 사용하는 방식이 유리할 수 있는데, {} 리스트 문법이 누군가에는 낯설 수 있기 때문이다.

1
2
3
auto v1 { 12345 }; // v1은 int의 리스트
auto v2 { 'c' };   // v2는 char의 리스트
auto v3 { f() };   // v3는 적절한 어떤 타입의 리스트
cs

여기에는 논리적 문제가 없다. 다음을 살펴보자.

1
2
3
4
auto x0 {};          // 오류 : 타입을 추론할 수 없다.
auto x1 { 1 };       // 한 개의 원소를 갖는 int의 리스트
auto x2 { 1, 2 };    // 두 개의 원소를 갖는 int의 리스트
auto x3 { 1, 2, 3 }; // 세 개의 원소를 갖는 int의 리스트
cs

동일한 종류의 T 타입 원소로 이뤄진 리스트의 타입이 Initializer_list<T> 타입인 것으로 받아들여진다. 특히 x1의 타입은 int로 추론되지 않는다. 특히 x1의 타입은 int로 추론되지 않는다. 그랬었다면 x2와 x3의 타입은 무엇으로 됐겠는가?

결론적으로 '리스트'로 사용하지 않을 것이라면 auto 지정된 객체에는 {}보다 =를 사용하기를 권장한다.

2. decltype() 지정자

적합한 초기화 식이 있다면 auto를 사용할 수 있다. 하지만 경우에 따라 초기화된 변수를 정의하지 않고 타입이 추론되기를 원할 수도 있다. 그러한 경우에 선언 타입 지정자인 decltype(expr)을 사용할 수 있는데, 이 지정자는 expr의 선언된 타입이다. 이 지정자는 일반화 프로그래밍에서 가장 유용하다. 서로 다른 원소 타입을 가질 가능성이 높은 두 개의 행렬을 더하는 함수를 작성한다고 가정해보자. 덧셈의 결과 타입은 무엇이 돼야 하겠는가? 당연히 결과는 행렬이 되겠지만, 그 행렬의 타입은 무엇이 돼야 할까? 명백히 답은 덧셈의 원소 타입은 원소를 더한 것의 타입이라는 것이다. 따라서 다음과 같이 선언할 수 있다.

1
2
template <typename T, typename U>
auto operator+(const Matrix<T>& a, const Mateix<U>& b) -> Matrix<decltype(T{} + U{})>;
cs

여기서는 Matrix<decltype(T{} + U{})>와 같이 인자라는 관점에서 반환 타입을 표현하기위해 접미사 반환 타입 문법을 활용한다. 즉, 결과는 원소 타입을 가진 Matrix로서 인자 Matrixes(T{} + U{})에 포함된 두 개의 원소를 더한 결과에서 얻어지는 것이다.

정의에서 Matrix의 원소 타입을 표현하기 위해 또 한 번 decltype()이 필요하다.

1
2
3
4
5
6
7
8
9
template <typename T, typename U>
auto operator+(const Matrix<T>& a, const Matrix<U>& b) -> Matrix<decltype(T{} + U{})>
{
    Matrix<decltype(T{} + U{}> res;
    for (int i = 0; i < != a.Rows(); i++)
        for (int j = 0; j != a.Cols(); j++)
                res(i, j) += (a(i, j) + b(i,j));
    return;
}
Colored by Color Scripter
cs

[C++14부턴 반환형으로 뒤에 decltype을 쓸 필요 없이 auto만 써줘도 됨.]

C++11 리스트 초기화

Muramasa — Sun, 8 Oct 2017 22:39:19 +0900

[The C++ Programming Language에서 발췌]

어떤 객체의 초기화 식이 지정되면 해당 객체의 초기 값이 결정된다. 초기화 식은 4가지 문법 스타일 중 하나를 사용한다.

1
2
3
4
int a1 { 1 };
int a2 = { 1 };
int a3 = 1;
int a4(1);
cs
 

이들 중 첫 번째 항목만이 모든 상황에서 사용될 수 있으므로, 그것을 사용하기를 강력히 권장한다. 다른 후보들보다 좀 더 명확하며, 오류에 취약하지 않다.

{}를 사용한 초기화, 리스트 초기화는 축소를 허용하지 않는다.

● 정수는 자신의 값을 보관할 수 없는 또 다른 정수로 변환될 수 없다. 예를 들어 char에서 int로의 변환은 허용되지만, int에서 char는 허용되지 않는다.

● 부동소수점 값은 자신의 값을 보관할 수 없는 또 다른 부동소수점 타입으로 변환될 수 없다. 예를 들어 float에서 double로의 변환은 허용되지만, double에서 float는 허용되지 않는다.

● 부동소수점 값은 정수 타입으로 변환될 수 없다.

● 정수 값은 부동소수점 타입으로 변환될 수 없다.

예를 들면 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
void f(double val, int val2)
{
    int x2 = val;    // val == 7.9라면 x2는 7이 된다.
    int c2 = val2;   // val2 == 1025라면 c2는 1이 된다.
 
    int x3 { val };  // 오류 : 손실 가능성
    int c3 { val2 }; // 오류 : 축소 가능성
 
    char c4 { 24 };  // OK : 24는 char로 정확히 표시될 수 있다.
    char c5 { 264 }; // 오류(char가 8비트라 가정할 경우} : 264는 char로 표시될 수 있다.
 
    int x4 { 2.0 };  // 오류 : double에서 int 값으로 변환은 불가능
}
Colored by Color Scripter
cs

초기화 식에 의해 결정된 타입을 구하기 위해 auto를 사용할 때는 {} 초기화 식 사용에 이점이 없다. 초기화 식이 {} 리스트일 경우 우리는 리스트의 타입이 추정되기를 원하지 않을지도 모르기 때문이다. 예를 들어 다음과 같다.

1
2
auto z1 { 99 }; // z1은 initializer_list<int>
auto z2 = 99;   // z2는 int
cs
 

따라서 auto를 사용할 때는 =가 바람직하다.

빈 초기화 식 리스트 {}는 기본 값을 넣겠다는 의미를 나타내는 데 사용된다. 예를 들면 다음과 같다.

1
2
3
4
5
int x4 {};
double d4 {};
char* p {};
vector<int> v4{};
string s4 {};
cs

대부분의 타입은 기본 값을 갖고 있다. 통합 정수 타입의 경우에는 기본 값으로 0을 적절히 표시한다. 포인터의 경우에는 기본 값이 nullptr이다. 사용자 정의 타입에서는 기본 값이 존재할 경우 해당 타입의 생정자에 의해 결정된다.

C++ 프로그래머를 위한 권고 사항

Muramasa — Sun, 8 Oct 2017 22:32:09 +0900

[The C++ Programming Language]

1. 생성자를 이용해서 불변속성을 구축한다.

2. 생성자/소멸자 쌍을 이용해서 자원 관리를 간소화한다.
3. '무방비'의 new와 delete를 삼간다.
4. 기본 제공 배열이나 임시 코드보다 컨테이너와 알고리즘을 이용한다.
5. 그때그때 개발된 코드보다는 표준 라이브러리 코드를 우선 사용한다.
6. 지역적으로 통제할 수 없는 오류를 알리기 위해서는 오류 코드보다는 예외를 사용한다.
7. 대규모 객체의 복사를 피하귀 위해 이동 의미의 구조를 사용한다.
8. unique_ptr을 이용해서 다형성 타입의 객체를 참조한다.
9. shared_ptr을 이용해서 공유 객체를 참조한다. 공유 객체란 단독의 소유자가 자신의 소멸을 담당하지 않는 객체를 말한다.