> For the complete documentation index, see [llms.txt](https://learncpp.benntan.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://learncpp.benntan.com/memory-and-ownership/arrays-and-strings.md).
# Arrays & Strings
Thus far, pointers pointed to a singular variable. But what if we have multiple values stored together (exactly, like an array!)
### Arrays
To declare an array:
{% code title="" %}
```cpp
int arr[3] = {10, 20, 30}; // array
int* p_arr = arr; // pointer to array
```
{% endcode %}
Visually, this is how an array is represented:
Note that:
* All 3 elements sit **side-by-side** (i.e there exists no gaps between them). This is what we mean by **contiguous memory.**
* You may also have noticed that the difference between each memory address is 4 bytes. This because (usually) `int` occupies 4 bytes.
### Pointer Arithmetic
Since `p_arr` stores the address of the first element, you can access `arr[0]` via dereferencing `*p_arr`.
What about `arr[1]`? The cool thing about pointer arithmetic is that it's **type-aware,** you can simply perform `(p_arr + 1)` to move forward by 1 element of type `int` (i.e 4 bytes).
Functionally,
Operation
Result
*p_arr
Move p_arr by 0 bytes, dereference to get arr[0]
*(p_arr + 1)
Move p_arr by 4 bytes, dereference to get arr[1]
*(p_arr + 2)
Move p_arr by 8 bytes, dereference to get arr[2]
Note that `arr` also decays into a pointer to the first element that shares the same memory address as `p_arr`, hence operations that can be done with `arr` can also be done with `p_arr`
{% code title="main.cp" %}
```cpp
#include
int main() {
int arr[3] = {10, 20, 30};
std::cout << arr[0] << std::endl; // 10
std::cout << arr[1] << std::endl; // 20
std::cout << arr[2] << std::endl; // 30
std::cout << *(arr + 0) << std::endl; // 10
std::cout << *(arr + 1) << std::endl; // 20
std::cout << *(arr + 2) << std::endl; // 30
int* p_arr = arr;
std::cout << *(p_arr + 0) << std::endl; // 10
std::cout << *(p_arr + 1) << std::endl; // 20
std::cout << *(p_arr + 2) << std::endl; // 30
}
```
{% endcode %}
😎 Cool Fun Fact
We've learnt that we can access `arr[0]` via `*(arr + 0)`. Since addition is commutative, `*(arr + 0) == *(0 + arr)`, hence `0[arr]` works too!
{% code title="main.cpp" %}
```cpp
#include
int main()
{
int arr[3] = {10, 20, 30};
std::cout << 1 [arr] << std::endl;
std::cout << arr[1] << std::endl;
}
```
{% endcode %}
### Strings
Fundamentally, a string is simply an *array* of characters ending with a special character `\0` (i.e null terminator)
The usual pointer arithmetic rules that we've learnt above apply too.
{% code title="main.cpp" %}
```cpp
#include
int main() {
char str[] = "hello";
std::cout << str[0] << std::endl; // 'h'
std::cout << *(str + 1) << std::endl; // 'e'
char* str2 = "world";
std::cout << str2[0] << std::endl; // 'w'
std::cout << *(str2 + 1) << std::endl; // 'o'
}
```
{% endcode %}
Notice when we compile, we get a warning:
😕 Why the warning for char* str2 but not char str[] ?
`"hello"` is a string literal stored in read-only memory.
`char[]` has no issues since it copies the string literal onto its own array on the stack.
`char *` is pointing to the same string literal in read-only memory. Writing to it causes undefined behaviour hence the warning.
In fact, if you try compiling the program with stricter flags: `clang++ -std=c++17 -Wall -Wextra -pedantic-errors main.cpp -o hello-world`, the compiler rejects the code entirely.
To squash this, we can use `const char *` to assert that we are not going to modify the string.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://learncpp.benntan.com/memory-and-ownership/arrays-and-strings.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
