Initializing variables
Introduction
D inherits from C and C++ in its basic style of variable initialization. For example:
int x = 10;
declares a variable named x of type int, whose initial value is 10.
However, because D has static type inference, there is often no need to explicitly specify the type of the variable:
auto x = 10;
declares an int variable named x, whose initial value is 10. The type of x is automatically deduced to be int, because the decimal integer literal 10 has a type of int.
Structs
Structs are initialized using a constructor-like syntax:
struct MyStruct
{
int x;
string z;
}
MyStruct ms = MyStruct(10, "abc");
However, since the constructor-like syntax already specifies what the type of ms will be, it does not need to be repeated:
auto ms = MyStruct(10, "abc");
Classes
Class objects are initialized with the new keyword:
class MyClass
{
int x;
this(int _x) { this.x = _x; }
}
MyClass mc = new MyClass(123);
Again, static type inference allows us to only name the class once:
auto mc = new MyClass(123);
This is helpful especially when the class name is long:
class ThisIsAClassWithAVeryLongName { ... }
// This is a lot of unnecessary typing to do:
ThisIsAClassWithAVeryLongName mc = new ThisIsAClassWithAVeryLongName();
// This is much better:
auto mc = new ThisIsAClassWithAVeryLongName();
Const, immutable, etc.
The auto keyword actually does not mean "automatically infer the type"; it actually means "automatic variable", as in, not a class member but a variable allocated in its scope. When coupled with static type inference, it serves as a convenient placeholder for the omitted type name.
So, declaring a const int or immutable variable can be written this way:
const x = 10; // the type of x is const(int)
immutable y = 20; // the type of y is immutable(int)
const ms = MyStruct(123, "def"); // the type of ms is const(MyStruct)
const mc = new MyClass(321); // the type of mc is immutable(MyClass)
