Blog

#include <cstdio>
#include <cstring>

class Buffer {
    char*       data_;
    std::size_t size_;
public:
    explicit Buffer(const char* s) : data_(new char[std::strlen(s) + 1]), size_(std::strlen(s))
    {
        std::memcpy(data_, s, size_ + 1);
    }
    ~Buffer() { delete[] data_; }
    // 복사 생성자/대입 연산자를 쓰지 않음 -> 컴파일러가 멤버별 복사를 만든다
    const char* c_str() const { return data_; }
};

int main()
{
    Buffer a("hello");
    Buffer b = a;              // data_ 포인터 값만 복사
    std::fprintf(stderr, "a=%p b=%p\n", static_cast<const void*>(a.c_str()), static_cast<const void*>(b.c_str()));
}                              // b, a 순서로 같은 메모리를 두 번 delete[]

#include <cstdio>
#include <cstring>

class Buffer {
    char*       data_;
    std::size_t size_;
public:
    explicit Buffer(const char* s) : data_(new char[std::strlen(s) + 1]), size_(std::strlen(s))
    {
        std::memcpy(data_, s, size_ + 1);
    }
    ~Buffer() { delete[] data_; }

    Buffer(const Buffer& o) : data_(new char[o.size_ + 1]), size_(o.size_)   // 깊은 복사
    {
        std::memcpy(data_, o.data_, size_ + 1);
    }
    Buffer& operator=(const Buffer& o)          // 흔한 실수: 자기 대입을 고려하지 않음
    {
        delete[] data_;                         // o가 *this면 원본을 먼저 지워버린다
        size_ = o.size_;
        data_ = new char[size_ + 1];
        std::memcpy(data_, o.data_, size_ + 1);
        return *this;
    }
    const char* c_str() const { return data_; }
};

int main()
{
    Buffer a("hello");
    Buffer b = a;                               // 복사 생성자
    b = Buffer("world");                        // 복사 대입
    std::fprintf(stderr, "a=%s b=%s distinct=%d\n", a.c_str(), b.c_str(), a.c_str() != b.c_str());

    Buffer& alias = a;
    a = alias;                                  // 자기 대입
    std::fprintf(stderr, "a=%s\n", a.c_str());
}

#include <cstdio>
#include <cstring>
#include <utility>

class Buffer {
    char*       data_;
    std::size_t size_;
public:
    explicit Buffer(const char* s) : data_(new char[std::strlen(s) + 1]), size_(std::strlen(s))
    {
        std::memcpy(data_, s, size_ + 1);
    }
    ~Buffer() { delete[] data_; }
    Buffer(const Buffer& o) : data_(new char[o.size_ + 1]), size_(o.size_)
    {
        std::memcpy(data_, o.data_, size_ + 1);
    }
    Buffer(Buffer&& o) noexcept : data_(std::exchange(o.data_, nullptr)), size_(std::exchange(o.size_, 0)) {}

    // copy-and-swap: 값으로 받아(복사 또는 이동) 교환한다. 자기 대입·예외에 안전
    Buffer& operator=(Buffer o) noexcept
    {
        std::swap(data_, o.data_);
        std::swap(size_, o.size_);
        return *this;                           // 이전 데이터는 o와 함께 소멸
    }
    const char* c_str() const { return data_ ? data_ : "(empty)"; }
};

int main()
{
    Buffer a("hello");
    Buffer& alias = a;
    a = alias;                                  // 자기 대입
    Buffer b("x");
    b = a;                                      // 복사 대입
    Buffer c("y");
    c = std::move(b);                           // 이동 대입
    std::printf("a=%s b=%s c=%s\n", a.c_str(), b.c_str(), c.c_str());
}

#include <cstdio>
#include <memory>
#include <string>
#include <vector>

struct Document {                 // 특수 멤버 함수를 하나도 쓰지 않는다 (Rule of Zero)
    std::string        title;
    std::vector<int>   pages;
};

struct Session {
    std::unique_ptr<int> token = std::make_unique<int>(42);   // 복사 불가 멤버
};

int main()
{
    Document a{"spec", {1, 2, 3}};
    Document b = a;               // string, vector가 각자 깊은 복사
    b.pages.push_back(4);
    std::printf("a.pages=%zu b.pages=%zu\n", a.pages.size(), b.pages.size());

    Session s1;
    Session s2 = std::move(s1);   // 이동은 된다
    std::printf("s1.token=%p s2.token=%d\n", static_cast<void*>(s1.token.get()), *s2.token);
    // Session s3 = s2;           // 복사는 막힌다 (주석 해제 시 아래 에러)
}

#include <cstdio>
#include <utility>

struct Tracked {
    Tracked() = default;
    Tracked(const Tracked&) { std::puts("  copy"); }
    Tracked(Tracked&&) noexcept { std::puts("  move"); }
};

struct Plain {
    Tracked t;
};

struct WithDtor {
    Tracked t;
    ~WithDtor() {}            // 소멸자만 추가했다 -> 암시적 이동 생성자가 사라진다
};

int main()
{
    std::puts("Plain:");    { Plain a;    [[maybe_unused]] Plain b = std::move(a); }
    std::puts("WithDtor:"); { WithDtor a; [[maybe_unused]] WithDtor b = std::move(a); }
}

#include <cstdio>
#include <vector>

template <bool NoExcept>
struct Item {
    static inline int copies = 0, moves = 0;
    Item() = default;
    Item(const Item&) { ++copies; }
    Item(Item&&) noexcept(NoExcept) { ++moves; }
};

template <bool NoExcept>
void grow(const char* label)
{
    std::vector<Item<NoExcept>> v;
    for (int i = 0; i < 1000; ++i) v.emplace_back();   // 재할당이 여러 번 일어난다
    std::printf("%-20s copies=%d moves=%d\n", label, Item<NoExcept>::copies, Item<NoExcept>::moves);
}

int main()
{
    grow<true>("move noexcept");
    grow<false>("move may throw");
}