PQC Verified

모던 C++로 계산기 만들기

by gg582 · 2026-11-05 07:29:07 · 30 views · 9 min read

Table of contents

Template, Concept 등의 모던 C++ 개념을 다룰 때는 이론을 차례로 나열하기보다, 실제 돌아가는 코드를 직접 만들어 보며 병목이 되는 지점을 짚는 편이 직관적입니다.

앞선 포스트를 기억하시나요? 컨셉트에 대한 글이었죠.

이 글의 말미에 언급했던 문장이 한 가지 있습니다.

우리는 간단한 사칙 연산, 그리고 괄호 파싱, 형 변환 기능 추가를 통해서 ./cppcal "a=10;b=10.2;c=a+b;print c"는 해석에 실패하고, ./cppcal "a=float(10);b=10.2;c=a+b;print c"는 해석할 수 있는 계산기를 만들 것이다.

우선 "그 컨셉트라는 게 어느 쪽에 들어가라는 건데?"가 핵심 질문입니다.

초점은 ./cppcal "a=10;b=10.2;c=a+b;print c"를 해석 실패로 떨어뜨리는 데 있습니다.

a는 정수형, b는 실수형입니다. 사람은 둘을 더할 때 자연스럽게 실수를 가정하지만, 이 계산기는 암시적 형변환을 일절 허용하지 않습니다. 두 피연산자의 타입이 정확히 일치하는지, 그리고 해당 연산자 함수 객체 Op를 적용해도 동일한 결과 타입이 유지되는지 검사해야 합니다.

가감승제 기본 연산만 다루므로 규칙은 단순합니다.

그렇다면 구수략 갑 편에서도 나온 정수 사칙연산의 기본 법칙을 떠올려 보게 됩니다. 부호에 있어서는 지수 이상혁의 "익산 정부론 편"에서 짚고 넘어간 성질만으로 뺄셈을 이해할 수 있습니다.

곱셈은 반복된 덧셈이고, 나눗셈은 곱셈의 역원이다. 뺄셈은 음수(부호가 양이 아닌 수)를 더하는 것이다.

수학적으로는 정수 나눗셈의 결과가 실수가 될 수 있지만, C/C++ 정수 나눗셈은 소수점을 버리고 0을 반환합니다.

int x = 1;
int y = 3;
int z = 1/3;

z는 0이 됩니다. 이 구현에서는 굳이 타입 승격을 지원하지 않고 언어 스펙의 방식을 그대로 따릅니다.

이를 반영한 제약식은 다음과 같습니다.

template <typename T1, typename T2, typename Op>
concept CalculableSame = std::same_as<T1, T2> && requires(T1 a, T2 b, Op op) {
    // Requires that T1 and T2 are identical types,
    // and invoking op(a, b) yields the same type T1 without implicit conversion.
    { op(a, b) } -> std::same_as<T1>;
};

std::same_as<T1, T2>에 더해, op(a, b) 호출 결과 역시 원본 타입 T1을 반환하는지 컴파일 타임에 강제합니다.

연산을 수행하는 함수입니다.

template <typename Op>
NumType applyBinaryOp(const NumType &l, const NumType &r, Op op) {
    return std::visit([op](auto &&a, auto &&b) -> NumType {
        using T1 = std::decay_t<decltype(a)>;
        using T2 = std::decay_t<decltype(b)>;
        using CleanOp = std::decay_t<Op>;

        if constexpr (CalculableSame<T1, T2, CleanOp>) {
            return op(a, b);
        } else {
            std::cerr << "err: type mismatch" << std::endl;
            std::exit(1);
        }
    }, l, r);
}

런타임에 에러 낼 거면 l.index() == r.index()로 때우지 왜 굳이 std::visit 돌리고 if constexpr에 Concept까지 얹었냐 싶을 수 있습니다.

지금이야 NumType에 long long, double 둘뿐이라 2 \times 2 분기로 끝나지만, 나중에 타입 서너 개만 더 붙어도 인덱스 비교나 switch문은 N \times N만큼 징그럽게 많아집니다. 반면 Concept로 묶어두면 std::visit 풀릴 때 컴파일러가 연산 가능한 조합만 본문 코드로 남기고, 안 되는 건 모조리 else로 떨어뜨립니다. 런타임에 손으로 짤 타입 검사를 컴파일러한테 통째로 떠넘겨서 확장성을 챙기는 셈입니다.

솔직히 코드만으로 논리를 이해할 수 있는 무식함은 반감되죠. 개인적이지만, C나 초기 언어들에 비해 이런 점은 의외로 단점이라고 생각합니다.

람다 매개변수의 auto &&는 variant 안의 알맹이를 쓸데없는 복사 없이 그대로 물고 들어오는 포워딩 레퍼런스입니다. 바인딩된 a, b는 참조자나 const가 묻어있을 수 있으니, decltype으로 뽑고 std::decay_t로 껍데기를 다 벗겨서 순수 타입만 제약식에 넘깁니다. Op도 마찬가지로 참조 한정자를 날린 CleanOp로 만들어서 검사합니다.

사칙연산마다 거의 동일한 루틴을 반복 작성할 필요 없이, std::plus<>, std::minus<>, std::multiplies<>, std::divides<> 같은 표준 함수 객체를 인자로 넘기면 하나의 함수 템플릿으로 수렴합니다.

실리콘밸리에서 흔히 끌어오는 바흐 비유와 달리, 현대 프로그래밍의 실제 흐름은 J.S 바흐보단 J.C 바흐에 가깝습니다.

물론 J.S 바흐 역시 대단한 실용주의자였지만, J.C 바흐 방식에 가깝다고 말하는 건 "순간의 인상"이 구조적 통제력보다 우선하는 태도에 대해 짚고 넘어가려는 겁니다.


이 타입 중 하나면 컴파일러가 처리해 줄게! std::variant

std::variant도 그런 실용주의적 흐름의 연장선입니다. 서양 문물을 맞닥뜨렸을 때 어색해하던 당시 분위기와 무관하게, 쓸모 있는 이론들을 국적 불문으로 써먹었던 육일재 남원상이나 지수 이상혁을 떠올리게 하죠.

실제로 중세부터 근대까지 있던 '산학자'라는 직업은 순수 수학자보단, 응용수학자와 공학자 사이의 어딘가에 있었습니다.

C 언어 시절에는 서로 다른 타입을 하나의 메모리 공간에 다루기 위해 union을 사용했고, 현재 어떤 타입이 들어있는지 식별하기 위해 열거형 태그를 덧붙여 수동 관리를 해야 했습니다.

typedef enum { TYPE_LL, TYPE_DOUBLE, TYPE_STRING } ValueType;

typedef struct {
    ValueType tag;
    union {
        long long llVal;
        double    dVal;
        char     *strVal;
    } data;
} OldStyleTaggedUnion;

이런 방식은 태그 값 갱신을 누락하거나 엉뚱한 멤버를 읽을 때 발생하는 미정의 동작의 위험성을 프로그래머가 맨몸으로 떠안아야 합니다. 특히 생성자와 소멸자 호출 주기가 중요한 C++ 객체는 일반 union 안에서 다루기 까다롭습니다.

std::variant는 이를 컴파일러 차원에서 안전하게 캡슐화한 타입 안전 유니언입니다.

정말 솔직하게 말하자면, 타입 안전한 표현이 논리를 가시적으로 보이는가? 는 다른 문제라고 보지만요.

using llOrDoubleOrString = std::variant<long long, double, std::string>;

llOrDoubleOrString x = "Hello C++!";
std::cout << std::get<std::string>(x) << std::endl;

x = 10LL;
// std::string is destructed. now it stores 10 (long long)
if (std::holds_alternative<long long>(x)) {
    std::cout << "X is Ten." << std::endl;
}

제일 큰 멤버 크기만큼 잡힌 버퍼에 현재 활성 타입 인덱스 딱 하나만 붙여서 메모리를 알뜰하게 쓰면서도, 엉뚱한 타입 꺼내려 하면 컴파일 에러를 내거나 예외를 던집니다. 복잡하게 손으로 관리하던 유니언을 컴파일러가 알아서 관리해준다는 거죠. 투명성을 희생해서 공수 비용을 줄입니다.


최종 구현

import std;

constexpr auto nth_bit_is_high = [](unsigned int x, unsigned int n) constexpr noexcept -> bool {
    return (x & (1u << n)) != 0;
};

const std::string EMPTY_STRING = "";
const auto DELIMETER = ';';

using NumType = std::variant<long long, double>;

std::unordered_map<std::string, NumType> vars;

std::vector<char> alreadyUsed{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '=', '+', '-', '*', '/'};

std::string trim(const std::string &s) {
    auto start = s.find_first_not_of(" \t\r\n");
    if (start == std::string::npos)
        return EMPTY_STRING;
    auto end = s.find_last_not_of(" \t\r\n");
    auto substr_endpos = end - start + 1;
    return s.substr(start, substr_endpos);
}

template <typename T1, typename T2, typename Op>
concept CalculableSame = std::same_as<T1, T2> && requires(T1 a, T2 b, Op op) {
    // Requires that T1 and T2 are identical types,
    // and invoking op(a, b) yields the same type T1 without implicit conversion.
    { op(a, b) } -> std::same_as<T1>;
};

template <typename Op>
NumType applyBinaryOp(const NumType &l, const NumType &r, Op op) {
    return std::visit([op](auto &&a, auto &&b) -> NumType {
        using T1 = std::decay_t<decltype(a)>;
        using T2 = std::decay_t<decltype(b)>;
        using CleanOp = std::decay_t<Op>;

        if constexpr (CalculableSame<T1, T2, CleanOp>) {
            return op(a, b);
        } else {
            std::cerr << "err: type mismatch" << std::endl;
            std::exit(1);
        }
    }, l, r);
}

NumType evalExp(const std::string &rawExpr);

NumType evalOp(std::string tok) {
    tok = trim(tok);

    // float(...) expression
    if (tok.size() >= 7 && tok.rfind("float(", 0) == 0 && tok.back() == ')') {
        std::string inner = tok.substr(6, tok.size() - 7);
        NumType v = evalExp(inner);
        return std::visit([](auto &&val) -> NumType {
            return static_cast<double>(val);
        }, v);
    }

    if (vars.contains(tok)) {
        return vars[tok];
    }

    // if an expression contains ".",
    // we assume it's double.
    // For example, 10.0 is regarded as double in here.
    if (tok.find('.') != std::string::npos)
        return std::stod(tok);

    // if we found no "." from an expression, we assume it's long long.
    return std::stoll(tok);
}

NumType evalExp(const std::string &rawExpr) {
    std::string expr = trim(rawExpr);

    // Scan for top-level binary operators outside parentheses
    int parenDepth = 0;
    size_t plusPos = std::string::npos;
    size_t minusPos = std::string::npos;
    size_t mulPos = std::string::npos;
    size_t divPos = std::string::npos;

    for (size_t i = 0; i < expr.size(); ++i) {
        char ch = expr[i];
        if (ch == '(') {
            parenDepth++;
        } else if (ch == ')') {
            parenDepth--;
        } else if (parenDepth == 0) {
            if (ch == '+') plusPos = i;
            else if (ch == '-') minusPos = i;
            else if (ch == '*') mulPos = i;
            else if (ch == '/') divPos = i;
        }
    }

    unsigned int opMask = 0;

    /** NOTE: This should handle only one expression per execution
     * =======OPERATION TABLE===========
     *
     * | Operation | Bit |
     * | :-------- | :-- |
     * |     +     | 0th |
     * |     -     | 1th |
     * |     *     | 2nd |
     * |     /     | 3rd |
     *
     * ================================= */
    opMask = plusPos  != std::string::npos ? opMask | (1u << 0) : opMask;
    opMask = minusPos != std::string::npos ? opMask | (1u << 1) : opMask;
    opMask = mulPos   != std::string::npos ? opMask | (1u << 2) : opMask;
    opMask = divPos   != std::string::npos ? opMask | (1u << 3) : opMask;

    if (!opMask) return evalOp(expr);

    if ((opMask & (opMask - 1)) != 0) {
        std::cerr << "err: multiple operations not supported" << std::endl;
        std::exit(1);
    }

    size_t splitPos = std::string::npos;
    if (nth_bit_is_high(opMask, 0)) splitPos = plusPos;
    else if (nth_bit_is_high(opMask, 1)) splitPos = minusPos;
    else if (nth_bit_is_high(opMask, 2)) splitPos = mulPos;
    else if (nth_bit_is_high(opMask, 3)) splitPos = divPos;

    std::string lStr = expr.substr(0, splitPos);
    std::string rStr = expr.substr(splitPos + 1);

    NumType lhs = evalExp(lStr);
    NumType rhs = evalExp(rStr);

    if (nth_bit_is_high(opMask, 0)) return applyBinaryOp(lhs, rhs, std::plus<>{});
    if (nth_bit_is_high(opMask, 1)) return applyBinaryOp(lhs, rhs, std::minus<>{});
    if (nth_bit_is_high(opMask, 2)) return applyBinaryOp(lhs, rhs, std::multiplies<>{});
    if (nth_bit_is_high(opMask, 3)) {
        bool isZero = std::visit([](auto &&v) { return v == 0; }, rhs);
        if (isZero) {
            std::cerr << "err: division by zero" << std::endl;
            std::exit(1);
        }
        return applyBinaryOp(lhs, rhs, std::divides<>{});
    }

    return evalOp(expr);
}

void execStatement(const std::string &raw) {
    std::string stmt = trim(raw);

    if (stmt.empty()) return;

    // NOTE: print statement is not guarded.
    // for example, print x is fine.
    // but print(x) is not okay.
    if (stmt.rfind("print", 0) == 0) {
        std::string target = trim(stmt.substr(5));

        if (!vars.contains(target)) {
            std::cerr << "err: undefined variable" << std::endl;
            std::exit(1);
        }

        std::visit([](auto &&val) {
            std::cout << val << std::endl;
        }, vars[target]);
        return;
    }

    auto eqPos = stmt.find('=');

    // all statements EXCEPT print should follow:
    // name = value
    if (eqPos == std::string::npos) {
        std::cerr << "err: wrong statement" << std::endl;
        std::exit(1);
    }

    std::string var_name = trim(stmt.substr(0, eqPos));
    std::string expr = trim(stmt.substr(eqPos + 1));

    vars[var_name] = evalExp(expr);
}

int main(int argc, char **argv) {
    if (argc < 2) {
        std::cerr << "usage: ./cppcal \"syntax1;syntax2;\"" << std::endl;
        std::cerr << "example: ./cppcal \"a=float(10);b=10.2;c=a+b;print c\"" << std::endl;
        return 1;
    }

    std::stringstream ss(argv[1]);
    std::string stmt;

    // currently delimeter is ';'
    // you can change it above.
    // however, when you use '.' or some characters those are already used for other syntaxes,
    // it will return an error.
    auto it = std::find(alreadyUsed.begin(), alreadyUsed.end(), DELIMETER);

    if (it != alreadyUsed.end()) return 1;
    while (std::getline(ss, stmt, DELIMETER)) {
        execStatement(stmt);
    }

    return 0;
}

Makefile

CXX = clang++
CXXFLAGS = -std=c++23 -stdlib=libc++ -O2 -Wall -Wextra
TARGET = cppcal
SRC = main.cpp

LLVM_LIBDIR := $(shell $(CXX) -print-resource-dir 2>/dev/null)/../../..
STD_CPPM := $(firstword $(wildcard $(LLVM_LIBDIR)/share/libc++/v1/std.cppm /usr/lib/llvm-*/share/libc++/v1/std.cppm /usr/share/libc++/v1/std.cppm))

all: $(TARGET)

$(TARGET): $(SRC) std.pcm
	$(CXX) $(CXXFLAGS) -fmodule-file=std=std.pcm $(SRC) std.pcm -o $@

std.pcm:
	@if [ -z "$(STD_CPPM)" ]; then \
		echo "error: std.cppm not found." >&2; \
		exit 1; \
	fi
	$(CXX) $(CXXFLAGS) --precompile $(STD_CPPM) -o $@

clean:
	rm -f $(TARGET) std.pcm

.PHONY: all clean

빌드 및 실행

$ make
$ ./cppcal "a=10;b=10.2;c=a+b;print c"
err: type mismatch
$ ./cppcal "a=float(10);b=10.2;c=a+b;print c"
20.2

질문: 형변환은 어떤 구문을 타고 진행되었죠?

문제는 형변환이 어떤 구문을 타고 진행되었는지 추적하는 것입니다.

    if (tok.size() >= 7 && tok.rfind("float(", 0) == 0 && tok.back() == ')') {
        std::string inner = tok.substr(6, tok.size() - 7);
        // NOTE: recursive call
        NumType v = evalExp(inner);
        return std::visit([](auto &&val) -> NumType {
            return static_cast<double>(val);
        }, v);
    }

길이 검증을 거쳐 0번 오프셋으로 접두사 "float("와 접미사 ')'를 검사한 뒤, 내부 수식을 재귀 평가하여 static_cast<double>로 변환합니다.

실제 언어 처리기를 구성하기 위해선 이런 방식 대신 정식 괄호 파싱과 식별자 기반의 구문 분석 트리가 필요합니다. 이 부분은 파서를 확장하며 다룰 예정입니다.

Related posts

Back
Report

Comments

No comments yet.

Markdown supported: **bold**, *italic*, `code`, lists, links, images, $math$.