Compile-time variables

[Kayomn]

On Friday, 6 April 2018 at 13:55:55 UTC, nkm1 wrote:
> On Friday, 6 April 2018 at 13:10:23 UTC, Kayomn wrote:
>> ID tags are unique and spsecific to the class type. There 
>> shouldn't be more than one type ID assigned to one class type.
>>
>> The idea behind what it is I am doing is I am implementing a 
>> solution to getting a type index, similar to 
>> std.variant.Variant.type(). The way that I implemented this in 
>> C++ is like so:
>>
>> --------------------------------------------------------------------------------
>> inline unsigned int getNodeTypeID() {
>>     static unsigned int lastID = 0;
>>
>>     return lastID++;
>> }
>>
>> template<typename T> inline unsigned int getNodeTypeID() {
>>     static unsigned int typeID = getNodeTypeID();
>>
>>     return typeID;
>> }
>> --------------------------------------------------------------------------------
>>
>> In this C++ example I am exploiting the fact that templates 
>> are generated at compile-time to execute getNodeTypeID for 
>> each new type instance generated. After initial type 
>> generation, whenever they are called at runtime they were 
>> return the ID assigned to that function template instance that 
>> was generated at compile-time.
>>
>> It's pretty simple, and to be honest I'm surprised this has 
>> been causing me such a headache implementing it in D.
>
> That's because the C++ code doesn't do what you think it does. 
> Apparently you think that getNodeID() is executed at compile 
> time. This is not the case, which you can verify by adding 
> "constexpr" to it:
>
> $ g++ -std=c++14 -Wall -Wextra -c -o example example.cpp
> main.cpp: In function ‘constexpr unsigned int getNodeTypeID()’:
> main.cpp:2:25: error: ‘lastID’ declared ‘static’ in ‘constexpr’ 
> function
>      static unsigned int lastID = 0;
>
> In fact, you're "exploiting" the fact that static variables in 
> C++ can be initialized at runtime (which is probably not what 
> you want).
> The equivalent D code is:
>
> uint newID()
> {
>     static uint lastID;
>
>     return lastID++;
> }
>
> uint getNodeID(T)()
> {
>     static bool inited;
>     static uint id;
>
>     if (!inited)
>     {
>         id = newID();
>         inited = true;
>     }
>
>     return id;
> }
>
> (yes, C++ does insert some hidden bool that tells it whether 
> the variable was initialized or not).
> Naturally, you can't use that for constructing switches or 
> other compile time constructs.

Figured I had a handle on how it worked doing but guess not. One 
final question, however.

I've implemented this test bed with your example to what I think 
is your exact implementation, but it seems to be giving 
unexpected output.

--------------------------------------------------------------------------------
import std.stdio;

uint newID() {
	static uint lastID;

	return lastID;
}

uint getNodeID(T)() {
	static bool inited;
	static uint id;

	if (!inited) {
		id = newID();
		inited = true;
	}
	return id;
}

class Node {}

class Sprite {}

class Camera {}

void main() {
	// Test 01.
	writeln("Test 01.");
	writeln(getNodeID!(Node)(),'\t',getNodeID!(Sprite)(),'\t',getNodeID!(Camera)());
	// Test 02.
	writeln("Test 02.");
	writeln(getNodeID!(Node)(),'\t',getNodeID!(Sprite)(),'\t',getNodeID!(Camera)());
}
--------------------------------------------------------------------------------

Output:
--------------------------------------------------------------------------------
Performing "debug" build using gdc for x86_64.
dlangtest ~master: building configuration "application"...
Running ./dlangtest
Test 01.
0	0	0
Test 02.
0	0	0
--------------------------------------------------------------------------------

Have I misunderstood something?