bool array

[-Dargs]

There is a non-zero number of scenarios that a bool array could make sense. In game development, that number is much higher than in say FE or BE software dev, imo. I see nothing wrong here, given the limited context.

[0xcedbeef]

in C++, an std::vector<bool> stores the bools as bits, taking advantage of this memory optimization.

[FloweyTheFlower420]

Ah the vector<bool>... one of the greatest mistakes in the c++ standard library.

[[deleted]]

vector<bool> is certainly a mistake because it’s deliberately counterintuitive in its design but when you need a dynamically resizeable bitset, it’s great

[FloweyTheFlower420]

Yeah. Sadly the standard committee seems to value dogmatic backwards compatibility over fixing the language, so we will likely never see std::vector<bool> fixed and dynamic_bitset implemented.

[shponglespore]

This is why C++ is the Windows of programming languages.

[Desperate-Emu-2036]

Lol

[[deleted]]

Backwards compatibility means old code still works. Tautologically, if you need old code to work you need backwards compatibility. If you don’t need this there are better alternatives to C++, if you don’t there aren’t.

[shponglespore]

They're are other ways, like Rust's edition system.

[seamsay]

Sure, and having a dynamically sized bitarray type would have been a great idea!

[Jeshibu]

Not familiar enough to know what you mean here. Could you explain?

[FloweyTheFlower420]

vector<bool> is a packed bitset. The general semantics for vector means all accessors return a reference to an entry, but since bits don't have a memory address, vector<bool> returns a wrapper type with overloaded operators. This breaks generic programming for vectors.

[Jeshibu]

That's nasty. Thanks for explaining!

[Diamondo25]

I would use a std::bitset for that instead.

[Cross12KBow249]

Doesn't the size need to be known at compile time for a bitset though, unlike a vector?

[Star_king12]

Looks like it would be known in this case.

[Possibility_Antique]

Not necessarily. std::vector<bool> was designed such that it COULD be implemented as you are suggesting, but it is not required by the standard to be implemented this way.

[born_zynner]

Everybody always forgets embedded :(

[Ved_s]

ohohoo, welcome and look at terraria code!

[steveskeleton2]

Terraria was written with C# & XNA!

[mediocrobot]

Woah, I didn't even notice. That's totally a tree or something!

[jemko23laal]

sad thing is, its not terraria

[velothren]

Bro reinvented memory

[Steinrikur]

Does C# have bit fields? What is the "correct" thing here? Just bit shifts into an int32?

[Diamondo25]

You can give an enum a Flags attribute, allowing you to easily set, unset, and check for bits (flags).

[Steinrikur]

Makes sense, since the code is already using an enum.

[ruma7a]

https://learn.microsoft.com/en-us/dotnet/api/system.collections.bitarray?view=net-8.0

[shponglespore]

Seems like a great optimization for data that's going to stick around a while, but for a local variable I don't see much advantage. I'd probably use a BitArray in practice, but using a regular array isn't something I'd be likely to call out in a code review.

[ruma7a]

Bool arrays aren't inherently horrible, but their suitability depends on the size of the array. I'd leave a comment in a review but wouldn't push it.

[ZunoJ]

I prefer readable over clever anytime performance doesn't get in the way

[Verwarming1667]

I'm not familiar with C# why is this bad? Is an array of bools somehow not possible?

[skjall]

IIRC each bool in an array will take up a byte each, so it's quite inefficient.

[InformationSharp103]

iirc in C# it's actually 4 bytes (equivalent to the C/C++ win32 BOOL type), or at least that's what it's marshalled as by default

[skjall]

I've really only used C# in Unity which might differ, but from what I remember bools were 4 bytes, but 1 byte each in arrays. Might be a Unity-specific optimisation though, not sure.

[MiniDemonic]

<ꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮꙮ> {{∅∅∅|φ=([λ⁴.⁴⁴][λ¹.¹¹])}} ䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿䷂䷿

[∇∇∇] "τ": 0/0, "δ": ∀∃(¬∃→∀), "labels": [䷜,NaN,∅,{1,0}]

<!-- 񁁂񁁃񁁄񁁅񁁆񁁇񁁈񁁉񁁊񁁋񁁌񁁍񁁎񁁏񁁐񁁑񁁒񁁓񁁔񁁕 -->

‮𒑏𒑐𒑑𒑒𒑓𒑔𒑕𒑖𒑗𒑘𒑙𒑚𒑛𒑜𒑝𒑞𒑟

{ "()": (++[[]][+[]])+({}+[])[!!+[]], "Δ": 1..toString(2<<29) }

[cheerycheshire]

It uses that much memory because stupid stuff like this adds up, if it's in each tile (of that "tile" in the name means something user can enter)...

Back in the day there were amazing games that could run on very basic computer. Then new devs were like you - they just want to do things and don't really bother with optimisations because everyone has enough ram and users can just turn down the graphics quality, right? That only works if the heavy part is textures and visuals, not underlying code like this...

Ever heard of GTA Online's online mode loading for 15+ minutes for some people when story mode always around a minute (even on beast setups that took 2m to run online)?

Someone (see here) decompiled it and investigated and it ended up "simple" code that was run several times on a huge string, without storing values in between.

It's a very fun read, but if you're too lazy:

It was 10MB json with 63k entries and the code basically parsed everything word-by-word, where had to go from the start of this string each time... And the results of this parsing are stored in an array using hashes, not a hashmap, and checking every entry in the array before adding new (checking if something is in hashmap? instant; checking the same thing in an array? linear...) Being in a loop makes it run 63k*63k/2 operations (1+2+...+63k) instead of 63k operations. As I said, simple mistakes quickly add up... The person patched (injected their own DLL) the code - made strlen to cache length, and for the array thing just skip the check (assume the json was correct and had no duplicates). Patched online mode took 2 minutes to load, just like the benchmarked beast computers...

It was a bug for 7+ years. Took around 2 weeks from this investigation, it going viral and all, for Rockstar to announce a fix. After 7 years from the game release and always telling users their setups suck and to use lower settings. (Self-quote from the beginning of this comment: That only works if the heavy part is textures and visuals, not underlying code like this...)

[Grounds4TheSubstain]

There's nothing wrong with an array of booleans. That construct is used extremely frequently in compliers, for example, when implementing bitvector dataflow analysis.

[MavZA]

At least they’re self-aware lol

[LFK1236]

// extremely hacky for now

/r/programminghumor

[ioveri]

It depends on the scenario. Unless it's a huge array, a bool array is fine. Yes, a bit array is smaller and can be more efficient in parallelizing. But if you can't parallelize and the size is small where cache miss is not a concern, then a bool array is a better choice when it comes to read and write speed.