C ++: Как запретить функции принимать указатель, выделенный в строке?

Ваш дизайн должен сделать выбор. Либо станьте владельцем и удалите его, либо не становитесь владельцем. В любом случае, пользователь должен знать, как использовать вашу функцию. Им нужно либо знать, что ваша функция уничтожит изображение (и, возможно, передать свою копию по мере необходимости), либо им нужно быть достаточно умным, чтобы управлять собственными ресурсами.

Как правило, вы не хотите лишать права собственности только для того, чтобы удалить ее. Поэтому я бы не ничего удалял. Если кто-то достаточно глуп, чтобы потерять возможность удалить передаваемое изображение, проблема не в этой функции. Другими словами, вы должны попытаться защититься от Мерфи, но забыть о защите от Макиавелли.

Тем не менее, использование необработанного указателя - это плохо! Плохой код C ++ отмечен ручным управлением ресурсами и проблемами с ресурсами. У вас должна быть оболочка вокруг изображения, которая удалит изображение в деструкторе. Таким образом вы можете никогда избежать утечки, даже если возникнет исключение. Предоставьте ему метод reset(), который отбрасывает старый ресурс изображения и получает новый.

Похоже, вам нужно совместное владение, поэтому вам понадобится оболочка ресурса с подсчетом ссылок. Затем проблема решается: если кто-то выполняет «встроенное» распределение, оно будет помещено в общий указатель, а затем автоматически удалено, когда это будет выполнено. (А еще лучше иметь explicit конструктор, чтобы кто-то знал, что он будет делиться ресурсом.)

Это делается в умном указателе shared_ptr. у Boost1 один, а в C ++ 0x есть один. Просто дайте ему пользовательское удаление (которое освобождает изображение), и вы больше никогда не будете беспокоиться об управлении ресурсами.

Это должно быть сделано со всеми ресурсами. Здесь используется концепция Управление ресурсами с привязкой к определенному объему < / а> (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
}

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*>);

foo(new int);

Такое разграничение использования невозможно. И во всех случаях это допустимый параметр. Я действительно не могу понять, зачем тебе это ...

Так что не используйте указатели ... используйте (lvalue) ссылки:

void Foo(myClass& bar);

Не решает ли это вашу задачу? Но я все равно рекомендую для таких случаев что-то вроде 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;
}

C или C ++ не дают вам возможности определить, где была выделена память, которая входит в параметры вашей функции. Если вы хотите большей безопасности, программируйте на .NET.

Если вы хотите сделать его более безопасным, просто полностью измените подпись своей функции, чтобы она принимала автоматический указатель. таким образом семантика становится кристально ясной, и не должно возникать путаницы в отношении того, кому или чему принадлежит память.