동적 할당 없는 임베디드 C++ — placement new·정적 객체·풀

1
// 위험
2
std::vector<Order> orders;
3
for (auto& order : input) {
4
    orders.push_back(order);   // heap alloc, 크기마다 reallocate
5
    if (orders.capacity() > 1000) {
6
        // 시점 불명, 메모리 부족 가능
7
    }
8
}

1
#include <array>
2

3
std::array<int, 16> buffer;             // stack, 64 byte
4
std::array<float, 256> sin_table;       // 1024 byte
5
std::array<Order, 8> recent_orders;     // sizeof(Order)*8
6

7
buffer[0] = 1;
8
auto size = buffer.size();               // 16, constexpr
9
auto begin = buffer.begin();             // iterator
10

11
// range-for
12
for (auto& x : buffer) { x = 0; }
13

14
// algorithm
15
std::fill(buffer.begin(), buffer.end(), 0);
16
std::sort(sin_table.begin(), sin_table.end());

1
#include <etl/vector.h>
2
#include <etl/string.h>
3
#include <etl/map.h>
4

5
etl::vector<int, 16> v;        // 최대 16개
6
v.push_back(1);
7
v.push_back(2);
8
if (v.full()) { /* */ }
9

10
etl::string<32> s = "hello";    // 최대 32 char
11
s += " world";
12

13
etl::map<int, Order, 8> orders; // 최대 8 entry
14
orders.insert({1, Order{}});

1
#include <memory_resource>
2

3
// stack buffer 위에 monotonic allocator
4
std::array<std::byte, 4096> buffer;
5
std::pmr::monotonic_buffer_resource pool(buffer.data(), buffer.size());
6

7
std::pmr::vector<int> v(&pool);
8
v.reserve(100);
9
for (int i = 0; i < 100; ++i) v.push_back(i);
10
// 모든 메모리는 stack buffer에서

1
void func() {
2
    int local_arr[100];                    // stack — 함수 종료시 회수
3
    static int static_arr[100];            // .bss — 영구
4
    auto* heap = new int[100];             // heap — 위험!
5
    delete[] heap;                          // 명시 해제 필요
6
}

1
template<typename T, size_t N>
2
class ObjectPool {
3
    alignas(T) std::byte storage_[sizeof(T) * N];
4
    std::bitset<N> in_use_;
5

6
public:
7
    T* allocate() {
8
        for (size_t i = 0; i < N; ++i) {
9
            if (!in_use_[i]) {
10
                in_use_.set(i);
11
                return reinterpret_cast<T*>(&storage_[sizeof(T) * i]);
12
            }
13
        }
14
        return nullptr;
15
    }
16

17
    void deallocate(T* p) {
18
        if (!p) return;
19
        size_t i = (reinterpret_cast<std::byte*>(p) - storage_) / sizeof(T);
20
        if (i < N) in_use_.reset(i);
21
    }
22

23
    template<typename... Args>
24
    T* construct(Args&&... args) {
25
        T* p = allocate();
26
        if (p) new (p) T(std::forward<Args>(args)...);
27
        return p;
28
    }
29

30
    void destroy(T* p) {
31
        if (p) {
32
            p->~T();
33
            deallocate(p);
34
        }
35
    }
36
};
37

38
ObjectPool<Order, 32> order_pool;
39

40
auto* o = order_pool.construct(/* args */);
41
// 사용
42
order_pool.destroy(o);

1
alignas(Order) std::byte buffer[sizeof(Order)];
2
Order* o = new (buffer) Order(/* args */);   // placement new
3

4
o->process();
5

6
o->~Order();   // 명시 destructor 호출

1
std::optional<Order> current_order;   // sizeof(Order) + bool, on stack
2

3
void start() {
4
    current_order = Order{/* args */};   // emplace
5
}
6

7
void process() {
8
    if (current_order) {
9
        current_order->execute();
10
    }
11
}
12

13
void end() {
14
    current_order.reset();
15
}

1
class Logger {
2
public:
3
    static Logger& instance() {
4
        static Logger inst;   // C++11 — thread-safe, 최초 호출 시 1번 생성
5
        return inst;
6
    }
7

8
private:
9
    Logger() = default;
10
};
11

12
// 사용
13
Logger::instance().log("hello");

1
// BAD — 동적
2
std::vector<Order> orders;
3
orders.push_back(o);
4

5
// GOOD — 정적
6
etl::vector<Order, 32> orders;
7
if (!orders.full()) orders.push_back(o);
8

9
// GOOD — pmr (메모리 풀에서)
10
std::pmr::vector<Order> orders(&order_pool);
11

12
// GOOD — std::array + 직접 size
13
std::array<Order, 32> orders;
14
size_t order_count = 0;
15
if (order_count < orders.size()) orders[order_count++] = o;

1
// BAD — 동적
2
std::string s = "hello";
3

4
// GOOD — 고정 크기
5
etl::string<32> s = "hello";
6

7
// GOOD — string_view (참조만)
8
std::string_view sv = "hello";   // const char* + size_t
9

10
// GOOD — std::array<char, N>
11
std::array<char, 32> s = {'h', 'e', 'l', 'l', 'o', '\0'};

1
// BAD — heap 가능
2
std::function<void(int)> callback;
3
callback = [data](int x) { /* */ };   // capture가 크면 heap
4

5
// GOOD — etl::delegate (fixed-size)
6
etl::delegate<void(int)> cb;
7
cb = etl::delegate<void(int)>::create<&MyClass::method>(my_obj);
8

9
// GOOD — 함수 포인터
10
void (*cb)(int) = my_function;
11

12
// GOOD — std::function with capture-less lambda
13
std::function<void(int)> cb = [](int x) { /* */ };   // capture 없으면 inline storage

1
std::string s = "a";
2
s += "b";   // heap reallocate 가능

1
static std::array<HugeStruct, 1000> arr;   // 큰 .bss

1
auto* o = pool.allocate();
2
if (!o) { /* ? */ }   // nullptr 처리 누락

1
Order* o = new (buffer) Order;
2
return;   // ~Order() 호출 안 함 — leak

1
struct Node {
2
    std::array<Node, 4> children;   // 무한 재귀 — 컴파일 에러
3
};

1
extern "C" {
2
    static size_t total_alloc = 0;
3
    static size_t total_free = 0;
4
    static size_t alloc_count = 0;
5

6
    void* __wrap_malloc(size_t n) {
7
        total_alloc += n;
8
        alloc_count++;
9
        return __real_malloc(n);
10
    }
11

12
    void __wrap_free(void* p) {
13
        // 크기 추적 어려움 — newlib에 기록 필요
14
        total_free++;
15
        __real_free(p);
16
    }
17
}

1
// V1 — std::vector (heap)
2
std::vector<int> v;
3
for (int i = 0; i < 100; ++i) v.push_back(i);
4

5
// V2 — etl::vector (static)
6
etl::vector<int, 128> v;
7
for (int i = 0; i < 100; ++i) v.push_back(i);
8

9
// V3 — std::array
10
std::array<int, 128> v;
11
for (int i = 0; i < 100; ++i) v[i] = i;

1
V1 (std::vector): +6.2 KB (heap, vector, growth logic)
2
V2 (etl::vector): +0.4 KB
3
V3 (std::array): +0.2 KB