Как работает память, если векторы внутри массива классов динамически поддерживаются push_backed?
Предположим, что у нас есть следующий класс:
class Test {
public:
Test() {}
std::vector<int>& getIntList() {
return intList;
}
private:
std::vector<int> intList;
};
Кроме того, у нас есть следующие коды внутри основной функции для объявления массива классов:
int main(void) {
Test* test[20];
for (int i = 0; i < 20; ++i) {
test[i] = new Test();
}
}
В этих случаях создаются экземпляры тестовых объектов.
Теперь, если я случайным образом добавлю несколько элементов в вектор внутри каждого класса,
могут существовать шансы столкнуться с диапазоном адресов памяти каждого вектора внутри каждого класса при изменении размера их памяти.
В этом случае весь «тестовый» объект копируется в другую область памяти и изменяется размер вектора? Или вектор STL копируется только в другую область памяти и изменяется в размере, пока класс ссылается на вектор?
В целом, не является ли хорошей идеей такой код?
@formerlyknownas Я спросил, хорошо ли управлять вектором (памятью) вот так
Ваш вопрос совершенно не ясен, почему вы думаете, что здесь что-то может «натолкнуться»?
Вы можете написать гораздо менее надуманную версию с двумя объектами std::vector<int> в локальной области видимости.
я действительно не понимаю. Вы не управляете памятью векторов, вектор делает это за вас
В любом случае, ответ заключается в том, что векторный объект не растет, когда вы добавляете к нему элементы — объект верхнего уровня управляет некоторым динамически выделяемым хранилищем в другом месте. Ваша ложная предпосылка состоит в том, что увеличение vector.size() влияет на sizeof(vector), а это не так.
векторы не хранят свои элементы в стеке, если это ваш источник путаницы
«могут существовать шансы столкнуться с диапазоном адресов памяти каждого вектора внутри каждого класса при изменении размера их памяти». Эта часть вообще не понятна
Классы имеют фиксированный размер времени компиляции в C++. В стеке ничего не растет и не сжимается. Как вы думаете, как работает sizeof без оценки его параметров?
Это звучит как XY-проблема, чего вы пытаетесь достичь, фактически?
@Jabberwocky, поскольку размер вектора будет изменяться при отталкивании, векторы внутри каждого класса не могут последовательно изменять размер своей области, что означает, что они должны быть скопированы в другую область памяти и должны быть изменены в этой области.
Да, размеры векторов будут изменены, так в чем проблема?
Вектор не "расти внутри каждого класса" Это не дело. Vector не хранит свои данные в стеке
Сорри, я думаю, мне нужно отредактировать свой вопрос.
связанный/возможно обман: stackoverflow.com/questions/55478523/…
во всяком случае, теперь я понимаю кое-что, что я пропустил
Ответы 1
Рассмотрим этот пример:
struct foo {
std::vector<int> x;
std::vector<int> y;
};
Теперь sizeof(foo) — это константа времени компиляции. Он не меняется при добавлении элементов к векторам. Также sizeof(std::vector<int>) является постоянным.
Размер экземпляра foo не увеличивается, когда растет size() вектора. Это похоже на наличие динамического массива (только для примера):
struct bar {
int* c_array;
};
Здесь sizeof(bar), скорее всего, будет просто sizeof(int*), потому что это просто указатель, хотя он может указывать на первый элемент массива в стиле c или на один int.
Вот что я хочу знать. Спасибо. Так действует ли вектор как динамический массив, инициализированный небольшим размером (программистом)?
@sungjuncho Да, std::vector — это динамический массив, элементы которого хранятся в куче. std::array — это статический массив, выделяемый во время компиляции, который не может изменить свой размер. И не беспокойтесь о массивах в стиле C в новом коде.
@sungjuncho хм да, вроде. std::vector это гораздо больше. Просто чтобы назвать один пример, у него есть operator==, который делает то, что вы хотите, что-то, что излишне сложно с c-массивами.
В целом, не является ли хорошей идеей такой код? Нет, забудьте об использовании
newвне создания умных указателей, пока они вам действительно не понадобятся (вероятно, никогда)