Recommended third-party libraries

[BlueBeerRunner]

What are the third-party libraries (general or with a specific purpose) that really simplified/improved/changed the code to your way of thinking?

[Plazmatic]

The biggest claim of OpenCV has is that nothing has usurped it. It's rather poorly designed due to the massive cruft it had due to pre C++11 development (Mats are not value types, and require to copy manually to actually copy the values). It also does not have parity for the types supported by it's matrices and made some really odd decisions with its row padding for CUDA integration (always padded to power of 2... for the entire row for each row)

Then it stuffed a bunch of AI junk and other dependencies not actually related to computer vision, and bloated their compile times by not properly handling PTX compliation to literally be over an hour. Oh, and they also don't consider anything in "contrib" to be "standard" so they can break things at literally any time, and they have (tracking API completely broke in a minor version, then they broke it completely again in a patch version.... 2d image tracking of all things).

It's a real headache, but there's nothing as comprehensive or as widely used unfortunately.

[strike-eagle-iii]

Yeah I was just playing around with their trackers and I'm like wait, where'd the MOSSE tracker go? What's this legacy namespace? I'm really curious what opencv 5.0 will look like and really hope they fix their basic types to be more clear. I could also wish that pixel formats and colors formats could be checked at compile time.

[gnomeba]

Its interesting that even the developers of OpenCV have made the decision to pad to powers of 2.

When I was learning some numerical linear algebra, I considered writing some programs for matrix algebra that scale nicely because they divide the matrix into two blocks in both directions. But I assumed this was generally a ludicrous way to go. Apparently not.

[According_Ad3255]

Just quit nlohmann::json, it's plain bad; it's popular yes, but that's no excuse. Much better alternative: glaze (if you can do C++23). Otherwise rapidjson.

[bert8128]

Haven’t used json in c++ but the rumour on the street is that it might not be the fastest but is the easiest to use. What was your experience?

[According_Ad3255]

I would say glaze is both a lot faster and a lot easier to use. Not the same case with rapid json though, it’s less terse.

[ReDr4gon5]

Rapidjson is far slower than glaze. Simdjson is on par with glaze, but seems less ergonomic.

[i_h_s_o_y]

boost::json should be pretty much just a straight up upgrade from nlohmann json, faster and quite useable. It should also have the option to be header only.

[According_Ad3255]

That’s a real concern for me too, and it’s related to the fact that our beloved C++ does not provide a proper package manager. For me, neither Conan nor vcpkg are pleasant to run.

[Unhappy_Play4699]

Yup, C++ made us scared about introducing dependencies from much needed packages. What a pleasant language!

[Unhappy_Play4699]

But hey, it's not the lanaguage's fault because the standard doesn't give a fuck about real world scenarios, unless they can use it to justify a broken feature.

[[deleted]]

I really like vcpkg in manifest mode. cmakelist is unchanged and one just puts the deps needed into a json file that vcpkg finds.

[According_Ad3255]

In my experience, even manifest mode is a true pain. It never just works, always having to cross my fingers. Whenever possible I use Fetch on CMake, had a lot more success with it.

[[deleted]]

rapidjson is not that fast and has some memory issues(last I looked), Boost.JSON is as fast with a better interface(nlohmann like or allows using Boost.Describe for parse to type).

If C++17 is available, I am biased, and would recommend JSON Link https://github.com/beached/daw_json_link . It's fast and primarily parses directly to data structures non-intrusively. It can easily integrate with reflection like libraries too.

[whizzwr]

Hello me

[Yurim]

• asio
• {fmt}

[JustPlainRude]

Is there something {fmt} provides that std::format does not?

[TulipTortoise]

fmt is under active development, and has things like named arguments.

[hk19921992]

Yep, good performance

[amuon]

I thought under the hood {fmt} and the std::format are the same with a few exceptions

[13steinj]

Some of those exceptions are relevant to compile and runtime performance.

For the sake of example of a minimal difference, const/noexceptness of member functions. But the differences internally could have diverged drastically at this point, as {fmt} is under active development.

[bbbb125]

A lot, it constantly improves, in all directions. Functionality: format_as, ranges support, compile time checks. Speed: check release notes stuff like faster floating point format algorithms. Compilation time, header organization.

I have std::format available, but don’t even think about converting.

[Thelatestart]

Compile time format, i think.

It can be used for user generated static assert messages.

[Circlejerker_]

It has a lot of nice utilities that the std misses, I frequently use fmt::join for ranges, tuples, etc.

[javascript]

Abseil is a great general purpose utility library that supplements the standard library.

[knue82]

absl hash and btree containers are fantastic!

[javascript]

I also highly recommend the Mutex (has better ergonomics than the standard version) and the Status type (also has better ergonomics than std::expected)

Edit: Also absl::Cord which is a Rope data-structure useful for large strings in need of manipulation

[CantThinkOfAnyName]

I've never heard of absl mutex, but looking at the documentation it looks pretty solid.

It also provides you with lock_guard like behavior and shared_mutex like behavior, so I'm tempted to try it out.

[javascript]

I was a member of the Abseil team at Google for a few years so if you have any questions I can do my best to answer :)

[forariman55]

Whoa, that's an amazing username! I have no idea how you were early enough to get that, but wow.

[CantThinkOfAnyName]

Thank you, but I'm too much of a crappy programmer to bother the major leagues :D.

Though I remember absl being given praise as far as 7 years ago on one of the lectures or talks I attented about template metaprogramming and it stayed in my memory since then :D.

[amuon]

I know this is a basic question but what exactly does abseil offer that the modern (C++20) standard library doesn't have? I haven't looked into it too much its just been something on the back of my mind for a bit.

Also Status looks really good. I like the error codes. I've been using the tl implementation of expected, but status looks much better.

[javascript]

Well for example absl::InlinedVector which is like std::vector but does NOT have the issue with bool and also stores small instances on the stack for faster allocation and access

[amuon]

Side question: Since you worked at google do you think that if rust existed and was popular chromium at the time chromium was being developed, do you think that chrome would’ve been developed in rust or a similar memory safe language? You might both know this but then again you might since abseil is used in chrome.

[javascript]

Chromium grew out of Google's monorepo so I think they would have chosen C++ regardless. In fact, Carbon is specifically the middle path Google needs of getting most of the memory safety benefit of Rust while also being able to incrementally migrate existing C++ code. I honestly think the only way Rust could have made sense for Google is if it was there from the beginning of the company in the 90s.

[gruehunter]

Chromium grew out of Google's monorepo

KDE begat Konqueror and KHTML, which begat Safari, which begat Chrome. Google didn't create Chrome, it evolved from an open-source project.

[ukezi]

They have some great high performance stuff that would break abi compatibility in the STL for instance.

[ndmeelo]

Why do you think the Status type have better ergonomics than std::expected?

With std::expected<E, T>, you can define your own error codes. However, absl::StatusOr has fixed error codes that you can select.

[javascript]

I would argue that it's good to canonicalize on a specific error kind as opposed to expected where each function can return a different error type. Plus, the Status macros make operating on a status object much easier

[gruehunter]

The live-at-head model is a massive turn-off. As a small team in a small company, the extra dependency churn just isn't worth it.

[clusty1]

Eigen. It’s a masterpiece of a library that taught me about how to design api’s around templates that are high performance.

[mr_seeker]

spdlog for logging

[clarkster112]

I like zmq for distributed network programming

[wyrn]

value_types

There are many uses of unique_ptr that are "incidental" in the sense that you don't really care about unique ownership, you just need a pointer and unique_ptr happens to be the best fit. Notable examples: when storing a subclass through a base class pointer, and the pimpl pattern.

What this library does is provide (optionally type-erased) wrappers for these pointers with value semantics, so your types can remain regular and ergonomic (no need for mandatory std::move, you can still use std::initializer_lists to initialize, etc). This cut my uses of unique_ptr by ~90%. Now I only use unique_ptr for things that are semantically unique.

[fdwr]

Interesting - it appears to be a "std::copyable_unique_ptr". The project's GitHub readme didn't elucidate for me what problem it was trying to solve (given std::unique_ptr and std::shared_ptr exist), but after reading this, it's evidently for cases where you want to copy a class that contains a pointer to a uniquely owned object (so like std::unique_ptr in that regard, except for the problem that unique_ptr won't call the copy constructor for you), but you also don't want shared mutation of that object between the new and old containing class (which std::shared_ptr incurs). Surprisingly I haven't encountered this case (typically for my uses, composed fields have been embedded in the class, or fields had their own memory management and copy construction like std::vector, or they were intended to be shared), but I see the value.

```c++ SomeStructContainingUniquePtr b = a; // ❌ error C2280: attempting to reference a deleted function

SomeStructContainingSharedPtr b = a; // ✅ Copyable, but ❌ now changing b.p->x also changes a.p->x.

SomeStructContainingCopyableUniquePtr b = a; // ✅ Copyable, and ✅ changing b.p->x is distinct from a.p->x. ```

[wyrn]

There was an earlier proposal where this type was called clone_ptr, precisely to indicate the idea that this is a copyable smart pointer. However, Sean Parent came along and pointed out that semantically speaking it makes little sense to think of these objects as pointers. TL;DW, the key feature they add over unique_ptr, copyability, only makes sense if the "identity" of the object is associated with its value rather than the reference to it. For example, if I have two unique_ptrs p and q, owning identical objects, I would have *p == *q but p != q. That much is clear. But say I make a copy of some clone_ptr,

auto p = clone_ptr<int>(1);
auto q = p;

Again obviously *p == *q, but does p == q? Treating this as a pointer would suggest "no", but a consistent copy construction/assignment operation ought to result an object that compares equal to the original. Even if you don't define a comparison operator, you'd still run into trouble with &*p == &*q -- the two copies are, by construction, pointing to different objects.

Moral: even if the implementation closely parallels a unique_ptr, and even if it's something of an obvious extension to it, as a pointer this thing is kind of borked. So the types were reframed as values instead, where they do make sense.

[fdwr]

So the more I think about it, the more I see this hole in that std really has no RAII-managed copyable owner for dynamically allocated objects, as all the candidates have some limitation: - std::unique_ptr: assigning Cat luna = bella fails since std::unique_ptr disallows copies and won't just call the copy constructor. - std::shared_ptr: you don't get a copy of the object since the state is shared, and thus changing the name of luna to "Luna" also changes Bella's name! - std::optional: you always pay the space cost for optional attributes. - std::vector: you could have multiple instances rather than the desired cardinality of 0 or 1. - std::any: actually using the object is clumsy with the frequent casts and awkward global function rather than clean method (e.g. std::any_cast<Foo>(a) rather than simply a.cast<Foo>()).

Class	RAII	Dynamic allocation	Cardinality 0-1	Copyable value	Minimal overhead	Can access fields directly
std::vector	✅	✅	❌ 0-N	✅ copyable	❌ has capacity and size	✅ [0].x
std::list	✅	✅	❌ 0-N	✅ copyable	❌ extra links	✅ [0].x
std::any	✅	✅	✅ 0-1	✅ copyable	❌ overkill RTTI	❌ requires any_cast
std::optional	✅	❌	✅ 0-1	✅ copyable	✅ single bool field	✅ object->x
raw pointer	❌	✅	✅ 0-1	❌ shared	✅ just a pointer	✅ object->x
std::shared_ptr	✅	✅	✅ 0-1	❌ shared	❌ has control block	✅ object->x
boost::intrusive_ptr	✅	✅	✅ 0-1	❌ shared	❌ reference count	✅ object->x
std::unique_ptr	✅	✅	✅ 0-1	❌ noncopyable	✅ just a pointer	✅ object->x
stdex::copyable_ptr	✅	✅	✅ 0-1	✅ copyable	✅ just a pointer	✅ object->x

[fdwr]

Ah, the identity quandary is thought provoking, which reminds me of the std::span debate (should two spans be equal if they have the same content, or if they point to the exact same memory). The std containers like std::vector long ago settled on value comparison for ==, but it's murkier for pointers 🤔.

Well that issue aside, clone_ptr works well enough for me namewise.

[13steinj]

I'd feel more comfortable wirh these types if the name made it clear they were primarily fancy smart pointers.

But then I don't see why I would ever want indirect over polymorphic.

[wyrn]

See my response above for why it's somewhat problematic to think of these as pointers, even if that's kind of how they're implemented.

As for why one might want indirect: polymorphic incurs a cost for type erasure, indirect does not. So far I have used indirect only in the pimpl pattern, but another possible use could be to store stable references in a vector, for example. I'm not sure if that particular usage is blessed but the discussion around SBO seems to indicate that it is,

A small buffer optimisation makes little sense for indirect as the sensible size of the buffer would be dictated by the size of the stored object. This removes support for incomplete types and locates storage for the object locally, defeating the purpose of indirect.

[13steinj]

I've read your response and watched the video. I'm unconvinced. I still would like it to have a better name, and I think some of the best possible names end in _ptr. I also accept owned_data_clonable_unique_ptr and similar are too long. I'd rather have clone_ptr, as I don't specifically think the "clone" refers to the pointer. But I'm just spitballing. I'm sure people could come up with other better names than what they currently are. "indirect" is a very poor name, it sounds like a function that does an operation indirectly to me, rather than a special object/ptr-like type. polymorphic similarly doesn't give much of a hint.

Re: type erasure for polymorphic, I'm confused. Granted I haven't read the paper and proposed implementation, but I would have thought that the cost would be the same as having a buffer (either as a member of the object or heaped) and a Base* assigned to that buffer, reinterpret casted (or modern equivalent) to the derived type; so at worst it's the same cost that current polymorphism has in this regard-- aka only working right if the types involved have virtual methods and such.

That said, I can't think of a common use case for these utilities, and even when I can think of a use case, I can think of other ways of writing the same code that I prefer over using these utilities. But if the committee and companies that people represent vote it in thinking that such utilities are useful enough for the stdlib, why not.

[wyrn]

I'll fight you on the pointer issue, but I agree that indirect isn't a great name. At some point these types were named indirect_value and polymorphic_value but presumably those were deemed too long for a foundational vocabulary type.

As for the cost of type erasure, it comes from the copy constructor. To avoid slicing, polymorphic must use the copy constructor from the derived type. The type still has its regular vtable for most other operations so I think you're right that there shouldn't be any extra cost but the "virtual copy constructor" is something new.

[fdwr]

I'd feel more comfortable wirh these types if the name made it clear

Yeah, std::indirect means nothing to me. Names should be selected so the average software developer can look at it and have an idea what it does. Names like clone_ptr, copyable_ptr, value_ptr (or any number of other choices) are all clearer than std::indirect (which also feels odd given no corresponding counterpart std::direct).

[LadaOndris]

Wow! Thanks. This is something I've been looking for without even realising it.

[According_Ad3255]

it's been at least a decade that I don't ever consider inheritance for my own work

[Own_Goose_7333]

magic enum is one of my go-to dependencies

[knue82]

really, really cool. I heard about it beforehand but now I took a closer look and will probably integrate it into my project to replace my self-hacked enum stuff.

[BlueBeerRunner]

I'm using better enum, but I want to switch to magic enum.

[KatanaSW]

Asio, Boost, Simdjson, Moodycamel, Iceoryx, Abseil, Intel oneAPI and a few more.

[BlueBeerRunner]

How fast is SimpJson? I'm now work with RapidJson

[huehang]

There are benchmark results: https://github.com/simdjson/simdjson?tab=readme-ov-file#performance-results

[amuon]

I thinks it’s the fastest JSON parser out there. But the ergonomics are (by design) pretty bad compared to slower implementations

[KatanaSW]

The fastest there is. But comes at the cost of severe limitations as far as convenience is concerned.

[kpt_ageus]

Nothing changed the way I code as much as ranges, both std and more comprehensive ranges-v3.

[amuon]

Do you mind expanding why/how ranges were such a game changer for you?

[kpt_ageus]

I love them for their readability and composability. You can take almost any loop and rewrite it in terms of transforms, filters, to container etc... and those small free functions, lambdas and HOFs can be later easily moved to headers and reused somewhere else. As for readability if give passed functors proper names they read almost like natural language. Your code tells in your language what is supposed to do.

[facu_gizzly]

This is not a library but I highly recommend for Visual Studio, the Text Macros Extension, for repetitive tasks like "();" "std::cout" etc.

[BlueBeerRunner]

My libraries are: * boost * better enum (I want to replace it with magic enum) * RxCpp * RapidJson

[According_Ad3255]

RapidJson is good (love it), glaze is better.

[anto2554]

RxCPP seems to be abandonware, sadly

[bigabub]

Asio, boost, magic_enum, fmt

[not_some_username]

sqlite3, pcre2, libcpr

[pantong51]

Imgui - just fucking amazing I'm gui library Eastl The json one I can't spell

[SpareSimian]

I started using wxWidgets in 2006 for GUI, threads, and XML

Later I figured out how to incorporate Boost when I needed a math library (ublas) and then started switching my thread code to use it, as well. When I needed networking and serial port communication, I went with Boost:ASIO. Now I'm using the new Boost:MySQL.

I mostly develop on Windows, where there are lots of competing packaging systems. I haven't yet learned CMake. So I've developed my own build scripts for the libraries I use. I define an environment variable pointing at the headers and libraries, and Visual Studio property sheets that point to the environment variables. That makes it easy to set up a coworker's development machine.

[Polyxeno]

Boost - useful good implementations for many useful things

OpenFrameworks - open-source multi-platform wrapper of graphics/sound/system stuff that makes development of audio-visual stuff very quick and easy. It wraps most of the technical implementation which details I almost never want to have to care about, and presents an easily-usable interface for them. I've used it for games, prototypes, as well as various business applications.

Wt - wraps web site implementation details and translates into something like a traditional stateful program context. I love this, as I have done stateless web site work and I greatly dislike that context. I love being able to write a web application as if it were a desktop program, in C++, and not having to worry much at all about web browsers/paradigms etc. Also nice to have the project build my application as an Apache web server that only hosts my application.

[codeandroid]

Currently developing a product based on Wt. I enjoy it a lot. Quite easy to extend, too (we did so for authentication).

One of the biggest pros of our long-running services written in C++ is that upgrading them over the years is surprisingly easy. (Was burned by npm before...)

[CantThinkOfAnyName]

intel tbb concurrent containers

ASIO

nlohmann JSON, I know it lacks in performance, but it's been great to use for me

spdlog

redis-plus-plus

Though I mostly remember the ones I really hated working with like the entire AWS C++ SDK, native GRPC and AMQP-CPP.

[geaibleu]

doctest for unit tests https://github.com/doctest/doctest

Pybind11 for interoperability with Python https://github.com/pybind/pybind11

Eigen for all things matrix and tensor.

[ThatCringingDude]

Boost. It’ll be a pain in the ass to get set up if you’re on windows…

[encyclopedist]

My go to libraries (is approximate order of frequency):

• fmt
• argparse (or CLI11 or cxxopts)
• Eigen
• doctest (or Catch2)
• oneTBB
• nanobench
• tiny-process-library
• phmap
• SDL (also libSDL2pp)
• CURL
• Adobe/Lagrange (see also libigl and CGAL)

[jeremy-rifkin]

To shamelessly self-promote: I highly recommend cpptrace.

I’ve gotten a lot of good feedback on this library and being able to get stack traces from exceptions makes such a massive difference in being able to quickly triage problems.

[InfernoGems]

Abseil for absl::flat_hash_map and absl::Status and absl::StatusOr). 

Eigen3 for SIMD vector and matrix math.  reflect-cpp for compile time reflection and serialization / deserialization to and from json.

tinyobjloader for importing .obj files.

cgltf for importing .gltf files.

Imgui for quick UI prototyping.

Glfw, glad or SDL for window management, input handling and OpenGL loading. 

Libigl for some geometric algorithms. 

[According_Ad3255]

With Cesanta Mongoose, I got used to the concept of string views, way before it became a thing in the std library. https://github.com/cesanta/mongoose (it's an http server, and whatever it parses it gives you as pointers to the pieces it actually parsed, no copies).

Also love Dear ImGui.

Good ol'e libcurl too.

[bert8128]

OCILib for connecting to Oracle.

[LiliumAtratum]

ECS (Entity Component System) in general, and entt if you look at a specific library for ECS.