67 lines
1.6 KiB
D
67 lines
1.6 KiB
D
import std.random;
|
|
|
|
// enum allows to define manifest (compile-time) constants:
|
|
int sqr(int x) { return x ^^ 2; }
|
|
enum int x = 5;
|
|
enum y = sqr(5); // Forces Compile-Time Function Evaluation (CTFE).
|
|
|
|
// enums are compile-time constants:
|
|
enum MyEnum { A, B, C }
|
|
|
|
|
|
// immutable defines values that can't change:
|
|
immutable double pi = 3.1415;
|
|
|
|
|
|
// A module-level immutable storage class variable that's not
|
|
// explicitly initialized can be initialized by its constructor,
|
|
// otherwise its value is the default initializer during its life-time.
|
|
|
|
immutable int z;
|
|
|
|
static this() {
|
|
z = uniform(0, 100); // Run-time initialization.
|
|
}
|
|
|
|
class Test1 {
|
|
immutable int w;
|
|
|
|
this() {
|
|
w = uniform(0, 100); // Run-time initialization.
|
|
}
|
|
}
|
|
|
|
|
|
// The items array can't be immutable here.
|
|
// "in" is short for "const scope":
|
|
void foo(const scope int[] items) {
|
|
// items is constant here.
|
|
// items[0] = 100; // Cannot modify const expression.
|
|
}
|
|
|
|
|
|
struct Test2 {
|
|
int x_; // Mutable.
|
|
@property int x() { return this.x_; }
|
|
}
|
|
|
|
// Unlike C++, D const and immutable are transitive.
|
|
// And there is also "inout". See D docs.
|
|
|
|
void main() {
|
|
int[] data = [10, 20, 30];
|
|
foo(data);
|
|
data[0] = 100; // But data is mutable here.
|
|
|
|
// Currently manifest constants like arrays and associative arrays
|
|
// are copied in-place every time they are used:
|
|
enum array = [1, 2, 3];
|
|
foo(array);
|
|
|
|
auto t = Test2(100);
|
|
auto x2 = t.x; // Reading x is allowed.
|
|
assert(x2 == 100);
|
|
|
|
// Not allowed, the setter property is missing:
|
|
// t.x = 10; // Error: not a property t.x
|
|
}
|