Why function's return statement is not usual int[ ] - d

Question

I have just started to use Dlang and it seems to be ideal for people who want a safer C language. In addition it has modern paradigms also like functional programming.
I am trying following code to convert a list of numbers as strings to list of integers:
import std.stdio;
import std.array;
import std.conv;
int[] list_str2int(char[][] slist){ // this function should convert a list of numbers as char[] to integers
int[100] intcol;
int N = cast(int)slist.length;
foreach(int i; 0..N){
char[] temp = slist[i];
temp = split(temp, ".")[0]; // effectively this is floor; to!int does not work if '.' is there;
intcol[i] = to!int(temp); // not working;
}
return intcol; // error from this statement;
}
void main(){
char[][] strlist = cast(char[][])["1.1","2.1","3.2","4.4"];
int[] newintlist = list_str2int(strlist);
writeln("Converted list: ", newintlist);
}
But getting following error:
testing.d(13): Error: returning cast(int[])intcol escapes a reference to local variable intcol
Failed: ["/usr/bin/dmd", "-v", "-o-", "testing.d", "-I."]
I cannot understand why there is error on return line of the first function where the variable is int[].
Where is the problem and how can it be solved? Thanks for your help.

Answer 1

int[100] is a static array (a value type), and is located on list_str2int's stack frame - therefore it will cease to exist once the function returns. The function's return value, int[], is a slice (a reference type), which does not hold any data, but refers to a contiguous number of integers somewhere in memory. The statement return intcol; thus takes a slice of the static array, however, returning it is invalid because the slice would point to memory that would no longer be valid after the function returns.
You have a few options:
Declare the return type as int[100] also. Making it a value type, the integers will be copied to the caller's stack frame.
Allocate the array in the program's heap by declaring and initializing the array as auto intcol = new int[100];. This will make intcol a slice of memory in the heap. Memory in the heap is owned by the garbage collector, and has effectively infinite lifetime.
An option that's further from the above but more idiomatic to modern D is to use ranges. Your program could be rewritten to a single statement as follows:
import std.algorithm.iteration;
import std.stdio;
import std.array;
import std.conv;
void main()
{
["1.1", "2.1", "3.2", "4.4"]
.map!(item => item
.split(".")[0]
.to!int
)
.array // optional, writeln and co can write ranges
.writefln!"Converted list: %s";
}

Answer 2

int[] is a slice, it can use dynamic allocation.
The int[100] is an array of 100 elements. It is allocated on the stack
Just like in C, you can't return local memory from a function, you can't return intcol, as the memory behind it becomes invalid after the function returns.
It seems unknown to me, if you want to use dynamic arrays or static. If you want to use dynamic arrays, then stick to them.
import std.stdio;
import std.array;
import std.conv;
int[] list_str2int(char[][] slist){ // this function should convert a list of numbers as char[] to integers
int N = cast(int)slist.length;
int[] intcol = new int[N];
foreach(int i; 0..N){
char[] temp = slist[i];
temp = split(temp, ".")[0]; // effectively this is floor; to!int does not work if '.' is there;
intcol[i] = to!int(temp); // not working;
}
return intcol; // error from this statement;
}
void main(){
char[][] strlist = cast(char[][])["1.1","2.1","3.2","4.4"];
int[] newintlist = list_str2int(strlist);
writeln("Converted list: ", newintlist);
}
will output:
Converted list: [1, 2, 3, 4]