임베디드 C++ 소유권 모델 — single·shared·borrow 패턴

1
class Device {
2
    std::unique_ptr<Driver> driver_;   // owner — lifetime 책임
3
public:
4
    Device() : driver_(std::make_unique<Driver>()) {}
5
    // 자동 delete on destruction
6
};

1
class Logger {
2
public:
3
    void register_sink(Sink* sink) {   // observer — non-owning
4
        sink_ = sink;
5
    }
6

7
    void write(const char* msg) {
8
        if (sink_) sink_->emit(msg);
9
    }
10

11
private:
12
    Sink* sink_ = nullptr;   // non-owning
13
};
14

15
Sink sink;
16
Logger logger;
17
logger.register_sink(&sink);   // logger는 sink 안 소유

1
void process(const Data& data) {   // borrower
2
    // data를 잠시 사용
3
    // 함수 끝나면 빌림 끝
4
}

1
이 함수/객체가 ...
2

3
1. 이 객체를 소유해야 하나?
4
   YES → unique_ptr (단일) 또는 shared_ptr (공유, 드물게)
5

6
2. 객체 lifetime이 외부에서 관리되나?
7
   YES → 매개변수: const T& 또는 T*
8
        멤버: T*
9

10
3. 함수 호출 동안만 필요하나?
11
   YES → 매개변수 (const T&, T*, std::span, std::string_view)

1
class Display {
2
public:
3
    Display(Bus& bus) : bus_(bus) {}   // borrower — bus는 외부 소유
4

5
    void clear() { bus_.write(CLEAR_CMD); }
6

7
private:
8
    Bus& bus_;   // non-owning reference
9
};
10

11
class System {
12
    Bus bus_;             // owner
13
    Display display_;     // owner (display는 bus borrow)
14

15
public:
16
    System() : display_(bus_) {}   // bus_ 참조 전달
17
};

1
// 소유권 이전
2
void take_ownership(std::unique_ptr<Resource> r);
3

4
// 작은 객체 복사
5
int compute(int a, int b);
6

7
// 큰 객체 read-only 빌림
8
void print(const HugeData& data);
9

10
// 변경 가능 빌림
11
void modify(Counter& c);
12

13
// nullable
14
void with_optional_logger(Logger* logger = nullptr);
15

16
// array
17
void process(std::span<const uint8_t> data);
18

19
// string
20
bool match(std::string_view pattern, std::string_view text);

1
class Service {
2
    Database db_;                       // owner, value
3
    std::unique_ptr<Logger> logger_;    // owner, optional (nullable)
4
    std::optional<Config> config_;      // optional value (heap 0)
5
    Bus* bus_;                          // non-owning, nullable
6
    EventLoop& loop_;                   // non-owning, non-null (참조 멤버)
7
};

1
struct Event {
2
    int type;
3
    uint32_t data;
4
};
5

6
QueueHandle_t event_queue;
7

8
void producer() {
9
    Event e{1, 42};
10
    xQueueSend(event_queue, &e, portMAX_DELAY);   // copy
11
}
12

13
void consumer() {
14
    Event e;
15
    if (xQueueReceive(event_queue, &e, portMAX_DELAY)) {
16
        process(e);
17
    }
18
}

1
ObjectPool<LargeMessage, 16> pool;
2
QueueHandle_t handle_queue;
3

4
void producer() {
5
    auto* msg = pool.allocate();
6
    msg->fill(...);
7
    xQueueSend(handle_queue, &msg, portMAX_DELAY);   // pointer pass
8
}
9

10
void consumer() {
11
    LargeMessage* msg;
12
    if (xQueueReceive(handle_queue, &msg, portMAX_DELAY)) {
13
        process(*msg);
14
        pool.deallocate(msg);   // 소유권 명시적 해제
15
    }
16
}

1
struct SystemState {
2
    int counter;
3
    float temperature;
4
};
5

6
SystemState g_state;   // shared
7
SemaphoreHandle_t state_mutex;
8

9
void update(int c, float t) {
10
    xSemaphoreTake(state_mutex, portMAX_DELAY);
11
    g_state.counter = c;
12
    g_state.temperature = t;
13
    xSemaphoreGive(state_mutex);
14
}
15

16
void read(SystemState& out) {
17
    xSemaphoreTake(state_mutex, portMAX_DELAY);
18
    out = g_state;
19
    xSemaphoreGive(state_mutex);
20
}

1
// Bad — capture가 dangling
2
void setup() {
3
    LocalData data;
4
    register_callback([&data](int e) {
5
        data.process(e);   // 함수 끝 후 data 사라짐 — dangling
6
    });
7
}
8

9
// Good — capture by value
10
void setup() {
11
    LocalData data;
12
    register_callback([data](int e) {
13
        // data는 lambda 내부 owner
14
    });
15
}
16

17
// Better — 명시적 owner
18
class Handler {
19
    LocalData data_;
20
public:
21
    void on_event(int e) { data_.process(e); }
22
};
23

24
Handler g_handler;   // 명시적 owner
25

26
void setup() {
27
    register_callback([](int e) { g_handler.on_event(e); });
28
}

1
#include <gsl/pointers>
2

3
void take_owner(gsl::owner<int*> p);   // 의도: 소유권 받음
4
void observe(int* p);                  // 의도: 관찰만
5
void use(int& x);                      // 의도: 빌림

1
class A { B* b; };   // A가 owner? 그냥 reference?

1
struct A { shared_ptr<B> b; };
2
struct B { shared_ptr<A> a; };   // cycle — 영원히 안 해제

1
void setup() {
2
    auto resource = std::make_unique<Resource>();
3
    register_handler([&resource](int e) { /* */ });   // dangling
4
}

1
class A {
2
    B& b_;   // reference 멤버
3
public:
4
    A(B& b) : b_(b) {}
5
    // A를 어떻게 copy/move? b_ 못 재바인딩
6
};

1
void process(const Data& data) {
2
    saved_ = &data;   // data는 borrow — caller가 사라지면 dangling
3
}

1
void register_callback(void* ctx, void (*cb)(void*));

1
# Raw pointer + new/delete
2
모듈 크기: 4.2 KB
3
메모리 leak (1주일 stress): 3-5건/일
4
use-after-free: 1-2건/주
5

6
# unique_ptr 명시적 owner
7
모듈 크기: 4.3 KB (+100 B)
8
메모리 leak: 0
9
use-after-free: 0