임베디드 스마트 포인터 선택 — unique·shared·custom 비교

1
#include <memory>
2

3
std::unique_ptr<Sensor> sensor = std::make_unique<Sensor>();
4
// sensor가 유일한 owner
5
// 소멸 시 자동 delete
6

7
// 이동 가능
8
auto other = std::move(sensor);   // sensor → other로 소유권 이전
9
// sensor는 이제 nullptr

1
class Driver {
2
public:
3
    static std::unique_ptr<Driver> create(int param) {
4
        if (!validate(param)) return nullptr;
5
        return std::make_unique<Driver>(param);
6
    }
7
};
8

9
void setup() {
10
    auto driver = Driver::create(42);
11
    if (driver) {
12
        driver->initialize();
13
        // ... 사용
14
        // 함수 끝 — 자동 delete
15
    }
16
}

1
struct PoolDeleter {
2
    Pool* pool;
3
    void operator()(uint8_t* p) const {
4
        if (p) pool->deallocate(p);
5
    }
6
};
7

8
using PoolPtr = std::unique_ptr<uint8_t, PoolDeleter>;
9

10
PoolPtr alloc(Pool& p, size_t n) {
11
    return PoolPtr(p.allocate(n), {&p});
12
}

1
auto a = std::make_shared<Resource>();
2
auto b = a;   // copy — 카운터 증가 (atomic)
3
// a와 b 모두 owner — 마지막이 사라질 때 delete

1
class Job {
2
    std::shared_ptr<Data> data_;
3
public:
4
    Job(std::shared_ptr<Data> d) : data_(std::move(d)) {}
5
    void execute() {
6
        // data_가 다른 task에서도 사용 중
7
        process(*data_);
8
    }
9
};

1
auto strong = std::make_shared<Resource>();
2
std::weak_ptr<Resource> weak = strong;
3

4
// 사용
5
if (auto locked = weak.lock()) {
6
    // strong 유효 — locked가 잠시 owner
7
} else {
8
    // strong 이미 해제됨
9
}

1
struct Parent {
2
    std::vector<std::shared_ptr<Child>> children;
3
};
4

5
struct Child {
6
    std::weak_ptr<Parent> parent;   // shared 아님 — cycle 방지
7
};

1
class Cache {
2
public:
3
    void register_handler(Handler* h) {   // non-owning
4
        handler_ = h;
5
    }
6

7
    void on_event() {
8
        if (handler_) handler_->handle();
9
    }
10

11
private:
12
    Handler* handler_ = nullptr;
13
};
14

15
Handler h;
16
cache.register_handler(&h);   // 소유권 이전 X — h는 호출자가 관리

1
class Device {
2
    Device() = default;   // private
3

4
public:
5
    static std::unique_ptr<Device> create(const Config& cfg) {
6
        if (!validate(cfg)) return nullptr;
7

8
        auto d = std::unique_ptr<Device>(new Device);
9
        if (!d->initialize(cfg)) return nullptr;
10
        return d;
11
    }
12
};
13

14
// 사용
15
auto device = Device::create(my_config);
16
if (!device) {
17
    log_error("device create failed");
18
    return;
19
}
20

21
device->run();
22
// 자동 cleanup

1
class System {
2
    std::unique_ptr<Logger> logger_;   // nullable
3

4
public:
5
    void enable_logging() {
6
        logger_ = std::make_unique<Logger>();
7
    }
8

9
    void log(const char* msg) {
10
        if (logger_) logger_->write(msg);
11
    }
12
};

1
class System {
2
    std::optional<Logger> logger_;   // 더 좋음 (heap 없음)
3

4
public:
5
    void enable_logging() {
6
        logger_.emplace();
7
    }
8
};

1
auto* p = new Foo();   // raw owning pointer — 어떻게 delete?

1
shared_ptr<Data> get_data();   // 정말 공유 소유?

1
std::unique_ptr<FILE, decltype(&fclose)> f(fopen(...), &fclose);

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

1
auto a = std::make_unique<Foo>();
2
auto b = a;   // ERROR — copy 안 됨

1
class RefCounted {
2
    mutable int count_ = 1;
3
public:
4
    void add_ref() const { ++count_; }
5
    void release() const {
6
        if (--count_ == 0) delete this;
7
    }
8
protected:
9
    virtual ~RefCounted() = default;
10
};
11

12
template<typename T>
13
class IntrusivePtr {
14
    T* p_;
15
public:
16
    explicit IntrusivePtr(T* p) : p_(p) { if (p_) p_->add_ref(); }
17
    ~IntrusivePtr() { if (p_) p_->release(); }
18
    // ...
19
};