I have considering alternative syntax, and attribute among them.

While attribute is something in the right direction, it doesn’t get us there.

Because for 1 attributes can be ignored.

But I want if there’s a method to call

For example:  x.method(); then the const version of that method should be picked, something you wouldn’t be able to do with an attribute.

From: Std-Proposals <std-proposals-bounces@lists.isocpp.org> On Behalf Of Sebastian Wittmeier via Std-Proposals
Sent: Sunday, February 16, 2025 2:59 PM
To: std-proposals@lists.isocpp.org
Cc: Sebastian Wittmeier <wittmeier@projectalpha.org>
Subject: Re: [std-proposals] Delayed const declaration

You use an attribute-like syntax now (probably as placeholder).

However, that would be an actual alternative:

Create an attribute that the compiler (may) give a warning or an error, if the variable is modified.

Advantage: Standard syntax. Ignorable.

Small issues:

 - Some entity has an attribute. Attributes do not stand alone. One could just give the variable name (l-value) as an expression:

int x = 0;

x = 1;

[[const]] x;

- Attributes can be ignored. Overload resolution would still see the non-const x (to keep the attribute ignorable). Solution: Instead of actually making the variable const, call it

[[warn-if-modified]] x;

-----Ursprüngliche Nachricht-----
Von: Bo Persson via Std-Proposals <std-proposals@lists.isocpp.org>
Gesendet: So 16.02.2025 12:54
Betreff: Re: [std-proposals] Delayed const declaration
An: std-proposals@lists.isocpp.org;
CC: Bo Persson <bo@bo-persson.se>;
On sön 2025-02-16 at 12:08, Tiago Freire via Std-Proposals wrote:
> If you are going to do that, perhaps we can simplify the syntax a little
> bit.
>
> Instead of having to declare [mutable const] which makes the variable
> open for writes like any other regular variable.
>
> We could just omit [mutable const] and deduce that after the fact
> depending on either or not a close statement is used, instead of:
>
> [mutable const] int x = 0;
>
> const x;
>
> you would simplify it as:
>
> int x = 0;
>
> const x;
>

The two-step declaration has the disadvantage that it invites typos. Or
when you change the name of x, you might forget the const declaration
half a page further down. Now some other x is const?

This reminds me of a similar problems with goto, where added code before
and after the label affects what the goto means (in a totally different
location).


--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals