In D we a several data types which are passed by reference:
dynamic arrays, associative arrays. And sometimes we need to pass
these reference data to class instance to store it inside. One of
the principles of object-oriented programming is incapsulation.
So all class data should be only modyfiable via class methods and
properties. But I we pass reference data to class (for example as
parameter in constructor) we still can change these data from
initial code and break some internal logic of class for modifying
these data. Example:
class Foo {
this(int[] b) { bar = b; }
private int[] bar;
//Some methods
}
void main() {
int[] bar = [1,2,3,4,5];
Foo foo = new Foo(bar);
//There I could do some logic with class
bar[2] = 6; //I modify class without some checks from class
//And there I might pass *bar* somewhere outside and break
incapsulation
}
Same situation happens when I assign reference data to
properties. I can check or do something with data at the moment
of assignment, but I can't control that someone will modify using
initial reference from outside. So do you copy reference data in
constructors or properties? Should it be? Or call site should be
responsible for not escaping reference somewhere outside and not
modifying these data badly?
There also possible some situations when these data should be
shared between different pieces of code (for example different
class instance could reference the same memory area). But I think
this is not very good and safe approach and should be avoided if
possible.
But I think storing reference to class inside another class could
be good approach because there could be different type of
relations between classes. For plain data types we often have
types of relations: *ownership* or *aggregation*. But classes can
usualy have more types of relations: *usage* or when one class
subscribes for events of another.
Is there some good links to read for these questions that you
could advice. After several hours of googling I haven't found
good topics about these problems. And I have not enough time for
reading big book.
