C++ 重载 =operator, RAII

Question

我正在尝试做一个简单的缓冲区并遵循 RAII 习惯用法

在 main.cpp 中

int main()
{
    buffer buf(5);
    buffer test(10);
    test = buf;


    return 0;
}

在 buffer.cpp 中

#include "buffer.h"
#include <iostream>
size_t buffer::get_size() const
{
    return length;
}
buffer::buffer(size_t length) : start(new int[length]), length(length)
{
    std::cout << length << +" size" << std::endl;
}

buffer::buffer(const buffer& rhs) : start(new int[rhs.get_size()]), length(rhs.get_size())
{
    std::copy(rhs.begin(), rhs.end(), start);
}

buffer& buffer::operator=(const buffer& rhs)
{
    buffer temp = rhs;
    std::swap(*this, temp);

    return *this;

}

int* buffer::begin()
{
    return start;
}

int* buffer::end()
{
    return start + length;
}

const int* buffer::begin() const
{
    return start;
}

const int* buffer::end() const
{
    return start + length;
}
buffer::buffer(buffer&& rhs) noexcept
{
    *this = std::move(rhs);
}
buffer& buffer::operator=(buffer&& rhs) noexcept
{
    if (this != &rhs) { // if this is not the rhs object
        start = rhs.start;
        length = rhs.length;
        rhs.start = nullptr;
        rhs.length = 0;
    }

    return *this;
}
buffer::~buffer()
{
    delete[] start;
}

在buffer.h中

#pragma once
class buffer {
    size_t length;
    int* start;

public:
    size_t get_size() const;
    explicit buffer(size_t size);
    buffer(const buffer& rhs);
    buffer& operator=(const buffer& rhs); 
    buffer& operator=(buffer&& rhs) noexcept;
    buffer(buffer&& rhs) noexcept;
    int* begin(); 
    int* end();
    const int* begin() const;
    const int* end() const;
    ~buffer();
};

现在您注意到主缓冲区的大小比测试小。我的问题是在 test=buf 上面的行中由 test 分配的内存发生了什么？

它会被清理干净吗？或者 main 必须在清理之前完成。

Answer 1

test 分配的原始数组将交换到复制分配中的 temp 对象，并在该对象超出范围时释放。

但是移动赋值有内存泄漏，你必须在从rhs获取新数组之前释放旧数组。

一般来说，我建议使用 unique_ptr 而不是手动分配。