C++：如何防止函数接受内联分配的指针？

Question

无法弄清楚如何准确地表达问题，所以这里有一个例子：

给定这个函数原型：

void Foo(myClass* bar);

我想阻止这种用法：

Foo(new myClass());

而是需要一个先前创建的对象：

myClass* bar = NULL;
bar = new myClass();
Foo(bar);

或者

myClass bar;
Foo(&bar);

谢谢。

---

编辑

这是一个澄清的示例：

void Mouse::SetImage(BITMAP* image, int focusX, int focusY) {
    if(_image) {
        set_mouse_sprite(NULL);
        set_mouse_sprite_focus(0, 0);
        show_mouse(NULL);
        destroy_bitmap(_image);
        _image = NULL;
    }
    if(image) {
        _image = create_bitmap(image->w, image->h);
        clear_bitmap(_image);
        blit(image, _image, 0, 0, 0, 0, image->w, image->h);
    }
    if(image == NULL) {
        focusX = 0;
        focusY = 0;
    }
    _focusX = focusX;
    _focusY = focusY;
    _dirtyImage = true;
}

用户传递的任何图像都会被复制到对象的图像中。

如果我在复制图像后释放传入的图像，并且该图像在程序的其他地方使用，则会导致程序因访问冲突而崩溃。

如果他们内联分配存储而我没有释放它，则会发生内存泄漏。如果在程序运行过程中多次调用 SetImage 方法，问题就会变得更加复杂。

关于使用替代库或 Allegro 库本身的评论将被忽略，我已经知道这很糟糕。我别无选择。

Answer 1

您的设计需要做出选择。要么取得所有权并删除它，要么不取得所有权。 无论哪种方式，都由用户决定如何使用您的函数。他们要么需要知道您的函数将破坏图像（并且可能根据需要传递他们自己的副本），要么他们需要足够聪明来管理自己的资源。

通常，您不想仅仅为了删除它而窃取所有权。所以我不会删除任何内容。如果有人愚蠢到失去了删除他们传递的图像的能力，那不是这个函数的问题。换句话说，你应该尝试防范墨菲，但忘记防范马基雅维利。

也就是说，使用原始指针是不好的！糟糕的 C++ 代码的特点是手动资源管理和资源问题。您应该在图像周围有一个包装器，它将在析构函数中删除该图像。这样，即使抛出异常，您也永远不会发生泄漏。为其提供一个 reset() 方法，该方法会丢弃旧的图像资源并获取新的图像资源。

听起来您想要共享所有权，因此您需要一个引用计数的资源包装器。然后问题就解决了：如果有人进行“内联”分配，它将被放入共享指针中，然后在完成后自动删除。 （更好的是有一个显式构造函数，这样有人就必须知道他们将共享资源。）

这是在一个名为shared_ptr的智能指针中完成的。 Boost 有一个，TR1 有一个，C++0x 有一个。只需给它一个自定义删除（释放图像的一个），您就再也不用担心资源管理了。

这应该使用所有资源来完成。这里的概念是范围限定的资源管理< /a>（SBRM）；通过利用自动（堆栈）变量的生命周期规则来自动管理资源。它也因其原始但丑陋的名称而闻名资源获取是初始化 (RAII)。对这个领域进行一些研究，您会发现您的代码更简单、更清晰。

---

如果不更改参数的类型，则无法完成此操作。您可以将其更改为：

void Foo(myClass*& bar);

因为非常量引用只能绑定到左值：

void foo(int*&);

int main(void)
{
    int *i = 0;
    int j;

    foo(i); // well-formed
    foo(&j); // ill-formed
    foo(new int); // ill-formed
}

但是，这不允许获取左值的地址。您当然可以做简单的事情：

int main(void)
{
    int j;
    int* pj = &j;
    foo(pj); // well-formed
}

而且它有效。但我不知道你为什么想做这些。

---

上述解决方案允许您修改参数（因为它是一个引用）。如果您想在函数内强制执行 const，您可以创建一个如下所示的实用程序：

template <typename T>
class require_lvalue
{
public:
    require_lvalue(T& pX) :
    mX(pX)
    {}

    const T& get(void) const
    {
        return mX;
    }

    operator const T&(void) const
    {
        return get();
    }

private:
    // non-copy-assignable
    require_lvalue& operator=(const require_lvalue&);

    const T& mX;
};

void foo(require_lvalue<int*>);

相同的结果，除非您在函数内有一个 const 引用。

---

请注意，MSVC 有一个错误，并接受这一点：

foo(new int);

在这两种情况下，即使它不应该接受。 （但是，它不接受 new int() 。）

Answer 2

不可能有这样的用法区别。在所有情况下它都是一个有效的参数。我真的不明白你为什么需要这个......

Answer 3

所以不要使用指针...使用（左值）引用：

void Foo(myClass& bar);

Answer 4

这还没有解决你的任务吗？
但无论如何，对于这种情况，我推荐使用 std::auto_ptr 之类的东西。

#include <iostream>

void test(int *& ptr)
{
    std::cout << *ptr << std::endl;
}

int main()
{
/* NEXT LINE WILL FAIL */
//  test(new int(5));

    int *b = new int(5);
    test(b);
    delete b;

    return 0;
}

Answer 5

C 或 C++ 无法让您确定内存分配的位置，即进入函数参数的位置。如果您想要更好的安全性，请使用 .NET 进行编程。

如果您想让它更安全，那么不仅仅是完全更改您的函数签名以接受自动指针。这样，语义就变得非常清晰，并且对于谁或什么拥有记忆就不会有任何混淆。