97
правок
Изменения
м
===Архив===
→Проблема, возникающая при использовании многих библиотек
call f
, где <tex>push</tex> <tex>n</tex> {{---}} команда "положить на стек n". Адрес возврата положится на стек при вызове команды <tex>call</tex>.
Хорошим объяснением того, почему конвенции вызова используют обратный порядок передачи аргументов являются эллипсисы (функции с неопределенным количеством аргументов).
{{TODO|t=пример программы с эллипсисом}}
===Возвращаемое значение===
Возвращаемое функцией значение тоже храниться на стеке, рядом с локальными переменными.
{{TODO|t=дописать}}
{{TODO|t=это мы вроде так для простоты считаем, ссылка на правду}}
===Конвенции вызова===
====Отличия конвенций====
push 1
call g
add esp, 12//смещает вершину стека на 12 байт
====Конфликт конвенций====
По умолчанию в С++ используются конвенции вызова <tex>\_\_cdecl</tex> и <tex>\_\_thiscall</tex>, которая используется для методов класса и отличается тем, что кладет один аргумент в регистр процессора.
}
Так как <tex>g</tex> задана конвенция вызова <tex>\_\_stdcall</tex>, после ее вызова вершина стека не будет сдвигаться. Однако, <tex>f</tex> задана конвенция вызова <tex>\_\_cdecl</tex>, поэтому аргумент не удалится со стека при вызове <tex>ret</tex>, и при следующем запросе адреса возврата будет выдан адрес <tex>239</tex>, скорее всего, не являющийся валидным.
==Размещение локальных переменных==
[[Файл:locals.png|right|thumb|200px|<center>Стек при выполнении функции</center>]]
В функциях для выполнения промежуточных вычислений, временного хранения данных и пр. могут быть использованы локальные переменные. Эти переменные являются временными и создаются при вызове функции, а удаляются при завершении ее выполнения. Для использования локальных переменных необходимо выделить память. В С++ память для всех локальных переменных функции выделяется при начале ее выполнения, и удаляется перед выполнением команды <tex>ret</tex>, чтобы в вершине стека снова оказался адрес возврата.
С помощью функции <tex>\_alloca()</tex> можно увеличить размер стека для размещения локальных данных. Так как объем стека ограничен,при использовании этой функции может возникнуть переполнение стека. Простейший пример кода, который вызовет переполнение:
void f(int size)
{
for (;;)
{
_alloca(size);
}
}
Однако, переполнение может возникнуть и в менее очевидном случае:
void f(int size)
{
_alloca(size);
}
int main()
{
int size = 239;
for(;;)
{
f(size);
}
}
Для упрощения выполнения, компилятор может посчитать, что функция <tex>f</tex> имеет свойство <tex>inline</tex>, и преобразовать код в следующий:
int main()
{
int size = 239;
for(;;)
{
_alloca(size);
}
}
, что, в свою очередь, вызовет переполнение.
==Архив==
{{TODO|t=включить в главу про кучу}}
Динамическая память - это память, получающаяся из свободной памяти при выделении памяти. Слово "динамическая" здесь означает "динамически распределяемая". Динамическая память выделяется и освобождается функциями <tex>VirtualAlloc</tex> и <tex>VirtualFree</tex>. Вызывая <tex>VirtualAlloc</tex>, указывая размер блока памяти и желаемый атрибут доступа (обычно: чтение-запись). Система выделяет от свободной памяти блок. Теперь в программе выделена память, и есть указатель на нее. Когда память надо освободить - вызывайте <tex>VirtualFree</tex>. Система переведёт память обратно в свободную.
Чем плохо такое выделением памяти? Оно выделяет больше памяти, чем нужно, и происходит частое обращение к ядру. Для этого в языке c++ есть особенные функции, для работы с областью памяти - куча "heap".
В стандартной библиотеке, пришедшей из языка C, <tex>libc</tex> реализованы функции <tex>malloc()</tex> и <tex>free()</tex>, соответственно для выделения и освобождения памяти. В самом C++ есть аналогичные функции <tex>new (new[])</tex> и <tex>delete(delete[])</tex>.
Для каждого <tex>malloc/new/new[]</tex> должны вызываться <tex>free/delete/delete[]</tex>, т.к. память сама не освобождается при выходе из функций. Не вызвав эти функции, куча останется неосвобожденнной, и произойдут утечки памяти.
{{TODO|t=запилить картиночки, поправить корявые фразочки}}
Рассмотрим процесс выделения памяти в куче на примере простой программы:
{{TODO|t=Показать в адресном пространстве ран-тайм, библиотеки ядра}}
==Проблема, возникающая при использовании многих библиотек==
{{TODO|t=насколько я помню, это позиционировалось не столько как проблема, больше - просто фича. Поправить}}
{{TODO|t=запилить картиночки, поправить корявые фразочки}}
Для начала рассмотрим пример программы, где используются две библиотеки: пользовательская (<tex>a.dll</tex>) и стандартная (<tex>msvcrt.dll</tex>). В случае, когда библиотека <tex>a.dll</tex> использует для работы с кучей библиотеку <tex>msvcrt.dll</tex>, никаких проблем не возникнет, т.к. при работе программы куча будет одна и функции для работы с ней будут одинаковые, что в пользовательской библиотеке, что в нашей программе.
Теперь рассмотрим другую ситуацию, когда в программе используется всё та же <tex>msvcrt.dll</tex>, но в <tex>a.dll</tex> пусть используется другая стандартна библиотека для работы с кучей: <tex>msvcrtr.dll</tex>.
Здесь может случится неприятная вещь: если мы будем пытаться освободить память из кучи, используя средства пользовательской библиотеки, у нас произойдет ошибка, т.к. кучи для библиотеки и программы будут разные и функция <tex>free</tex> может просто не понять, от куда ей надо освобождать, потому что в библиотеке она использовала <tex>new</tex> из <tex>msvcrtr.dll</tex>, а при вызове <tex>delete</tex> из программы мы обратимся к <tex>msvcrt.dll</tex>.
Согласитесь, не очень приятная ошибка. Для борьбы с ней есть верный способ --- использовать статическое объявление функций из стандартных библиотек: мы "выдёргиваем" только те функции, которые нас интересуют и объявляем их через <tex>static</tex>. У нас будет явное обращение к ним и тогда не произойдет ошибки, возникающей во втором примере.
