several questions

[Saaa]

Thanks!
Still bit uncertain about the static array though :)
But I think I understand static now, although I never use 'this' making it a 
bit more difficult to understand :)
If I say something like 'static int i=0;' within the main I can't use i for 
anything else in the whole program afterwards.
It makes variables into global variables :)
What exactly is 'having a this reference' ?
And what does final mean. (the attributes page doesn't say anything about it 
:/ )
Private is easy to understand, thanks.

> From the D1 documentation:
> For dynamic array and object parameters, which are passed by reference,
> in/out/ref apply only to the reference and not the contents.
>
> What exactly (internally memory wise) does 'passing' mean. Is it like
> copying?

It means that when used as a parameter to a function, a reference type
will just send (copy, if you will) a pointer to itself to the function,
while a value type will copy all its data. 'Least I think that should be
fairly correct.

> And does this mean that static arrays are not passed by reference and 
> should
> I use:
> void func(ref array.ptr)
> ,because otherwise the whole array is passed (copied) ? (which sound 
> slow:)

I seriously doubt ut does. Not having checked, I won't say that with 100%
certainty, though.

> Another question :)
>
> What is the advantage of making a function/variable static?
> It makes it nonvirtual, right. Why is this good?
> When should I make something static or final?

A static function or variable becomes a member of the class/struct
definition, instead of of the instance. Say you have

class Foo
{
static int bar_static; // Shared by all instances of Foo, so if one of
them changes the value, it's changed for all.
int bar; // New int specific to each instance. Change this value, and no
other instance will notice.
static void doStuff(){} // Function with no 'this' pointer. Can be called
using Foo.doStuff(), with no instance of Foo anywhere in your program. Can
change only static members of Foo.
void doStuff(){} // Function with 'this' pointer. Needs an instance on
which to work. Can change static members of Foo, as well as normal members.
}

> A private function/var can't used by anything in a 'lower' scope, right?

Private in D means 'not accessible outside this module.' So this is
perfectly legal:

class Foo
{
private int foo;
}

class Bar : Foo
{
void bar()
{
foo = 3;
}
}

void doStuff()
{
Foo f = new Foo();
f.foo = 4;
}

You can however not change foo from inside a different source file
(module).

> Well thats it for now =D