in / out for C++ programmers

[Jonathan M Davis]

On Friday, March 23, 2012 23:37:27 Ali Çehreli wrote:
> 'in' is the same as 'const scope'. const part is easy to understand but
> I don't know what 'scope' does. I could not understand what the spec
> means with "references in the parameter cannot be escaped (e.g. assigned
> to a global variable)" for scope:
> 
>    http://dlang.org/function.html

You mean that you don't understand what it means for a reference to escape a 
function? One example of this with pointers would be

int* func()
{
    int a;
    return &a;
}

A pointer to a local variable has escaped the function. That pointer is 
invalid. A case this simple gets caught by the compiler, but it's very easy 
to get around that (e.g. passing &a to a function which returns it and then 
return the result of that function rather than &a directly).

In the case of scope, it means that what you pass in cannot be assigned to a 
global or static variable, and it cannot be returned from that function. So, 
for instance.

int[] foo(const int[] a)
{
    ...
}

could not assign a to a global or static variable and cannot return it. This 
can allow some additional optimizations as well as improve safety in some 
cases. For instance, if you pass

int[5] b;

to foo, then you know that no slice of that static array will escape, since 
something like

int[] bar()
{
    int[5] c;
    return c;
}

is just as bad as the case with &a. I believe that scope is used primarily 
with delegates however (particularly, since you often _want_ to be able to 
return a slice of an array passed to a function). It guarantees that the the 
delegate's context won't escape the function and can make it so that the 
delegate's context doesn't have to be allocated on the heap, which improves 
efficiency.

scope is pointless with types which aren't pointers or references though.

- Jonathan M Davis