C++ Expression Templates | "지연 평가" 고급 기법

문제 상황

// 단순 벡터 구현
class Vector {
    vector<double> data;
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;  // 임시 객체 생성
    }
};

// 문제: 임시 객체 3개 생성
Vector a, b, c, d;
Vector result = a + b + c + d;
// temp1 = a + b
// temp2 = temp1 + c
// temp3 = temp2 + d
// result = temp3

Expression Templates 해결

// 표현식 템플릿
template<typename E>
class VecExpression {
public:
    double operator const {
        return static_cast<const E&>(*this)[i];
    }
    
    size_t size() const {
        return static_cast<const E&>(*this).size();
    }
};

// 실제 벡터
class Vector : public VecExpression<Vector> {
    vector<double> data;
    
public:
    Vector(size_t n) : data(n) {}
    
    double operator const { return data[i]; }
    double& operator { return data[i]; }
    size_t size() const { return data.size(); }
    
    // 표현식으로부터 생성
    template<typename E>
    Vector(const VecExpression<E>& expr) : data(expr.size()) {
        for (size_t i = 0; i < expr.size(); i++) {
            data[i] = expr[i];  // 지연 평가
        }
    }
};

// 덧셈 표현식
template<typename E1, typename E2>
class VecAdd : public VecExpression<VecAdd<E1, E2>> {
    const E1& u;
    const E2& v;
    
public:
    VecAdd(const E1& u, const E2& v) : u(u), v(v) {}
    
    double operator const {
        return u[i] + v[i];
    }
    
    size_t size() const { return u.size(); }
};

// 연산자 오버로딩
template<typename E1, typename E2>
VecAdd<E1, E2> operator+(const VecExpression<E1>& u, const VecExpression<E2>& v) {
    return VecAdd<E1, E2>(static_cast<const E1&>(u), static_cast<const E2&>(v));
}

int main() {
    Vector a(3), b(3), c(3);
    
    // 임시 객체 없음!
    Vector result = a + b + c;  // 한 번의 루프로 계산
}

실전 예시

예시 1: 벡터 연산

// 곱셈 표현식
template<typename E>
class VecScale : public VecExpression<VecScale<E>> {
    const E& v;
    double scalar;
    
public:
    VecScale(const E& v, double s) : v(v), scalar(s) {}
    
    double operator const {
        return v[i] * scalar;
    }
    
    size_t size() const { return v.size(); }
};

template<typename E>
VecScale<E> operator*(const VecExpression<E>& v, double scalar) {
    return VecScale<E>(static_cast<const E&>(v), scalar);
}

// 내적
template<typename E1, typename E2>
double dot(const VecExpression<E1>& u, const VecExpression<E2>& v) {
    double result = 0;
    for (size_t i = 0; i < u.size(); i++) {
        result += u[i] * v[i];
    }
    return result;
}

int main() {
    Vector a(3), b(3);
    
    // 복잡한 표현식도 최적화
    Vector result = (a + b) * 2.0 + a * 3.0;
    
    double d = dot(a, b);
}

예시 2: 행렬 연산

template<typename E>
class MatExpression {
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 MatExpression<Matrix> {
    vector<double> data;
    size_t nrows, ncols;
    
public:
    Matrix(size_t r, size_t c) : data(r * c), nrows(r), ncols(c) {}
    
    double operator()(size_t i, size_t j) const {
        return data[i * ncols + j];
    }
    
    double& operator()(size_t i, size_t j) {
        return data[i * ncols + j];
    }
    
    size_t rows() const { return nrows; }
    size_t cols() const { return ncols; }
    
    template<typename E>
    Matrix(const MatExpression<E>& expr) 
        : data(expr.rows() * expr.cols()), 
          nrows(expr.rows()), 
          ncols(expr.cols()) {
        for (size_t i = 0; i < nrows; i++) {
            for (size_t j = 0; j < ncols; j++) {
                (*this)(i, j) = expr(i, j);
            }
        }
    }
};

template<typename E1, typename E2>
class MatAdd : public MatExpression<MatAdd<E1, E2>> {
    const E1& u;
    const E2& v;
    
public:
    MatAdd(const E1& u, const E2& v) : u(u), v(v) {}
    
    double operator()(size_t i, size_t j) const {
        return u(i, j) + v(i, j);
    }
    
    size_t rows() const { return u.rows(); }
    size_t cols() const { return u.cols(); }
};

template<typename E1, typename E2>
MatAdd<E1, E2> operator+(const MatExpression<E1>& u, const MatExpression<E2>& v) {
    return MatAdd<E1, E2>(static_cast<const E1&>(u), static_cast<const E2&>(v));
}

예시 3: 지연 평가 리스트

template<typename E>
class ListExpression {
public:
    int operator const {
        return static_cast<const E&>(*this)[i];
    }
    
    size_t size() const {
        return static_cast<const E&>(*this).size();
    }
};

class List : public ListExpression<List> {
    vector<int> data;
    
public:
    List(initializer_list<int> init) : data(init) {}
    
    int operator const { return data[i]; }
    size_t size() const { return data.size(); }
    
    template<typename E>
    List(const ListExpression<E>& expr) : data(expr.size()) {
        for (size_t i = 0; i < expr.size(); i++) {
            data[i] = expr[i];
        }
    }
};

template<typename E>
class ListMap : public ListExpression<ListMap<E>> {
    const E& list;
    function<int(int)> func;
    
public:
    ListMap(const E& l, function<int(int)> f) : list(l), func(f) {}
    
    int operator const {
        return func(list[i]);
    }
    
    size_t size() const { return list.size(); }
};

template<typename E>
ListMap<E> map(const ListExpression<E>& list, function<int(int)> func) {
    return ListMap<E>(static_cast<const E&>(list), func);
}

int main() {
    List a = {1, 2, 3, 4, 5};
    
    // 지연 평가
    auto expr = map(a,  { return x * 2; });
    
    // 여기서 실제 계산
    List result = expr;
    
    for (size_t i = 0; i < result.size(); i++) {
        cout << result[i] << " ";  // 2 4 6 8 10
    }
}

성능 비교

#include <chrono>

// 일반 방식
Vector normalAdd(const Vector& a, const Vector& b, const Vector& c) {
    Vector temp1 = a + b;  // 임시 객체 1
    Vector temp2 = temp1 + c;  // 임시 객체 2
    return temp2;
}

// Expression Templates
Vector etAdd(const Vector& a, const Vector& b, const Vector& c) {
    return a + b + c;  // 임시 객체 없음
}

int main() {
    Vector a(1000000), b(1000000), c(1000000);
    
    auto start = chrono::high_resolution_clock::now();
    Vector r1 = normalAdd(a, b, c);
    auto end = chrono::high_resolution_clock::now();
    cout << "일반: " << chrono::duration_cast<chrono::milliseconds>(end - start).count() << "ms" << endl;
    
    start = chrono::high_resolution_clock::now();
    Vector r2 = etAdd(a, b, c);
    end = chrono::high_resolution_clock::now();
    cout << "ET: " << chrono::duration_cast<chrono::milliseconds>(end - start).count() << "ms" << endl;
}

자주 발생하는 문제

문제 1: 댕글링 참조

// ❌ 위험
auto expr = a + b;  // 표현식 저장
// a, b 소멸
// expr 사용 → 댕글링 참조!

// ✅ 즉시 평가
Vector result = a + b;

문제 2: 복잡한 에러 메시지

// 에러 발생 시 긴 템플릿 에러
Vector result = a + b + c + d;

// static_assert로 명확한 에러 제공
template<typename E1, typename E2>
VecAdd<E1, E2> operator+(const VecExpression<E1>& u, const VecExpression<E2>& v) {
    static_assert(is_same_v<typename E1::value_type, typename E2::value_type>,
                  "타입이 일치해야 합니다");
    return VecAdd<E1, E2>(static_cast<const E1&>(u), static_cast<const E2&>(v));
}

문제 3: 컴파일 시간

// 복잡한 표현식은 컴파일 시간 증가
Vector result = (a + b) * 2.0 + (c - d) * 3.0 + e;

// 필요하면 중간 결과 저장
Vector temp1 = (a + b) * 2.0;
Vector temp2 = (c - d) * 3.0;
Vector result = temp1 + temp2 + e;

실무 라이브러리

Eigen

#include <Eigen/Dense>

Eigen::VectorXd a(3), b(3), c(3);

// Expression Templates 자동 적용
Eigen::VectorXd result = a + b + c;

Blaze

#include <blaze/Math.h>

blaze::DynamicVector<double> a(3), b(3), c(3);

// 고성능 연산
auto result = a + b + c;

FAQ

Q1: Expression Templates는 언제 사용하나요?

A:

• 수치 계산 라이브러리
• 행렬/벡터 연산
• DSL 구현

Q2: 성능 이점은?

A: 임시 객체 제거로 2-10배 빠를 수 있습니다.

Q3: 단점은?

A:

• 구현 복잡
• 컴파일 시간 증가
• 에러 메시지 복잡

Q4: 직접 구현해야 하나요?

A: 아니요. Eigen, Blaze 같은 라이브러리를 사용하세요.

Q5: 디버깅은?

A:

• 간단한 케이스부터 테스트
• static_assert 활용
• 컴파일러 최적화 끄고 테스트

Q6: Expression Templates 학습 리소스는?

A:

• “C++ Templates: The Complete Guide”
• Eigen 라이브러리 소스
• “Modern C++ Design”

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ Expression Template 완벽 가이드 | 지연 평가와 수학 라이브러리 최적화
• C++ Type Traits | “타입 특성” 완벽 가이드
• C++ Tag Dispatching | “태그 디스패칭” 패턴 가이드

관련 글

• C++ Expression Template 완벽 가이드 | 지연 평가와 수학 라이브러리 최적화
• C++ SFINAE와 Concepts |
• C++ Tag Dispatching |
• C++ Type Traits |
• C++ 메모리 정렬 |