C++ Expression Template 완벽 가이드 | 지연 평가와 수학 라이브러리 최적화
이 글의 핵심
C++ Expression Template 완벽 가이드에 대한 실전 가이드입니다. 지연 평가와 수학 라이브러리 최적화 등을 예제와 함께 상세히 설명합니다.
Expression Template이란? 왜 필요한가
문제 시나리오: 벡터 연산의 임시 객체
문제: 수학 라이브러리에서 벡터 연산 result = a + b + c + d는 임시 객체 3개를 생성합니다. 각 +마다 새 벡터를 할당하고 복사합니다.
class Vector {
public:
Vector(size_t n) : data(n) {}
Vector operator+(const Vector& other) const {
Vector result(data.size());
for (size_t i = 0; i < data.size(); ++i) {
result.data[i] = data[i] + other.data[i];
}
return result; // 임시 객체
}
private:
std::vector<double> data;
};
// result = a + b + c + d;
// 1. temp1 = a + b (임시 객체 1)
// 2. temp2 = temp1 + c (임시 객체 2)
// 3. result = temp2 + d (임시 객체 3)문제점:
- 메모리 할당 3회
- 루프 3회 (각
+마다) - 캐시 효율 저하
해결: Expression Template은 연산을 지연 평가합니다. a + b + c + d를 표현식 트리로 저장하고, 할당 시점에 한 번에 계산합니다.
// Expression Template
Vector result = a + b + c + d;
// 1. expr = Add(Add(Add(a, b), c), d) (표현식 트리, 계산 안 함)
// 2. result = expr (할당 시점에 한 번에 계산)장점:
- 메모리 할당 1회 (result만)
- 루프 1회 (한 번에 계산)
- 캐시 효율 향상
flowchart TD
subgraph normal["일반 연산"]
n1["a + b → temp1 (할당)"]
n2["temp1 + c → temp2 (할당)"]
n3["temp2 + d → result (할당)"]
end
subgraph expr["Expression Template"]
e1["a + b + c + d → 표현식 트리"]
e2["result = 표현식 (할당 1회)"]
e3["루프 1회로 계산"]
end
n1 --> n2 --> n3
e1 --> e2 --> e3
목차
1. 기본 구조
최소 Expression Template
#include <iostream>
#include <vector>
// 표현식 기반 클래스
template<typename E>
class VecExpr {
public:
double operator const {
return static_cast<const E&>(*this)[i];
}
size_t size() const {
return static_cast<const E&>(*this).size();
}
};
// 덧셈 표현식
template<typename LHS, typename RHS>
class VecAdd : public VecExpr<VecAdd<LHS, RHS>> {
public:
VecAdd(const LHS& l, const RHS& r) : lhs(l), rhs(r) {}
double operator const {
return lhs[i] + rhs[i];
}
size_t size() const { return lhs.size(); }
private:
const LHS& lhs;
const RHS& rhs;
};
// 벡터 클래스
class Vector : public VecExpr<Vector> {
public:
Vector(size_t n) : data(n) {}
double& operator { return data[i]; }
double operator const { return data[i]; }
size_t size() const { return data.size(); }
// Expression Template 할당
template<typename Expr>
Vector& operator=(const VecExpr<Expr>& expr) {
const Expr& e = static_cast<const Expr&>(expr);
for (size_t i = 0; i < size(); ++i) {
data[i] = e[i]; // 지연 평가
}
return *this;
}
private:
std::vector<double> data;
};
// 연산자
template<typename LHS, typename RHS>
VecAdd<LHS, RHS> operator+(const VecExpr<LHS>& lhs, const VecExpr<RHS>& rhs) {
return VecAdd<LHS, RHS>(
static_cast<const LHS&>(lhs),
static_cast<const RHS&>(rhs)
);
}
int main() {
Vector a(3), b(3), c(3);
a[0] = 1; a[1] = 2; a[2] = 3;
b[0] = 4; b[1] = 5; b[2] = 6;
c[0] = 7; c[1] = 8; c[2] = 9;
Vector result(3);
result = a + b + c; // 표현식 트리, 할당 시점에 계산
for (size_t i = 0; i < result.size(); ++i) {
std::cout << result[i] << ' ';
}
std::cout << '\n'; // 12 15 18
}핵심: a + b + c는 VecAdd<VecAdd<Vector, Vector>, Vector> 타입의 표현식 객체를 반환하고, result = ...에서 한 번에 계산됩니다.
2. 벡터 연산 구현
곱셈, 뺄셈 추가
// 뺄셈 표현식
template<typename LHS, typename RHS>
class VecSub : public VecExpr<VecSub<LHS, RHS>> {
public:
VecSub(const LHS& l, const RHS& r) : lhs(l), rhs(r) {}
double operator const {
return lhs[i] - rhs[i];
}
size_t size() const { return lhs.size(); }
private:
const LHS& lhs;
const RHS& rhs;
};
// 스칼라 곱셈 표현식
template<typename E>
class VecScale : public VecExpr<VecScale<E>> {
public:
VecScale(double s, const E& e) : scalar(s), expr(e) {}
double operator const {
return scalar * expr[i];
}
size_t size() const { return expr.size(); }
private:
double scalar;
const E& expr;
};
// 연산자
template<typename LHS, typename RHS>
VecSub<LHS, RHS> operator-(const VecExpr<LHS>& lhs, const VecExpr<RHS>& rhs) {
return VecSub<LHS, RHS>(
static_cast<const LHS&>(lhs),
static_cast<const RHS&>(rhs)
);
}
template<typename E>
VecScale<E> operator*(double scalar, const VecExpr<E>& expr) {
return VecScale<E>(scalar, static_cast<const E&>(expr));
}
int main() {
Vector a(3), b(3), c(3);
a[0] = 1; a[1] = 2; a[2] = 3;
b[0] = 4; b[1] = 5; b[2] = 6;
c[0] = 7; c[1] = 8; c[2] = 9;
Vector result(3);
result = 2.0 * a + b - c; // 표현식 트리
for (size_t i = 0; i < result.size(); ++i) {
std::cout << result[i] << ' ';
}
std::cout << '\n'; // -1 -1 -3
}3. 행렬 연산
행렬 곱셈
#include <iostream>
#include <vector>
template<typename E>
class MatExpr {
public:
double operator()(size_t i, size_t j) const {
return static_cast<const E&>(*this)(i, j);
}
size_t rows() const { return static_cast<const E&>(*this).rows(); }
size_t cols() const { return static_cast<const E&>(*this).cols(); }
};
class Matrix : public MatExpr<Matrix> {
public:
Matrix(size_t r, size_t c) : rows_(r), cols_(c), data(r * c) {}
double& operator()(size_t i, size_t j) {
return data[i * cols_ + j];
}
double operator()(size_t i, size_t j) const {
return data[i * cols_ + j];
}
size_t rows() const { return rows_; }
size_t cols() const { return cols_; }
template<typename Expr>
Matrix& operator=(const MatExpr<Expr>& expr) {
const Expr& e = static_cast<const Expr&>(expr);
for (size_t i = 0; i < rows_; ++i) {
for (size_t j = 0; j < cols_; ++j) {
(*this)(i, j) = e(i, j);
}
}
return *this;
}
private:
size_t rows_, cols_;
std::vector<double> data;
};
// 행렬 곱셈 표현식
template<typename LHS, typename RHS>
class MatMul : public MatExpr<MatMul<LHS, RHS>> {
public:
MatMul(const LHS& l, const RHS& r) : lhs(l), rhs(r) {}
double operator()(size_t i, size_t j) const {
double sum = 0;
for (size_t k = 0; k < lhs.cols(); ++k) {
sum += lhs(i, k) * rhs(k, j);
}
return sum;
}
size_t rows() const { return lhs.rows(); }
size_t cols() const { return rhs.cols(); }
private:
const LHS& lhs;
const RHS& rhs;
};
template<typename LHS, typename RHS>
MatMul<LHS, RHS> operator*(const MatExpr<LHS>& lhs, const MatExpr<RHS>& rhs) {
return MatMul<LHS, RHS>(
static_cast<const LHS&>(lhs),
static_cast<const RHS&>(rhs)
);
}
int main() {
Matrix A(2, 3), B(3, 2);
A(0, 0) = 1; A(0, 1) = 2; A(0, 2) = 3;
A(1, 0) = 4; A(1, 1) = 5; A(1, 2) = 6;
B(0, 0) = 7; B(0, 1) = 8;
B(1, 0) = 9; B(1, 1) = 10;
B(2, 0) = 11; B(2, 1) = 12;
Matrix C(2, 2);
C = A * B; // 표현식 트리, 할당 시점에 계산
std::cout << C(0, 0) << ' ' << C(0, 1) << '\n'; // 58 64
std::cout << C(1, 0) << ' ' << C(1, 1) << '\n'; // 139 154
}4. 자주 발생하는 문제와 해결법
문제 1: Dangling Reference
증상: 잘못된 값 또는 크래시.
원인: 표현식 객체가 임시 객체를 참조하면, 임시 객체가 소멸 후 dangling reference가 됩니다.
// ❌ 잘못된 사용: 표현식 저장
auto expr = a + b; // a, b를 참조
// a, b가 소멸하면 expr은 dangling
// ✅ 올바른 사용: 즉시 평가
Vector result = a + b; // 할당 시점에 계산문제 2: 타입 복잡도
증상: 컴파일 시간 증가, 에러 메시지 복잡.
원인: 표현식 트리가 깊어지면 타입이 매우 복잡해집니다.
// 타입: VecAdd<VecAdd<VecAdd<Vector, Vector>, Vector>, Vector>
auto expr = a + b + c + d + e + f + g;해결: 중간 평가로 타입 복잡도를 줄입니다.
Vector temp = a + b + c;
Vector result = temp + d + e + f;문제 3: 앨리어싱
증상: 잘못된 결과.
원인: a = a + b에서 a가 읽기와 쓰기에 동시에 사용됩니다.
// ❌ 잘못된 사용: 앨리어싱
a = a + b; // a[0] = a[0] + b[0], a[1] = a[0] + b[1] (잘못됨)
// ✅ 올바른 사용: 임시 벡터
Vector temp = a + b;
a = temp;
// 또는 앨리어싱 검사
template<typename Expr>
Vector& operator=(const VecExpr<Expr>& expr) {
const Expr& e = static_cast<const Expr&>(expr);
if (this == &e) {
Vector temp(size());
for (size_t i = 0; i < size(); ++i) {
temp[i] = e[i];
}
*this = temp;
} else {
for (size_t i = 0; i < size(); ++i) {
data[i] = e[i];
}
}
return *this;
}5. 프로덕션 패턴
패턴 1: SIMD 최적화
#include <immintrin.h> // AVX
template<typename Expr>
Vector& operator=(const VecExpr<Expr>& expr) {
const Expr& e = static_cast<const Expr&>(expr);
size_t i = 0;
// AVX: 4개씩 처리
for (; i + 4 <= size(); i += 4) {
__m256d a = _mm256_set_pd(e[i+3], e[i+2], e[i+1], e[i]);
_mm256_storeu_pd(&data[i], a);
}
// 나머지
for (; i < size(); ++i) {
data[i] = e[i];
}
return *this;
}패턴 2: 병렬 평가
#include <execution>
#include <algorithm>
template<typename Expr>
Vector& operator=(const VecExpr<Expr>& expr) {
const Expr& e = static_cast<const Expr&>(expr);
std::vector<size_t> indices(size());
std::iota(indices.begin(), indices.end(), 0);
std::for_each(std::execution::par, indices.begin(), indices.end(),
[this, &e](size_t i) {
data[i] = e[i];
});
return *this;
}6. 완전한 예제: 수학 라이브러리
#include <iostream>
#include <vector>
#include <cmath>
template<typename E>
class VecExpr {
public:
double operator const {
return static_cast<const E&>(*this)[i];
}
size_t size() const {
return static_cast<const E&>(*this).size();
}
};
template<typename LHS, typename RHS>
class VecAdd : public VecExpr<VecAdd<LHS, RHS>> {
public:
VecAdd(const LHS& l, const RHS& r) : lhs(l), rhs(r) {}
double operator const { return lhs[i] + rhs[i]; }
size_t size() const { return lhs.size(); }
private:
const LHS& lhs;
const RHS& rhs;
};
template<typename LHS, typename RHS>
class VecMul : public VecExpr<VecMul<LHS, RHS>> {
public:
VecMul(const LHS& l, const RHS& r) : lhs(l), rhs(r) {}
double operator const { return lhs[i] * rhs[i]; }
size_t size() const { return lhs.size(); }
private:
const LHS& lhs;
const RHS& rhs;
};
template<typename E>
class VecScale : public VecExpr<VecScale<E>> {
public:
VecScale(double s, const E& e) : scalar(s), expr(e) {}
double operator const { return scalar * expr[i]; }
size_t size() const { return expr.size(); }
private:
double scalar;
const E& expr;
};
class Vector : public VecExpr<Vector> {
public:
Vector(size_t n) : data(n) {}
double& operator { return data[i]; }
double operator const { return data[i]; }
size_t size() const { return data.size(); }
template<typename Expr>
Vector& operator=(const VecExpr<Expr>& expr) {
const Expr& e = static_cast<const Expr&>(expr);
for (size_t i = 0; i < size(); ++i) {
data[i] = e[i];
}
return *this;
}
double norm() const {
double sum = 0;
for (double x : data) {
sum += x * x;
}
return std::sqrt(sum);
}
private:
std::vector<double> data;
};
template<typename LHS, typename RHS>
VecAdd<LHS, RHS> operator+(const VecExpr<LHS>& lhs, const VecExpr<RHS>& rhs) {
return VecAdd<LHS, RHS>(static_cast<const LHS&>(lhs), static_cast<const RHS&>(rhs));
}
template<typename LHS, typename RHS>
VecMul<LHS, RHS> operator*(const VecExpr<LHS>& lhs, const VecExpr<RHS>& rhs) {
return VecMul<LHS, RHS>(static_cast<const LHS&>(lhs), static_cast<const RHS&>(rhs));
}
template<typename E>
VecScale<E> operator*(double scalar, const VecExpr<E>& expr) {
return VecScale<E>(scalar, static_cast<const E&>(expr));
}
int main() {
Vector a(3), b(3), c(3);
a[0] = 1; a[1] = 2; a[2] = 3;
b[0] = 4; b[1] = 5; b[2] = 6;
c[0] = 7; c[1] = 8; c[2] = 9;
Vector result(3);
result = 2.0 * a + b * c; // 표현식 트리
for (size_t i = 0; i < result.size(); ++i) {
std::cout << result[i] << ' ';
}
std::cout << '\n'; // 9 14 21
std::cout << "Norm: " << result.norm() << '\n'; // 26.4008
}7. 성능 비교
벤치마크: 일반 연산 vs Expression Template
#include <chrono>
#include <iostream>
// 일반 벡터
class NormalVector {
public:
NormalVector(size_t n) : data(n) {}
NormalVector operator+(const NormalVector& other) const {
NormalVector result(data.size());
for (size_t i = 0; i < data.size(); ++i) {
result.data[i] = data[i] + other.data[i];
}
return result;
}
double& operator { return data[i]; }
private:
std::vector<double> data;
};
int main() {
constexpr size_t N = 10'000'000;
// 일반 연산
NormalVector na(N), nb(N), nc(N), nd(N);
auto start = std::chrono::high_resolution_clock::now();
NormalVector normal_result = na + nb + nc + nd;
auto end = std::chrono::high_resolution_clock::now();
auto normal_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
// Expression Template
Vector ea(N), eb(N), ec(N), ed(N);
start = std::chrono::high_resolution_clock::now();
Vector expr_result(N);
expr_result = ea + eb + ec + ed;
end = std::chrono::high_resolution_clock::now();
auto expr_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
std::cout << "Normal: " << normal_time << " ms\n";
std::cout << "Expression Template: " << expr_time << " ms\n";
std::cout << "Speedup: " << (double)normal_time / expr_time << "x\n";
}결과 (예시):
Normal: 320 ms
Expression Template: 95 ms
Speedup: 3.37x이유: Expression Template은 임시 객체 없음, 루프 융합, 캐시 효율 향상.
정리
| 개념 | 설명 |
|---|---|
| Expression Template | 연산을 표현식 트리로 저장, 지연 평가 |
| 목적 | 임시 객체 제거, 루프 융합, 성능 최적화 |
| 장점 | 메모리 할당 감소, 캐시 효율, SIMD 최적화 |
| 단점 | 구현 복잡, 타입 복잡도, 앨리어싱 문제 |
| 사용 사례 | 수학 라이브러리 (Eigen, Blaze), 벡터/행렬 연산 |
Expression Template은 수학 라이브러리에서 성능을 극대화하는 고급 메타프로그래밍 패턴입니다.
FAQ
Q1: Expression Template은 언제 쓰나요?
A: 수학 연산이 빈번하고, 임시 객체 비용이 큰 라이브러리에서 사용합니다 (Eigen, Blaze 등).
Q2: 단점은?
A: 구현 복잡, 타입 복잡도 증가, 앨리어싱 문제, 디버깅 어려움.
Q3: Eigen은 어떻게 구현하나요?
A: Eigen은 Expression Template + SIMD + 병렬화를 조합해 최적화합니다.
Q4: C++20 Ranges와 비교는?
A: Ranges는 지연 평가 + 조합에 집중하고, Expression Template은 수학 연산 최적화에 집중합니다.
Q5: 앨리어싱 문제는 어떻게 해결하나요?
A: 임시 벡터를 사용하거나, 앨리어싱 검사를 추가합니다.
Q6: Expression Template 학습 리소스는?
A:
- “C++ Templates: The Complete Guide” by Vandevoorde & Josuttis
- Eigen Documentation
- “Modern C++ Design” by Andrei Alexandrescu
한 줄 요약: Expression Template로 수학 연산의 임시 객체를 제거하고 성능을 극대화할 수 있습니다. 다음으로 Factory Pattern을 읽어보면 좋습니다.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ CRTP 완벽 가이드 | 정적 다형성과 컴파일 타임 최적화
- C++ 템플릿 | “제네릭 프로그래밍” 초보자 가이드
- C++ Move 시맨틱스 | “복사 vs 이동” 완벽 이해
관련 글
- C++ Expression Templates |
- C++ auto 타입 추론 | 복잡한 타입을 컴파일러에 맡기기
- C++ Branch Prediction |
- C++ Cache Optimization |
- C++ CTAD |