# Lesson 8: Strings and Dynamic Arrays

In this chapter, you will learn about strings in depth. In the meantime, you will also learn about another type: the dynamic array.

## Introductory Code

### Dynamic Arrays

```import std.stdio;

void main()
{
int[] a = [1,2,3,4];
int[] b = [5,6];
auto c = a ~ b;
writeln(c); // [1,2,3,4,5,6]

writeln(c.length);  // 6

int* ptr_c = c.ptr;
ptr_c[0] = 3;
writeln(c); // [3,2,3,4,5,6]
}
```

### Immutable and Strings

```import std.stdio;

void main()
{
// Concept:  Immutable
immutable(int) a = 10;
// a = 11;  Error:  cannot modify immutable
immutable a = 10;

// Concept:  Strings as Arrays
immutable(char)[] str = "Hello";
auto str1 = str ~ "1";
writeln(str1); // Hello1
writeln(str1.length);  // 6
// str1[] = 'z'; error! str1's elements are not mutable
char[] mutablestr1 = str1.dup;

// Concept: Char Literals
mutablestr1[] = 'z';  // 'z' is not a string, but a char

str1 = mutablestr1.idup;  // The str1 itself is mutable
// only its elements are not mutable
writeln(str1);  // zzzzzz
}
```

## Concepts

### Dynamic Arrays

#### Dynamic Arrays versus Static Arrays

In the previous lesson, you learned about static arrays. Dynamic arrays are different from those in that they do not have a fixed length. Essentially, a dynamic array is a structure with this info:

1. A pointer to the first element
2. The length of the entire array

You create a dynamic array like this:

```int[] a;
```

You can create a dynamic array initiated with a specific length:

```int[] a = new int[](5);
```

You will learn more about the `new` keyword later.
The syntax for filling an array with a single value is the same for both static and dynamic arrays:

```int[] a = [1,2,3];
a[] = 3;
writeln(a); // [3, 3, 3]
```

Dynamic arrays are indexed in the same fashion as static arrays. The syntax for accessing an element at a certain index is the same:

```a[2];
```

However, since dynamic arrays don't have a length known at compile-time, the compiler can't check if the index that you are accessing is really within that length. Code like this would compile but would also cause a runtime Range Violation error:

```int[] a = [1,2,3];
writeln(a[100]);  //Runtime error, Range violation
```

#### Manipulation of Dynamic Arrays

Dynamic arrays can be combined with other dynamic arrays or even with static arrays using the `~` operator. Appending a new element to the array uses the same operator.

```int[] a = [1,2];
auto b = a ~ [3,4];
writeln(b);  //[1, 2, 3, 4]
b ~= 5;  // same as b = b ~ 5;
writeln(b);  //[1, 2, 3, 4, 5]
```

You shouldn't assign a dynamic array to a static array (`my_static_arr = my_dynamic_arr;`) unless if you are certain that `my_dynamic_arr.length` is the equal to `my_static_arr.length`. Otherwise, a runtime error will occur. You can always assign a static array to a dynamic array variable, though, since the dynamic array will automatically resize if the static array's length is too big.

```int[] a = [9,9,9,9,9,9];
int[3] b = [1,2,3];
int[200] c;
a = b;
writeln(a);  // [1, 2, 3]
a = c;
writeln(a.length); // 200

int[] d = [5,4,3];
b = d;  // OK: lengths are both 3
// c = d;  runtime error! lengths don't match.
```

#### Passing Dynamic Arrays to Functions

Dynamic Arrays are passed by value to functions. That means, when you pass a dynamic array to a function, the structure that contains the pointer to the first element and the length is copied and passed.

```void tryToChangeLength(int[] arr)
{
arr.length = 100;
}
void main()
{
int[] a = [1,2];
tryToChangeLength(a);
writeln(a.length);  // still 2
}
```

You learned in the last chapter that you can cause things to be passed by reference instead of by value by adding the `ref` modifier.

#### Array and Other Properties

These properties apply to both static and dynamic arrays:

Property Description
.init For static arrays, it returns an array with each element initialized to its default value.
.sizeof Returns the size of the array in memory.
.length Returns the number of elements in the array. This is fixed in static arrays.
.ptr Returns a pointer to the first element of the array.
.dup Creates a dynamic array that is a copy of the array and returns it.
.idup Similar to `.dup` but the copy's elements are `immutable`.
.reverse Returns the array with its elements in reverse order.
.sort Sorts in place the elements in the array and returns the result.

There are also other properties which are common to every object or expression. Two of such properties are the `.init` and `.sizeof` properties.

### Immutable

In D, `immutable` is a storage-class just like `auto`. It converts a type to a non-modifiable type.

```immutable(int) fixed_value = 37;
immutable int another_value = 46;
```

Note that `immutable(type)` means the same as `immutable type` to the compiler.

#### Storage-Classes and `auto`

When you have a storage class like `immutable`, you can omit `auto` for type inference.

```immutable fixed_value = 55;
```

The type of whatever is immutable is inferred from the compiler. This next code example is not valid because there is no way the compiler could infer the type:

```immutable fixed_value;  //Error!
```

#### Using `immutable` Variables

This is allowed and perfectly fine code:

```immutable(int) a = 300;
int b = a;
```

It only sets `b` equal to the value of `a`. `b` does not have to be `immutable`. That changes if you are taking a reference:

```immutable(int) a = 13;
immutable(int)* b = &a;
// int* c = &a;  Error.
```

You are allowed to cast the `immutable` away, but if you were to modify an immutable value using that hack, the result is undefined.

```immutable(int) a = 7;
int* b = cast(int*)&a;
// Just make sure you do not modify a
// through b, or else!
```

### Strings as Arrays

You've seen strings since Lesson 1. A `string` is the exact same thing as `immutable(char)[]`, a dynamic array of immutable char elements. Likewise, a `wstring` is the same as `immutable(wchar)[]`, and a `dstring` is the same as `immutable(dchar)[]`.

#### String Properties

Strings have the same built-in properties as dynamic arrays. One useful property is the `.dup` property, for creating a mutable `char[]` copy of a string if you want to modify the individual characters of the string.

```string a = "phobos";
char[] b = a.dup;
b[1] = 'r';
b[4] = 'e';
writeln(b);  // probes
```

The `.idup` property is useful for creating a copy of an existing string, or for creating a string copy of a `char[]`.

```string a = "phobos";
string copy_a = a.idup;
char[] mutable_a = copy_a.dup;
mutable_a[3] = 't';
copy_a = mutable_a.idup;
writeln(mutable_a); // photos
writeln(a); // phobos
```

#### Char Literals

A `char` literal is enclosed by single-quotes. There are also `wchar` and `dchar` literals.

```auto a = "a"; // string
auto b = 'b'; // char
auto c = 'c'c; // char
auto d = 'd'w; // wchar
auto e = 'e'd; // dchar
```