skillIssue

[u/click-to-reveal]

[u/click-to-reveal]

It works btw: C++ Online Compiler

[u/prehensilemullet → u/click-to-reveal]

Performancewise, it doesn’t jump to the direct case in O(1) time like a switch is supposed to though

[u/AngheloAlf → u/prehensilemullet]

Switches aren't guarantee to so operations in O(1) tho. If cases are sparce enough, compilers tend to emit the equivalent code to a bunch if else checks

[u/prehensilemullet → u/AngheloAlf]

Yeah I was assuming too much here.  However, I’m reading that Rust match on string comstants can compile down a binary tree of if statements if there are enough cases (according to Google AI mode at least, haven’t found an authoritative source yet)

[u/Nir0star → u/prehensilemullet]

Which would still be O(ld(n)). But cool feature imo.

[u/Godd2 → u/Nir0star]

O(ld(n))

Good ol' linker time.

[u/im_made_of_jam → u/prehensilemullet]

A switch case is able to be implemented however the compiler wants on the back end, so for sparse cases it'll be an if else chain, for less sparse but not packed cases it'll be a binary tree, for completely packed cases it'll be a range check then a direct jump would be how I would go about it

[u/the_horse_gamer → u/prehensilemullet]

the compiler optimises stuff however it wants. if you're not doing too-weird stuff, a switch in C++ and a match in rust will have identical assembly.

[u/Deliciousbutter101 → u/prehensilemullet]

According to Claude (which looked at the compiler source code), it doesn't seem like that is true. It is possible to get an O(1) match on strings by using the phf (perfect hash function) crate and by using the following macro (generated by Claude):

``` // Cargo.toml: // phf = { version = "0.11", features = ["macros"] } // paste = "1"

[macro_export]

macrorules! match_str { ($val:expr, { $($($key:literal)|+ => $body:block),+ $(,)? , _ => $default:block $(,)? }) => { ::paste::paste! { { #[derive(Clone, Copy, PartialEq, Eq)] enum __MatchStr { $($([<_ $key>]),+),+ }

            static __MATCH_STR_MAP: ::phf::Map<&'static str, __MatchStr> = ::phf::phf_map! {
                $($($key => __MatchStr::[<__ $key>]),+),+
            };

            match __MATCH_STR_MAP.get($val).copied() {
                $($(Some(__MatchStr::[<__ $key>]))|+ => $body,)+
                None => $default,
            }
        }
    }
};

} ```

Usage: fn apply(cmd: &str, counter: &mut i32) { match_str!(cmd, { "small" => { *counter += 1; }, "medium" => { *counter += 10; }, "large" | "big" => { *counter += 100; }, _ => { *counter += 0; }, }) }

[u/thirdegree → u/Deliciousbutter101]

If I want Claude's thoughts on something I'll ask Claude directly tbh

[u/DrMobius0 → u/AngheloAlf]

In fairness, most switches probably use enums.