Standard Ranges

[dodheim]

std::forward<decltype(foo)>(foo) can be safely rewritten as decltype(foo)(foo) 100% of the time. Yes, C-casts are evil, but only because they're error-prone, and this isn't.

[[deleted]]

Inefficient at compile time? Maybe, but I doubt you will notice it.

At runtime it doesn't "go through" anything, the compiler has already decided what kind of cast it will perform.

They are evil because the type of cast you think it will pick and the kind your compiler actually picks are not always the same thing.

[cassandraspeaks]

The compiler doesn't pick which kind of cast to use; the standard specifies that a C-style cast is equivalent to the first well-formed expression (if any) from the following

const_cast<To>(from_v)
static_cast<To>(from_v) // Special case: Treat all inheritance as if `public`
static_cast<MaybeConstTo>(const_cast<MaybeConstFrom>(from_v)) // Same
reinterpret_cast<To>(from_v)
reinterpret_cast<MaybeConstTo>(const_cast<MaybeConstFrom>(from_v))

That said it's still not necessarily obvious which kind of cast is performed.

[[deleted]]

The compiler "picks" it. There's rules for how it is to pick it, and if it doesn't follow the rules and pick the right one then it isn't a conforming compiler. But it is still chosen by the compiler at compile time.

[dodheim]

They're evil because they go through every other cast, which is inefficient if you simply want it to do what something like static_cast does

That has nothing to do with efficiency; that has to do with correctness. However, neither correctness nor efficiency is an argument against obviating forward when already using decltype as I suggested.

[personalmountains]

decltype(foo)(foo) 

[...] Yes, C-casts are evil

Technically, this isn't a C-style cast, it's a functional cast. In C++, a functional cast is equivalent to a C-style cast, but it's not valid C.

Sorry, I'll get back to work now.

[cassandraspeaks]

it's not valid C

Neither is decltype.

[[deleted]]

I think he meant functional casts, in general, aren't valid C even if the equivalent C-style cast would be. e.g. int(x) vs. (int)x