Итератор на только что добавленный элемент списка - C/C++

Здравствуйте, Sm0ke, Вы писали:

S>Тут надо замерять по скорости нужен ли такой аллокатор? По сути операционная система сама должна выдавать эти адреса оптимально, будет ли выигрыш?
S>Потом при освобождении надо в аллокаторе помечать элемент, как освободившийся, чтобы потом снова его выдавать при выделении, но не может его вернуть операционной системе отдельно без всего pre-alloc блока. Стоит ли заморачиваться с такой хитровыфигованной системой, когда проще сделать в лоб?

Естественно, что бенчмарки наше всё в такой ситуации, но
1) Ходить к ОС ножками — явно недёшево, можно напороться на syscall. Косвенно на это намекают всякие фреймворки, которые сперва просят большой шмат памяти у системы, а затем обживаю его по надобности.
2) Само собой, ОС не знает, что там у нас с собственными внутренними аллокациями. С её точки зрения нам выдали целый кусок мяса, и вернуть лишь часть от него — никак (разве что попытаться сделать realloc на меньший размер, но тут гарантий опять же нет). Поэтому возвращать всё сразу, по ведомости ОС.

Здравствуйте, 00011011, Вы писали:

0>Как красиво и эффективно решить эту задачу?

Некрасиво, но вроде работает

template <class T, class SequenceContainer>
typename std::list<T>::iterator insertMany(std::list<T>& lst, const SequenceContainer& sequence) {
    typename std::list<T>::iterator ret = lst.end();
    std::for_each(sequence.begin(), sequence.end(), [&](const T& item) {
        auto inserted = lst.insert(lst.end(), item);
        if (ret == lst.end()) {
            ret = inserted;
        }
    });
    return ret;
}

Здравствуйте, Dair, Вы писали:

D>Здравствуйте, 00011011, Вы писали:

0>>Как красиво и эффективно решить эту задачу?

D>Некрасиво, но вроде работает

D>

D>template <class T, class SequenceContainer>
D>typename std::list<T>::iterator insertMany(std::list<T>& lst, const SequenceContainer& sequence) {
D>    typename std::list<T>::iterator ret = lst.end();
D>    std::for_each(sequence.begin(), sequence.end(), [&](const T& item) {
D>        auto inserted = lst.insert(lst.end(), item);
D>        if (ret == lst.end()) {
D>            ret = inserted;
D>        }
D>    });
D>    return ret;
D>}
D>

Но у списка же итак есть 4-ая и 5-ая перегрузка функции insert() ...

template <class T, class SequenceContainer>
typename std::list<T>::iterator insertMany(std::list<T>& lst, const SequenceContainer& sequence) {
    return lst.insert(lst.end(), sequence.begin(), sequence.end() );
}

Здравствуйте, Mr.Delphist, Вы писали:

MD>Здравствуйте, Sm0ke, Вы писали:

S>>Тут надо замерять по скорости нужен ли такой аллокатор? По сути операционная система сама должна выдавать эти адреса оптимально, будет ли выигрыш?
S>>Потом при освобождении надо в аллокаторе помечать элемент, как освободившийся, чтобы потом снова его выдавать при выделении, но не может его вернуть операционной системе отдельно без всего pre-alloc блока. Стоит ли заморачиваться с такой хитровыфигованной системой, когда проще сделать в лоб?

MD>Естественно, что бенчмарки наше всё в такой ситуации, но
MD>1) Ходить к ОС ножками — явно недёшево, можно напороться на syscall. Косвенно на это намекают всякие фреймворки, которые сперва просят большой шмат памяти у системы, а затем обживаю его по надобности.

Так вот куда в приложении память утекла

Это оказывается фреймворки рвут куски от системы

Я конечно шучу тут, но и да, и нет.

MD>2) Само собой, ОС не знает, что там у нас с собственными внутренними аллокациями. С её точки зрения нам выдали целый кусок мяса, и вернуть лишь часть от него — никак (разве что попытаться сделать realloc на меньший размер, но тут гарантий опять же нет). Поэтому возвращать всё сразу, по ведомости ОС.

realloc — не работает
Надо определять rare case когда можно вернуть bucket (содержащий только не выданные итемы), и если он не last. Хотя после list.clear() это может быть и не так уж rare.
Сложность в чём. Вот вернули мы bucket, а он сразу опять понадобился. Значит придётся для Пула писать Trait автовозвращения Бакетов. Автоматом или по требованию.

Здравствуйте, Igore, Вы писали:

I>Да, точно, значит надо еще раз сдвинуться чтобы вместе с rbegin не уезжать, но порядок будет обратный

Или так, с прямым порядком:

  std::list<int> l = { 1, 2, 3 };
  l.push_back(4);
  auto tmp = std::prev(l.rbegin().base());
  l.push_back(5);
  l.push_back(6);
  
  for (auto it = tmp; it != l.end(); ++it)
  {
      std::cout << *it << std::endl;
  }
  // 4 5 6

	От:	Mr.Delphist
	Дата:	04.02.22 07:49
	Оценка:

	От:	Dair
	Дата:	04.02.22 08:06
	Оценка:

От:	Sm0ke	ksi
Дата:	04.02.22 11:00
Оценка:	6 (1)

От:	Sm0ke	ksi
Дата:	05.02.22 01:30
Оценка:

	От:	ομικρον
	Дата:	16.02.22 12:36
	Оценка: