EA Standard Template Library VS etl

> you can still use it with smart pointers provided by any other library

Is the point of having a kitchen-sink library like this not that you dont have to reach for a 3rdparty library for things that you need 'all the time'?

Certainly, not everyone needs it.

...but, not everyone needs threads either. Not everyone needs an http server; and yet, if you have an application framework that provides them, when you do need them, it saves you reaching for yet-another-dependency.

Was that no the point from the beginning?

unique_ptr is a fundamental primitive for many, as you see from some other frameworks (1), and implementation is not always either a) trivial, or b) as simple as 'just use std::unique_ptr'.

This does seem like a very opinionated decision with reasonably unclear justification.

[1] - eg. https://github.com/EpicGames/UnrealEngine/blob/release/Engin..., https://github.com/electronicarts/EASTL/blob/master/include/...

Can I introduce you to EASTL

For games focused stuff have a look at EASTL https://github.com/electronicarts/EASTL also perhaps some of the Data Oriented Design stuff (see Mike Acton's CPP Con Talks). This also have loads of good stuff https://www.dataorienteddesign.com/dodbook/

C++, but generally treat it as C. STL is pretty slow while debugging so we avoid it and write our own replacements. If you don't want to drive that deep use something like EASTL: https://github.com/electronicarts/EASTL

In my experience game devs don't eschew the STL because of compile times, but because (a) its memory management is not sufficiently tunable and (b) it uses exceptions heavily which many game engines disable entirely due to perceived performance problems. For this reason, some of the engines I've worked on have used their own forks of the STL in the spirit of EASTL to rectify these issues. Others like my current project just don't use the STL at all (outside of some third-party library code) and use custom libraries for everything.

In my opinion, you should also benchmark it against something like boost::container::flat_set or eastl::vector_set and you should expect the same performance as with your ordered functionality. Another interesting idea for organization of such flat and sorted container can be found here.

Probably not as the way things are defined in the STL is often not in line with what C++ programmers want for their code base.

STL adheres to zero-cost-abstraction, which often puts safety in the backseat. Many programmers, myself included, prefer safety by default with an escape route, when its really needed.

Add to that things like exceptions, locale-dependent behavior, functions with a dozen overloads, an overly complex memory allocator interface (`std::vector` vs. `std::pmr::vector`), etc.

Personally, I'd prefer a common alternative to STL that focuses on these points. ETL [1] and abseil [2] come to mind, but it's not exactly what I envision.

1: https://github.com/ETLCPP/etl

If you can't use the STL because of exceptions: https://www.etlcpp.com/

You can also use ETL (https://www.etlcpp.com)

Use ETL for embedded standard library functionality: https://www.etlcpp.com/

The best choice here is use embedded Template Library: https://www.etlcpp.com/

If you can't get C++23, expected it's implemented in the ETL (it's also just a really amazing library for this kind of stuff - highly recommend!).

I want to use some of C++ std library classes/functions in my embedded system library project that I'm writing. However as the environment has limited ressources I don't want to have use or expose classes or functions that do the following: * Dynamic memory allocations * RTTI * Runtime exceptions I will be rewriting some basic container and algorithms according to my needs. I know that there are other re writes of STL like ESTL but I don't want to have any external dependencies So my question is can I somehow compile/package a fork of C++ std library that only include embedded systems friendly classes such as: - array - tuple - variant - type_traits Etc This compiled library must be completely standalone. The compiler that I use can support upto C++17 standard.

I will never not recommend the Embedded Template Library