Могу ли я заставить std::vector оставить утечку памяти?
Могу ли я заставить std::vector не освобождать память после того, как вектор выйдет за пределы области видимости?
Например, если у меня есть
int* foo() {
std::vector<int> v(10,1); // trivial vector
return &v[0];
}
int main()
{
int* bar = foo();
std::cout << bar[5] << std::endl;
}
Нет никакой гарантии, что значения будут по-прежнему доступны здесь.
Я сейчас просто делаю это
int* foo() {
std::vector<int> v(10,1);
int* w = new int[10];
for (int i=0; i<10; i++) {
w[i] = v[i];
}
return w;
}
но повторное заполнение всего нового массива немного расточительно. Есть ли способ заставить std::vector не удалять свой массив?
Примечание. Я не возвращаю сам вектор, потому что я взаимодействую с C++ с python с помощью SWIG, а ARG_OUTVIEW_ARRAY требует необработанного указателя и, по сути, преднамеренной утечки памяти. Однако я все же хотел бы иметь возможность использовать векторные функции при построении самих данных.
Проблема в том, что код Python станет конечным владельцем вектора, и преобразование требует, чтобы я намеренно оставил «утечку памяти». Я не просто возвращаю int, потому что мне понадобится весь массив в python.
@TheZhengmeister: почему не std::vector<int> v = new std::vector<int>(10,1); в foo?
Почему бы просто не использовать необработанный массив с SWIG? Возможно.
@P.W, это действительно работает! Тогда я могу просто взять &(*v)[0], верно?
@rustyx, можете ли вы рассказать, как это сделать? Моя проблема в том, что я не знаю размер массива до запуска кода С++, поэтому я не могу передать INPLACE_ARRAY и заполнить его во время.
@TheZhengmeister Нет, это ужасная идея. Если вы вернете &(*v)[0], вы утечете сам вектор, даже если освободите его внутренний массив.
@HolyBlackCat ах да, конечно, я буду этого избегать.
Почему бы вам не вернуть вектор вместо указателя на его данные?
Вы хотите сделать это, потому что не знаете, как правильно вернуть std::vector<int>? Поддерживающие его карты типов поставляются с SWIG или используют карты типов numpy.
@MarkTolonen Я использую интерфейс numpy.i (документация здесь), но есть ли способ заставить его работать напрямую с std::vector?
%include <std_vector.i> то %template(IntVector) std::vector<int>; разрешит передачу и возврат векторов.
Ответы 7
Нет.
Векторы не реализованы так, чтобы иметь утечки памяти, и интерфейс не предоставляет способ их создания.
Вы не можете «украсть» память (удалив право собственности на нее из вектора), что является, возможно, немного позорно.
Извините, но вам придется либо копировать (как вы делаете сейчас), либо не использовать вектор.
Как насчет использования специального распределителя, который не освобождает память? Я знаю, что это ужасная идея, но ее можно реализовать.
Я не собираюсь развлекаться таким хакерством!
Ржу не могу. Да, такого взлома следует избегать, но технически это возможно. По крайней мере, может быть просто для удовольствия :-)
Не уверен, но да.
Вы можете создать пользовательский распределитель, который ничего не делает при освобождении => утечка
Или, может быть, вы можете просто создать свой vector в куче, чтобы он все равно протекал.
int* foo() {
std::vector<int>* v = new std::vector<int>(10,1);
return &((*v)[0]);
// no delete
}
int main()
{
int* bar = foo();
std::cout << bar[5] << std::endl;
}
Второй вариант приведет к фактической утечке (вместо того, чтобы лишить права собственности на буфер у vector, чего, похоже, хочет ОП).
Это создает слишком большой риск случайной утечки большего объема памяти, чем нужно. Кроме того, у вас нет стратегии освобождения памяти после того, как вы с ней закончите. Это ужасная идея.
Конечно, это ужасная идея, но ОП хочет создать утечку, я помогу ему в этом ^^
Название вопроса вводит в заблуждение. OP, похоже, хочет повторно использовать буфер из вектора, а не пропускать его.
@HolyBlackCat, вы правы, мне нужно повторно использовать векторный буфер, но вне области действия кода C++ (с этим справится Python). Поэтому я также не уверен, что «утечка» — правильное слово.
@TheZhengmeister показанный здесь пример в дополнение к утечке массива приведет к утечке самого объекта vector. Не используйте его.
Это возможно, но вы никогда не должны этого делать. Заставить вектор оставить утечку памяти — ужасная идея, и если вам это нужно, вам нужно переосмыслить свой дизайн. std::vector — это тип управления ресурсами, одной из основных целей которого является обеспечение отсутствия утечек. Никогда не пытайтесь сломать это.
Теперь, чтобы ответить на ваш конкретный вопрос: std::vector принимает тип распределителя в качестве второго параметра шаблона, который по умолчанию равен std::allocator<T>. Теперь вы можете написать собственный распределитель, который не освобождает память, и использовать его с вашим вектором. Написание собственного распределителя — не очень тривиальная работа, поэтому я не буду описывать ее здесь (но вы можете найти руководства в Google).
Если вы действительно хотите использовать пользовательский распределитель, вы должны убедиться, что ваш вектор никогда не запускает операцию роста. Причина в том, что при увеличении емкости вектор будет перемещать/копировать данные в новое место и освобождать старые воспоминания с помощью распределителя. Если вы используете аллокатор, который дает утечки, то при выращивании вы не только сохраняете окончательные данные, но и сохраняете старые воспоминания, которые, я уверен, вы не хотите сохранять. Поэтому убедитесь, что вы создаете вектор с полной емкостью.
Нет.
И ты делаешь это неправильно. Вместо этого верните вектор, чтобы время жизни работало:
Напишите свой собственный специальный вектор памяти Python class, что-то вроде (наиболее грубо):
template <typename T>
class python_vector
{
T* buffer_;
public:
python_vector(size_t n, const T& value) : buffer_{new T(n)}
{}
// copy, assignment, operator[](), *etc*
~python_vector()
{
// DO NOTHING!
}
}
python_vector<int> foo() {
python_vector<int> v(10,1);
// process v
return v;
}
int main()
{
python_vector<int> bar = foo(); // copy allusion will build only one python_vector here
std::cout << bar[5] << std::endl;
}
ОП упомянул, почему он не возвращает вектор в примечании в конце вопроса.
@P.W Но он хочет, чтобы данные vector пережили это возвращение? Дизайн неправильный.
Да, я согласен с тобой.
Мне нужны данные, чтобы пережить возврат, потому что SWIG нужна «утечка памяти», чтобы python мог взять под контроль память, а затем освободить ее по истечении срока службы С++.
@TheZhengmeister Тогда vector не тот инструмент. Выделяйте память и управляйте ею так, чтобы вы могли контролировать ее, чтобы она не освобождалась в течение времени существования C++.
Кто бы ни проголосовал: так вы думаете, что лучше изуродовать практику кодирования vector, чтобы сделать что-то, для чего она никогда не предназначалась, а не писать какой-то код, чтобы сделать это правильно?
Не поставил минус, но, может быть, это потому, что ваш python_vector очень неполный? и, вручную управляя собственной памятью, вы открываете еще одну банку червей. (написание правильных специальных функций-членов и т. д.).
@SombreroChicken Я сказал грубо. В спецификации vector не предусмотрено кражи его буфера, так что вы уже открыли банку с червями.
vector предназначен для предотвращения утечек.
Но если вы хотите выстрелить себе в ногу, это возможно. Вот как вы предотвращаете освобождение вектором своего внутреннего массива:
int *foo()
{
std::vector<int> v(10,1);
int *ret = v.data();
new (&v) std::vector<int>; // Replace `v` with an empty vector. Old storage is leaked.
return ret;
}
Как говорят другие ответы, вы никогда не должны этого делать.
Это намного проще и чище, чем использование пользовательского распределителя. Спасибо.
Я почти уверен, что это UB, но, надеюсь, это должно работать в обычных средах выполнения...
@Quentin Можно было бы получить UB при delete[] использовании указателя позже, если по какой-то причине v[0] не находится в начале выделенного хранилища. Я думаю, что само размещение-новое здесь четко определено, поскольку можно уничтожать объекты, повторно используя их хранилище. Кроме того, если vector управляет каким-то другим ресурсом в дополнение к одному блоку памяти кучи, мы пропускаем это. Это звучит правильно?
Удаление @HolyBlackCat должно использовать ту же самую форму, которую std::vector использует внутри, распределители и все остальное - вероятно, будет соответствовать delete[] в простом случае, но не гарантируется. Я не уверен, является ли четко определенным сокращение времени жизни нетривиально разрушаемого объекта за счет нового размещения.
Это плохая идея, но ее можно создать, создав собственный распределитель, который не освобождается, как сказано в других ответах.
Например: (шаблон в основном из cppref)
#include <cstdlib>
#include <new>
#include <vector>
template <typename T>
struct LeakingAllocator
{
using value_type = T;
LeakingAllocator() = default;
template <typename U> constexpr LeakingAllocator(const LeakingAllocator<U>&) noexcept {}
T* allocate(std::size_t n)
{
if (n > std::size_t(-1) / sizeof(T)) throw std::bad_alloc(); // check for overflow
if (auto p = static_cast<T*>(std::malloc(n*sizeof(T)))) return p; // return p if malloc returns a valid object
throw std::bad_alloc(); // otherwise just throw.
}
void deallocate(T* p, std::size_t) noexcept { /*leak intentionally*/ }
};
template <typename T, typename U>
bool operator==(const LeakingAllocator<T>&, const LeakingAllocator<U>&) { return true; }
template <typename T, typename U>
bool operator!=(const LeakingAllocator<T>&, const LeakingAllocator<U>&) { return false; }
template <typename T>
using LeakingVector = std::vector<T, LeakingAllocator<T>>;
Затем код, как
int* ret()
{
LeakingVector<int> a;
a.resize(10);
return &a[0];
}
int main()
{
auto ptr = ret();
*ptr = 10;
std::cout << *ptr;
}
становится действительным.
В С++ вы, скорее всего, написали бы:
auto foo()
{
std::vector<int> v(10,1); // trivial vector
return v;
}
int main()
{
const auto bar = foo();
std::cout << bar[5] << std::endl;
}
Мне нужен необработанный указатель, потому что я использую SWIG для взаимодействия С++ с python, который передает управление памятью python после того, как С++ выходит за рамки. Это должна быть «утечка», потому что в противном случае ОС может просто перезаписать выделенную память.
Я не думаю, что Python может правильно управлять памятью, выделенной во время выполнения C++. Возможно, вам следует получить память от Python и скопировать в нее векторные данные.
почему
fooне возвращаетint? В конце концов, кто-то должен хранить значение...