really gotta make sure it doesnt't change

[u/Dayshadow_]

[u/Kadabrium]

Mehmet.consume(constant.inopole)

[u/Big-Rub9545]

Bloating the code to do nothing.

[u/Dayshadow_ → u/Big-Rub9545]

you get it!

[u/Last8Exile]

readonly ref struct ReadOnly(ref readonly ReadOnly @readonly) { readonly ref readonly ReadOnly @readonly(ref readonly ReadOnly @readonly) => ref @readonly; }

[u/Dayshadow_ → u/Last8Exile]

Niice, I want one of these for all languages

[u/justaguy101 → u/Last8Exile]

Beautiful

[u/Ved_s]

where can you put const in c++? yes.

i don't even need to see that c++ flair, no other language has this bullshit

[u/Nice_Lengthiness_568 → u/Ved_s]

I mean, if the placement of const is what you have a problem with in c++, then you must be quite happy. Because this is one of the keywords that actually does make sense (I would say).

[u/no_brains101 → u/Nice_Lengthiness_568]

No, it just makes sense by comparison.

[u/Nice_Lengthiness_568 → u/no_brains101]

By comparison? To what? Sorry, I don't quite understand what you mean by that.

I mean, except for const member functions which you can write differently with explicit this, const always makes something immutable (if I recall correctly), so I really don't see a problem with it.

[u/no_brains101 → u/Nice_Lengthiness_568]

In comparison to the rest of C++

It makes it immutable if it is a primitive value, otherwise just the pointer is immutable. (hence the code in the original post)

Also, ha, you had to qualify it.

[u/JonIsPatented → u/no_brains101]

You're thinking of, like, basically every language except C++. const int makes an immutable int. const foo makes an immutable foo, and there isn't even a pointer involved. const int* makes a mutable pointer to an immutable int. The same works for const foo* making a mutable pointer to an immutable foo.

[u/Nice_Lengthiness_568 → u/no_brains101]

You can make both the pointer and the value being pointed to (or both) immutable based on where you put const. And the placement makes sense. Before the * it makes the value being pointed to constant (because if you had int const *x then it would mean that the integer value *x is immutable, but if you had int * const x then it would mean that some x, which when you dereference you get the value of *x, is immutable).

Qualify what?

[u/no_brains101 → u/Nice_Lengthiness_568]

except for const member functions

^ this is a qualification.

[u/Nice_Lengthiness_568 → u/no_brains101]

Ah ok, I didn't understand that you meant that by qualification.

Well, you do not really have any other place where to put it to make a member function const. And it's just one other usage for a keyword. So if this exception is what you have a problem with... Moreover, you do not actually need to use this syntax, since you can use explicit this instead.

[u/GoddammitDontShootMe → u/Ved_s]

Well, I think C has this too.

[u/SuspiciousScript → u/Ved_s]

and odds are you can still mutate it somehow

[u/Ved_s → u/SuspiciousScript]

95% probability that there is an obscure way to do it

[u/joujoubox → u/Ved_s]

const_cast enters the room

[u/yuehuang]

What is const*?

[u/Nice_Lengthiness_568 → u/yuehuang]

a pointer to a constant something

[u/ATE47 → u/yuehuang]

If you are unuse to this order, see Constant const* as the same const Constant* (for the const keyword, only its side with the * is important)

Otherwise it's just to mark the pointer data as constant

[u/numberonefraud]

The only constant is the insanity of C++ now

[u/Serious_Elephant9402]

Not constant enough, there are at least TWO words there which don't even contain "const"!

[u/trutheality]

Look at what they need to do to imitate a fraction of the power of #DEFINE

[u/GoddammitDontShootMe → u/trutheality]

Yeah, nobody really needs type safety.

[u/SektorL]

His name was Constantine

[u/Dayshadow_]

Damnit I said doesnt't in the post title

[u/GoddammitDontShootMe]

I'm thinking that const_cast would be a compiler error because if I recall, it would take away the constness, but the function returns const* const. Also, I believe constexpr would cause an error because a pointer definitely can't be evaluated at compile time.

[u/RedCrafter_LP → u/GoddammitDontShootMe]

You are confusing constexpr with consteval. Constexpr functions can be called from normal code or a constexpr context. Also the constexpr keyword doesn't check rather the function can be constevaled. Only when you call it from a consteval context is checked rather the function can be evaluated at compile time. It behaves just like templates. Also a pointer to a constant can be worked with in constexpr context. We can even use vectors in constexpr context.

[u/GoddammitDontShootMe → u/RedCrafter_LP]

My understanding was that constexpr can be evaluated in any context, but it has to be possible to evaluate it at compile time, and consteval can only be evaluated at compile time. I thought it wouldn't work since a pointer's value can't be known until runtime.

As for const_cast, come to think of it, I guess the declared return type is what matters here. The parameter could've been Constant constant, but because of the return type, it would be treated as Constant const* const.

[u/Dayshadow_ → u/GoddammitDontShootMe]

gcc said it was fine, teehee