Question

我正在创建一个函数，它将返回一个我必须为其分配内存的数组，但我无法找到一种方法来确保在程序结束时删除内存。

这里的功能是：

int* RGB::getColor() const{
    int* arr = new int[3];

    arr[0] = red;
    arr[1] = green;
    arr[2] = blue;

    return arr;
}

以下是其使用示例：

int main(){
    int green;
    RGB test(50, 100, 150);

    green = test.getColor()[1];
}

由于它不是一个对象，我无法删除RGB类的析构函数中的任何内容。如何确保在＆＃34; getColor（）＆＃34;结束时删除内存？功能用吗？感谢。

Answer 1

我想这可以为您省去一些麻烦：

class RGB
{
public:
    RGB(int r, int g, int b)
    {
        colors[0] = r;
        colors[1] = g;
        colors[2] = b;
    }

    int operator[](uint index)
    {
        // you can check index is not exceeding 2, if you want
        return colors[index];
    }

    int getColor(uint index)
    {
        // you can check index is not exceeding 2, if you want
        return colors[index];
    }

private:
    int colors[3];
};

int main(){

    RGB test(50, 100, 150);
    int green = test[1];
    // int green = test.getColor(1); // or you really want to use it this way
}

试图在评论中实现OP请求的修改版本：

struct Color
{
    int values[3];

    int operator[](uint index) const
    {
        // you can check index is not exceeding 2, if you want
        return values[index];
    }
};

class RGB
{
public:
    RGB(int r, int g, int b)
    {
        color.values[0] = r;
        color.values[1] = g;
        color.values[2] = b;
    }

    Color getColor() const
    {
        return color;
    }

private:
    Color color;
};

int main() {
    RGB test(50, 100, 150);
    int green = test.getColor()[1]; // no need to worry about memory management!
}

实际上如果可能更好：

struct Color
{
    int r;
    int g;
    int b;

    enum Type
    {
        RED = 0,
        GREEN = 1,
        BLUE = 2,
    };

    int operator[](Type type) const
    {
        return values[type];
    }
};

class RGB
{
public:
    RGB(int r, int g, int b)
    {
        color.r = r;
        color.g = g;
        color.b = b;
    }

    Color getColor() const
    {
        return color;
    }

private:
    Color color;
};

int main() {
    RGB test(50, 100, 150);
    int green = test.getColor()[Color::GREEN];
}

Answer 2

如何确保在＆＃34; getColor（）＆＃34;结束时删除内存？功能用吗？

您可以通过捕获呼叫结果并在其上调用delete[]来实现。这个解决方案有效，但它存在可以避免的问题。

解决方案1：

RGB test(50, 100, 150);

int *values = test.getColor(); // store result in variable here
green = values[1];
delete []values; // and release the memory here

这种实现存在问题，因为它对客户端代码施加了责任（即，如果您不调用delete，则会发生泄漏）。

这是另一种解决方案：

解决方案2：

typedef std::tuple<int,int,int> RGBValue;

RGBValue RGB::getColor() const{
    return RGBValue{ red, green, blue };
}

auto green = std::get<1>( test.getColor() );

Answer 3

由于它不是一个对象，我无法删除RGB的类析构函数中的任何内容。

不是对象不是问题。已使用new[]分配已分配delete[]的C样式数组。但是你不应该在RGB的析构函数中释放它，因为你已经将它传递到了对象之外，它仍然可以被使用。

您可以使用当前设计释放内存：

int* colors = test.getColor();
green = colors[1];
delete[] colors;

但正如你所看到的那样，它并不是很好，因为来电者必须始终记得释放他们从未分配过的东西。

最简单的设计是返回一个容器类的实例来处理内存：

#include <array>

std::array<int, 3> RGB::getColor() const{
    return {red, green, blue};
}

如何释放我在“get”函数中分配的动态内存？

3 个答案: