поидее нет

тоже самое это.

тоже самое это.

ага, вижу что алиас

ребята, у меня есть функция которая генерирует лямбды

есть ли способ при каждом вызове генерить лямбду нового класса?

типо чтобы у всех лямбд различался тип

Эм... Может и мне так надо... Зачем?

мне нужно создать вектор, тип которого я узнаю только в момент вызова лямбды))))

хотел написать аля [](auto &&v) { static std::vector<decltype(v)> vec; }

фигня в том, что вектор будет один и тот же для разных инстансов лямбд

получается какой то type erasure на стероидах

А в среднем за урок что успевал?

мне нужно создать вектор, тип которого я узнаю только в момент вызова лямбды))))

std::vector<std::any> спасет отца русской демократии?

мне по рукам надают за лишние аллокации((

мне по рукам надают за лишние аллокации((

кто?

если я отвечу, то вы меня отправите в supapro)))

мне по рукам надают за лишние аллокации((

ну тогда как ты собрался воплотить "фигня в том, что вектор будет один и тот же для разных инстансов лямбд"?

всмысле я стараюсь этого избежать наоборот

или я не понял вопроса

так ты хочешь от этого уйти?

да

ещё раз

сейчас накидаю код

давай лучше начни с задачи

а то xy проблемой попахивает

В общем, мне нужно создать функтор, который будет скапливать в себе объекты до момента, пока их не окажется определённое количество. Потом выплёвывает все эти элементы

интерфейс std::optional<std::vector<T>>(T &&)

В общем, мне нужно создать функтор, который будет скапливать в себе объекты до момента, пока их не окажется определённое количество. Потом выплёвывает все эти элементы

Можно передавать в ту лямбду указатель на фиктивную другую лямбду. Лямбды каждый раз уникального типа, может поможет

T узнаётся только в момент вызова

что значит только в момент вызова? Все типы известны в compile-time

я обращаю внимание - типы, а не то, что лежит по ссылке\указателю(я опускаю полиморфизм всякий)

я имею в виду оператор() должен быть шаблонный

именно оператор() а не тип функтора

ну так инстанциация шаблона известна на этапе компиляции....

т.е. неканает template<typename T> struct MyFunctor

где хранить вектор?

в рифмЕ

а если серьёзно? как поле класса не получится, ибо я не знаю тип

тип не T?

ща

а, НЕ канает

тип T шаблонный

тип T шаблонный

напиши, как ты представляешь код, который будет использовать этот функтор

f(10.0); f(std::string("hello"); f(10); f(false);

?

и для каждого типа у тебя отдельный вектор значений?

т.е. примерно должно быть так struct MyFunctor { template<typename T> std::optional<std::vector<T>> operator(T &&value) { //допустим мы создали где то вектор с именем vec vec.emplace_back(value); if (vec.size() == 10) { return std::move(vec); } return std::nullopt; } };

ой

чё то с выравниванием

напиши, как ты представляешь код, который будет использовать этот функтор

ты понял, чего он хочет?

пока нет

в векторе нельзя хранить элементы разных типов, если я правильно понял, о чем ты

не не

посмотрите на код функтора

вопрос в том где создать vec

а если T всегда будет один и тот же между вызовами, то чем не подходит шаблонная структура?

в том, что я это T заранее не знаю, соответственно не смогу создать инстанс такой структуры

т.е. примерно должно быть так struct MyFunctor { template<typename T> std::optional<std::vector<T>> operator(T &&value) { //допустим мы создали где то вектор с именем vec vec.emplace_back(value); if (vec.size() == 10) { return std::move(vec); } return std::nullopt; } };

Создаёшь статический локальный. Мув его очистит.

ну значит сделай место использования тоже шаблоном и подставляй T

Для надёжности можно thread_local

статический не позволит несколько инстансов функтора делать разных же, с одним и тем же типом

статический не позволит несколько инстансов функтора делать разных же, с одним и тем же типом

+ у разных инстансов этой структуры вектор будет один и тот же

Тогда предлагаю создать статический std::map<MyFunctor*, std::vector<T>>

о

жесть, конечно, выглядит как костыль)

ах да, ещё одна особенность, максимальный размер вектора я знаю до вызова operator()

я бы так не стал делать, это еще и на производительности скажется из-за поиска по карте, и по памяти оверхед

ну т.е. размер, до которого копить надо

впринципе можно хранить void*

и кастовать его

т.е. vector<int> уже не получится

ага, понял сейчас

+ у разных инстансов этой структуры вектор будет один и тот же

struct foo { template <typename T> auto add(T &&e) { static std::vector<T> v; v.emplace_back(std::forward<T>(e)); if (v.size() == 2) { return std::optional<std::vector<T>>(std::move(v)); } return std::optional<std::vector<T>>(); } }; TEST(misc, foo) { foo f; ASSERT_EQ(std::optional<std::vector<double>>(), f.add(10.0)); ASSERT_EQ(std::optional<std::vector<double>>({10.0, 20.0}), f.add(20.0)); ASSERT_EQ(std::optional<std::vector<int>>(), f.add(100)); ASSERT_EQ(std::optional<std::vector<int>>({100, 200}), f.add(200)); }

а если нужна лямбда используй этот вспомогательный foo

так ему ж наоборот не нужно, чтобы вектор был общий у разных инстансов

у разных инстансов foo будет один и тот же вектор при одном и том же T

а как нужно?

так ему ж наоборот не нужно, чтобы вектор был общий у разных инстансов

+

чтоб были разные

чтоб были разные

по какому принципе они должны быть разведены?

каков критерий создания разных сущностей для одинакового типа?