339 lines
13 KiB
Markdown
339 lines
13 KiB
Markdown
# 2.2 Kinds of memory
|
||
Условно в первом приближении при запуске программы ей дают непрервыный кусок памяти по адресам которых она может обращаться.
|
||
|
||
Условно эта память делится на три части - data, text и stack.
|
||
|
||
`data` - область памяти, где хранится все, что определено на всей области программы - то есть, в частности, глобальные переменные.
|
||
|
||
`text` - машинный код вашей программы.
|
||
|
||
`stack` - по дефолту примерно 8 MiB. Область ответственная за уровни вложенности программы, которая "как бы" хранит все в том порядке в котором оно определяется. (Хотя на самом деле компилятор вам не обязан ничего и может переопределять порядок или добавление, видоизменение, игнорирование как хочет)
|
||
|
||
При какой-либо рекурсии мы на стек добавляем не только все плокальные переменные функции, но и указатель на то место, где он был вызыван, иначе
|
||
мы не узнаем куда вернуться.
|
||
Сам стек примерно вмещает 1 миллион запусков пустой "рекурсии".
|
||
|
||
Динамическая память - память выделяемая в процессе выполнения программы
|
||
```C++
|
||
int *p = new int; // выделение памяти на int и получение его адреса
|
||
```
|
||
|
||
`new` -- создает объект данного типа в динамической памяти.
|
||
|
||
> new - это какое-то шаманство, которое пока разобрано не будет.
|
||
> Выполняется в 200-300 раз дольше чем сложение в хорошем случае.
|
||
> А в плохом сколь угодно плохо) ($\geq 10000$)
|
||
|
||
Утечка памяти(memory leak)
|
||
```C++
|
||
void foo() {
|
||
int* p = new int(5);
|
||
...
|
||
// without delete
|
||
return;
|
||
}
|
||
```
|
||
Если не вызвать `delete`, то память останется условно занятой, но провзаимодействовать мы с ней никак не сможем, так как потеряли адреса.
|
||
|
||
В отличие от многих других языков в C++ нет сборщика мусора, поэтому надо убирать за собой.
|
||
|
||
Дважды удалять один и тот же указатель - UB(double free or corruption).
|
||
|
||
Провзаимодействовать с указателем и вызвать `delete` - UB.
|
||
|
||
Вызвать `delete` не от указателя созданного `new` - UB.
|
||
|
||
После `delete p` разыменовать `p` - UB.
|
||
|
||
Статическая память
|
||
```C++
|
||
{
|
||
static int z;
|
||
}
|
||
```
|
||
Теперь `z` лежит в вышеупомянутой `data`, ей предвыделило чуть больше памяти на этапе компиляции, специально для `z` и оно будет храниться там на протяжении всей программы (но доступно только из своей области видимости).
|
||
|
||
**Важно**. Ключевое слово `static` имеет разный смысл для переменных внутри функций и глобальных переменных.
|
||
Для глобальных переменных `static` влияет на линковку(internal linkage, что бы это ни значило), противоположность
|
||
ключевому слову `extern`.
|
||
|
||
Ниже приведены примеры переполнения стека(из-за рекурсии)
|
||
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int f(int x) {
|
||
std::cout << '\n';
|
||
++x;
|
||
f(x);
|
||
}
|
||
|
||
int main() {
|
||
f(0);
|
||
}
|
||
// переполнение стека
|
||
```
|
||
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int f() {
|
||
static int x = 0;
|
||
std::cout << '\n';
|
||
++x;
|
||
f();
|
||
}
|
||
|
||
int main() {
|
||
f();
|
||
}
|
||
// переполнение стека, but cooler
|
||
```
|
||
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int f() {
|
||
int *p = new int(5);
|
||
std::cout << p << ' ' << *p << std::endl;
|
||
delete (++p);
|
||
f();
|
||
}
|
||
|
||
int main() {
|
||
f(0);
|
||
}
|
||
// переполнение стека
|
||
```
|
||
|
||
# 2.3 Arrays
|
||
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int main() {
|
||
int a[10];
|
||
int b[5] = {1, 2, 3, 4, 5};
|
||
int c[5]{};
|
||
std::cout << *(a + 3) << '\n'; // 4
|
||
int *p = a + 3;
|
||
// p[i] == *(p + i), причем i[p] == p[i], потому что в терминах указателей это буквально i + p == p + i
|
||
std::cout << p[-2] << '\n'; // 2
|
||
}
|
||
```
|
||
|
||
`int*` и `int[]` взаимозаменяемы, поэтому следующий код вызовет ошибку компиляции
|
||
|
||
```C++
|
||
#include <iostream>
|
||
|
||
void f(int a[5]) {
|
||
;
|
||
}
|
||
|
||
void f(int* p) {
|
||
;
|
||
}
|
||
|
||
int main() {
|
||
int a[5] = {1, 2, 3, 4, 5};
|
||
int* b[5]; // массив из 5 указателей на int*, а не указатель на массив из 5 int
|
||
}
|
||
```
|
||
|
||
Массив можно выделить в динамической памяти (который на самом деле указатель на начало)
|
||
с помощью конструкции `new T[]`.
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int main() {
|
||
int *p = new int[100];
|
||
|
||
delete[] p;
|
||
}
|
||
```
|
||
Если пытаться сделать `delete[]` от обычного указателя или наоборот - это runtime error
|
||
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int main() {
|
||
std::vector<int> v(10);
|
||
v[-1] = 10000; // надругательство
|
||
return 0;
|
||
delete[] &v[0]; // надругательство
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int main() {
|
||
// Variable lenght array (VLA)
|
||
int n = 100;
|
||
std::cin >> n;
|
||
int a[n]; // с cin нельзя, с n = 100 - можно
|
||
}
|
||
```
|
||
Убрана обратная совместимость с C, чтобы не сдвигать переменные на стеке на какое-то неопредленное число, которое мы узнаем только в
|
||
рантайме. Но большинство компиляторов таки поддерживают VLA.
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int main() {
|
||
const char* s = "abcdef"; // сам строковый литерал всегда хранится в статической памяти, сам указатель на него - на стеке
|
||
std::cout << (int)(s[4]) << '\n';
|
||
}
|
||
```
|
||
|
||
**Идентификатор `const`**.
|
||
|
||
Запись `const char *` значит, что мы вправе менять указатель, но не вправе менять то, что лежит под ним.
|
||
|
||
[Здесь][rt-lt] подробно описано, как читать такие объявления.
|
||
|
||
**Null-terminated strings**. В языке Си есть конвенция отождествлять строку с последовательностью байт, которая заканчивается на `0`
|
||
(для записи NUL символа можно использовать литерал `'\0'`).
|
||
|
||
Если нам дан указатель на начало, легко, например узнать длину строки, или скопировать одну в другую
|
||
|
||
```C
|
||
size_t
|
||
my_strlen(const char *s)
|
||
{
|
||
size_t len = 0;
|
||
while (*s++) {
|
||
len++;
|
||
}
|
||
// если гарантируется, что s заканчивается нулевым байтом, то
|
||
// мы никогда не выйдем за границы выделенной памяти, то есть данный код корректный
|
||
return len;
|
||
}
|
||
|
||
void
|
||
my_strcpy(char *dst, const char *src)
|
||
{
|
||
while ((*dst++ = *src++));
|
||
// Для того, чтобы не было UB, нужно, чтобы dst, src
|
||
// заканчивались нулем и в dst было достаточно места
|
||
}
|
||
```
|
||
|
||
```C++
|
||
#include <iostream>
|
||
#include <cstring>
|
||
|
||
int main() {
|
||
const char* s = "abc\0def"; // сам строковый литерал всегда хранится в статической памяти, сам указатель на него - на стеке
|
||
std::cout << strlen(s) << ' ' << s << '\n'; // выведет '3 abc', потому что из-за поддержки C-style string все пытается прыгать вокруг присутствия /0 ровно в конце строки
|
||
}
|
||
```
|
||
|
||
Под каждым `std::string` лежит C-style null-terminated строка, указатель на начало которой
|
||
получить вызвав метод `.c_str()`.
|
||
|
||
# 2.4 Functions and pointers to functions
|
||
|
||
Указатель на функцию это "указатель на код", его также можно передавать в другие функции.
|
||
Объявляется он как `return-type (*name)(arguments)`.
|
||
|
||
Опять же, по [этой ссылке][rt-lt] можно найти гайд по чтению этих записей.
|
||
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int sqr(int x) {
|
||
return x * x;
|
||
}
|
||
|
||
int f(int x);
|
||
|
||
void sort(int *begin, int *end, bool(*cmp)(int, int));
|
||
|
||
int main() {
|
||
int x = 0;
|
||
std::cout << &x << '\n';
|
||
int(*p)(int) &sqr; // синтаксически корректное определние ссылки на функцию
|
||
|
||
std::cout << (void*)&sqr; // адрес sqr в памяти
|
||
|
||
int (*q)(int) = &f; // нельзя, так как функция не определена
|
||
|
||
}
|
||
```
|
||
|
||
Вызов функции по указателю медленнее, чем ее вызов напрямую, поэтому лучше
|
||
избегать их если можно(например, с помощью шаблонов).
|
||
|
||
```C++
|
||
#include <iostream>
|
||
|
||
int sqr(int x) {
|
||
return x * x;
|
||
}
|
||
|
||
double sqr(double x) {
|
||
return x * x;
|
||
}
|
||
|
||
int main() {
|
||
int (*p)(int) = sqr;
|
||
double (*pp)(double) = sqr;
|
||
|
||
double (*ppp)(double) = (double(*)(double))(p);
|
||
|
||
std::cout << (void*)p << ' ' << (void*)pp << '\n'; // выведет 2 разных адреса, потому что оно взяло разные функции
|
||
}
|
||
```
|
||
|
||
Существуют также variadic функции. Ниже адаптирован пример
|
||
[отсюда](https://www.gnu.org/software/libc/manual/html_node/Variadic-Example.html)
|
||
|
||
**TL;DR** Не пишите C-style variadic функции в C++. Будьте ОЧЕНЬ аккуратны при использовании variadic функций в C/C++.
|
||
|
||
```C
|
||
// C-style variadic function
|
||
|
||
int
|
||
variadic_sum(size_t count, ...)
|
||
{
|
||
va_list ap;
|
||
size_t i;
|
||
int sum;
|
||
|
||
va_start(ap, count);
|
||
|
||
sum = 0;
|
||
for (i = 0; i < count; ++i) {
|
||
sum += va_arg(ap, int); // макрос принимает va_list и тип аргумента, который мы ждём
|
||
}
|
||
|
||
va_end(ap); // может не делать ничего, но по стандарту нужно
|
||
|
||
return sum;
|
||
}
|
||
```
|
||
|
||
Данный код очень небезопасен по многим причинам. Первый аргумент `count` лежит на стеке, поэтому компилятор знает, как его достать. А
|
||
дальше могут лежать аргументы произвольных типов, которые могут занимать разное количество памяти.
|
||
|
||
Как тогда вытащить их со стека? `ap`
|
||
указывает на текущую позицию(сокращение от `argument pointer`), а `va_arg` приводит `ap` к типу, в нашем случае `int`, и прибавляет
|
||
количество байт, которое этот тип занимает.
|
||
|
||
Можно подумать, что в `va_start` мы передаем количество аргументов, но это неправда. `va_start` это **макрос**, а не функция, поэтому у
|
||
него есть немного контекста, например, адрес переменной `count`.
|
||
Он берет указатель на `count` и прибавляет к нему число байт, которое `count` занимает, чтобы указать на первый
|
||
variadic аргумент.
|
||
|
||
Тем самым, вторым аргументом в `va_start` нужно указать **последний не variadic аргумент функции**.
|
||
|
||
Одна из самых известных variadic функций с которой вы наверняка сталкивались, это `printf`.
|
||
Если передать в `printf` недостаточное число аргументов, слишком много аргументов, или тип аргумента
|
||
не совпадет со спецификатором(например, вы передали `char*` в `%d`), то **произойдет UB** как раз из
|
||
механизма работы `va`. Например, оно может брать аргументы выше по стеку, поэтому **никогда не передавайте
|
||
в `printf` недоверенный спецификатор формата, например, `prinf(username);` из соображений безопасности**.
|
||
|
||
[rt-lt]: https://cseweb.ucsd.edu/~gbournou/CSE131/rt_lt.rule.html
|