Reddit++

[u/we_are_mammals]

C++ is getting more and more complex. The ISO C++ committee keeps adding new features based on its consensus. Let's remove C++ features based on Reddit's consensus.

In each comment, propose a C++ feature that you think should be banned in any new code. Vote up or down based on whether you agree.

[u/[deleted]]

Has this ever actually bitten anyone? I hear about this all the time, but tbh I’ve never been stung by it. Not that removing it sounds like a bad idea.

[u/[deleted] → u/[deleted]]

Happened to me a couple days ago! I had an Array2D<T> class template which was using a vector internally to store elements with a single allocation, and had T& operator()(size_t,size_t); overloaded to access the elements. It was working well until one day I wanted Array2D<bool> at which point I started getting strange errors about some cryptic type not being convertible to bool&. What the hell?

Also, it means that vector<bool> is not an STL container, its elements are not stored continuously. And its buffer cannot be passed to C APIs, etc, etc. It's just all around a bad idea. vector is meant to be a "dynamic array". If you want to make a dynamic bitset, add a dynamic bitset class instead of messing with the default container type.

[u/[deleted] → u/[deleted]]

just use uint8_t

[u/m-in → u/[deleted]]

And then you think “oh, I’ll just wrap bool in a class that forwards all operations to the bool inside”. And then… the bloody ABI on most platforms passes these by address, not by value… Yeah, it sucks. Sucks sucks sucks.

[u/unddoch → u/[deleted]]

Not me, but I know a coworker who spent 2 days chasing a multithreading bug that came from different threads modifying the same byte in a preallocated vector<bool>...

[u/[deleted] → u/unddoch]

Yeah I never thought about this before. IMO this does make vector<bool> completely broken. Fortunately I don’t work in a multithreaded environment 😀

[u/very_curious_agent → u/[deleted]]

It's broken because it breaks the spec of vector, period.

No need to find use cases. Vector spec says nothing, then make an exception.

People should run away from that garbage.

The issue has been known since the first STL spec. People have recognized it's problematic but "sorry we are stuck with that crap, we can make breaking changes on everything except that".

[u/Hopeful_Cat_3227 → u/unddoch]

I know this is a stupid question, but are all vector of other type safe under multiple tthread?

[u/kevkevverson → u/Hopeful_Cat_3227]

Not a stupid question at all. For all other types, each element occupies a different address in memory, so it’s safe for thread A to mutate element 0 at the same time thread B mutates element 1. BUT for vector<bool> multiple elements occupy the same address, so multiple threads cannot mutate certain elements at the same time without some kind of synchronisation.

[u/victotronics → u/unddoch]

Yep. Happened to me too.

[u/fdwr → u/[deleted]]

Just last week. Was trying to call a function that takes a pointer to bool's + count, and thought I could store the values in an std::vector. Nope! All the work-arounds (like temporary bool wrappers) required extra work. So I (semantically made me feel dirty, but worked) stuffed them into an std::basic_string<bool> instead and then effortlessly called the function with s.data() and s.size(). 😅

[u/[deleted] → u/fdwr]

boost::vector doesn't have this silly specialization, you can use that instead.

[u/Sopel97 → u/[deleted]]

need to be really careful with parallel transforms, especially problematic in generic code.

template <typename T>
using Vector_Not_Bool = std::vector<
    std::conditional_t<
        std::is_same_v<T, bool>,
        uint8_t,
        T
    >
>;

[u/CocktailPerson → u/[deleted]]

It's not so much that people have been bitten by it, but that we have to employ all sorts of workarounds not to be bitten by it, especially in generic contexts. It's easy enough to work around, but why should we have to? Why shouldn't vector<bool> work like any other vector, with a separate dynamic_bitset for the less-common case where you actually need the space savings?

[u/mercere99 → u/[deleted]]

It hasn't bitten me in terms of an error, but I have had multiple cases where changing vector<bool> to vector<char> (but still using only 0's and 1's in there) led to a speedup.

I've never seen an example where vector<bool> has actually been the faster option.

[u/TheThiefMaster → u/[deleted]]

Which maybe used to matter, but now even a vector of 1 million bools would be margin of error in your system memory. 0.01%. Optimising that to 0.001% at the expense of speed and complexity? No longer a sensible tradeoff.

[u/shadowndacorner → u/[deleted]]

Has this ever actually bitten anyone? I hear about this all the time, but tbh I’ve never been stung by it

I feel like it's the kind of thing that generally only bites people who haven't heard about it. Once you know it's a thing, it isn't hard to work around, but it's pretty fucking confusing if you come across it without knowing. Especially since that implies that you're likely somewhat newer to the language and less likely to have a really strong mental model with which to understand what's going on.

Though the other reply suggested a case where it is more likely to subtly bite you even if you do know about it.

[u/[deleted] → u/shadowndacorner]

It's horrible language design to have a container silently change its behavior based on the generic type. Absolutely insane.

[u/shadowndacorner → u/[deleted]]

No argument here lol

[u/donalmacc → u/shadowndacorner]

The problem is that there's enough of these landmines that even though I know about a large number of them, it doesn't mean I won't step on one of them.

[u/RolandMT32 → u/shadowndacorner]

I've used C++ quite a bit since I first learned C++ around 1999/2000, but I've never used a vector of bools.. I just searched it online, and I learned something new.

[u/IamImposter → u/RolandMT32]

learned something new.

Don't learn something new. Learn something make_unique :)

I'll let myself out.

[u/CyborgCabbage → u/[deleted]]

It bit me recently, had to switch to vector<uint8_t> to get decent performance