digitalmars.D.learn - Local static variables must have unique names within a function's
- tipdbmp (16/16) Jan 19 2018 The following seems to work in C++, but errors in D, why is that?
- Simen =?UTF-8?B?S2rDpnLDpXM=?= (7/24) Jan 19 2018 19.17.1.3 explains the fact that they need to have unique names,
- tipdbmp (12/15) Jan 19 2018 // example from: 19.17.1.3
- H. S. Teoh (38/54) Jan 19 2018 I think this is more an implementational quirk than any deliberate
- Steven Schveighoffer (3/30) Jan 19 2018 Related: https://issues.dlang.org/show_bug.cgi?id=17653
- Jonathan M Davis (8/31) Jan 19 2018 This limitation gets especially annoying when you start doing stuff like
The following seems to work in C++, but errors in D, why is that?
int foo(int* num) {
{
static int x = 10;
x += 1;
*num += x;
}
{
static int x = 20; // error: foo.x is already defined in
another scope in foo
x += 2;
*num += x;
}
return 0;
}
https://dlang.org/spec/function.html#local-static-variables
Jan 19 2018
On Friday, 19 January 2018 at 11:02:01 UTC, tipdbmp wrote:
The following seems to work in C++, but errors in D, why is
that?
int foo(int* num) {
{
static int x = 10;
x += 1;
*num += x;
}
{
static int x = 20; // error: foo.x is already defined
in another scope in foo
x += 2;
*num += x;
}
return 0;
}
https://dlang.org/spec/function.html#local-static-variables
19.17.1.3 explains the fact that they need to have unique names,
but doesn't provide a reason. Mostly, it's just a bad idea - it's
very easy for a person reading the code after you've written it
to get the two x's mixed up.
--
Simen
Jan 19 2018
Mostly, it's just a bad idea - it's very easy for a person reading the code after you've written it to get the two x's mixed up.// example from: 19.17.1.3 void main() { { static int x; } { static int x; } // error { int i; } { int i; } // ok } I don't really see how the 'static' storage class would make 2 variables with the same name in different scopes "easier to mix up" compared to 2 variables with the same name in different scopes but declared without the 'static' keyword.
Jan 19 2018
On Fri, Jan 19, 2018 at 02:16:24PM +0000, tipdbmp via Digitalmars-d-learn wrote:I think this is more an implementational quirk than any deliberate decision on variable names being "easier to mix up". A static variable currently mangles to a combination of the function name and variable name, so if there are multiple static variables with the same name, their mangled names would collide. OTOH, it would really suck if non-static variable names can't be reused in nested scopes, because it would mean you have to invent new names for, say, loop variables for every loop in the same function: void func(int[100] a, int[100] b) { foreach (i; 0 .. 100) { a[i] = i; } foreach (i; 0 .. 100) { b[i] = i; } // this would fail } Fortunately this is not the case. However, the static variable case is annoying, and it's actually one case of a larger problem: void main() { foreach (i; 0 .. 10) { struct S { int x; } auto s = S(i); } foreach (i; 11 .. 20) { struct S { // <---- this is line 9 int y; } auto s = S(i); } } The compiler says: test.d(9): Error: declaration S is already defined in another scope in main even though the respective scopes of the declarations are disjoint. IMO, this is a needless, arbitrary restriction. Worse yet, the compiles ICEs after this, so I filed a bug: https://issues.dlang.org/show_bug.cgi?id=18266 T -- Latin's a dead language, as dead as can be; it killed off all the Romans, and now it's killing me! -- SchoolboyMostly, it's just a bad idea - it's very easy for a person reading the code after you've written it to get the two x's mixed up.// example from: 19.17.1.3 void main() { { static int x; } { static int x; } // error { int i; } { int i; } // ok } I don't really see how the 'static' storage class would make 2 variables with the same name in different scopes "easier to mix up" compared to 2 variables with the same name in different scopes but declared without the 'static' keyword.
Jan 19 2018
Steven Schveighoffer <schveiguy yahoo.com>
On 1/19/18 1:11 PM, H. S. Teoh wrote:
Fortunately this is not the case. However, the static variable case is
annoying, and it's actually one case of a larger problem:
void main() {
foreach (i; 0 .. 10) {
struct S {
int x;
}
auto s = S(i);
}
foreach (i; 11 .. 20) {
struct S { // <---- this is line 9
int y;
}
auto s = S(i);
}
}
The compiler says:
test.d(9): Error: declaration S is already defined in another scope in main
even though the respective scopes of the declarations are disjoint. IMO,
this is a needless, arbitrary restriction. Worse yet, the compiles ICEs
after this, so I filed a bug:
https://issues.dlang.org/show_bug.cgi?id=18266
Related: https://issues.dlang.org/show_bug.cgi?id=17653
-Steve
Jan 19 2018
On Friday, January 19, 2018 10:11:36 H. S. Teoh via Digitalmars-d-learn
wrote:
Fortunately this is not the case. However, the static variable case is
annoying, and it's actually one case of a larger problem:
void main() {
foreach (i; 0 .. 10) {
struct S {
int x;
}
auto s = S(i);
}
foreach (i; 11 .. 20) {
struct S { // <---- this is line 9
int y;
}
auto s = S(i);
}
}
The compiler says:
test.d(9): Error: declaration S is already defined in another scope in
main
even though the respective scopes of the declarations are disjoint. IMO,
this is a needless, arbitrary restriction. Worse yet, the compiles ICEs
after this, so I filed a bug:
https://issues.dlang.org/show_bug.cgi?id=18266
This limitation gets especially annoying when you start doing stuff like
generating tests using static foreach. In those cases, any helper types or
functions that you have can't be inside the static foreach. To an extent,
you can get around it using a templates outside of the static foreach, but
it's still annoying.
- Jonathan M Davis
Jan 19 2018