Примечание: Этот ответ слишком длинный . Я когда-нибудь его урежу. Между тем, прокомментируйте, если вы можете придумать полезные изменения.

Чтобы ответить на ваши вопросы, нам сначала нужно определить две области памяти, называемые стеком и кучей .

Стек

Представьте себе стопку как стопку коробок. Каждый прямоугольник представляет выполнение функции. В начале, когда вызывается main , на полу стоит один ящик. Все определяемые вами локальные переменные находятся в этом поле.

Простой пример

int main(int argc, char * argv[])
{
    int a = 3;
    int b = 4;
    return a + b;
}

В этом случае у вас есть один ящик на полу с переменными argc (целое число), argv (указатель на массив символов), a (целое число), и b (целое число).

Более одной коробки

int main(int argc, char * argv[])
{
    int a = 3;
    int b = 4;
    return do_stuff(a, b);
}

int do_stuff(int a, int b)
{
    int c = a + b;
    c++;
    return c;
}

Теперь у вас есть коробка на полу (для main ) с argc , argv , a и b . Поверх этого поля у вас есть еще одно поле (для do_stuff ) с a , b и c .

Это Пример иллюстрирует два интересных эффекта.

1. Как вы, вероятно, знаете, a и b передавались по значению. Вот почему есть копия этих переменных в поле для do_stuff .

2. Обратите внимание, что вы этого не делаете. Для этих переменных необходимо бесплатно или удалить или что-нибудь еще. Когда ваша функция возвращается, блок для этой функции уничтожается.

Box overflow

    int main(int argc, char * argv[])
    {
        int a = 3;
        int b = 4;
        return do_stuff(a, b);
    }

    int do_stuff(int a, int b)
    {
        return do_stuff(a, b);
    }

Здесь у вас есть ящик на полу (для main , как и раньше). Затем у вас есть коробка (для do_stuff ) с a и b . Затем у вас есть еще один ящик (для do_stuff , вызывающий сам себя), снова с a и b . А потом еще один. И вскоре у вас есть переполнение стека .

Краткое описание стека

Думайте о стеке как о стопке ящиков. Каждое поле представляет собой выполняющуюся функцию, и это поле содержит локальные переменные, определенные в этой функции. Когда функция возвращается, этот блок уничтожается.

Дополнительная техническая информация

• Каждый «блок» официально называется стековым фреймом .
• Вы когда-нибудь замечали, что ваши переменные имеют "случайные" значения по умолчанию? Когда старый стековый фрейм «уничтожается», он просто перестает быть актуальным. Его не обнуляют или что-то в этом роде. В следующий раз, когда фрейм стека использует этот раздел памяти, вы увидите биты старого фрейма стека в ваших локальных переменных.

Куча

Здесь вступает в игру динамическое распределение памяти.

Представьте себе кучу как бесконечный зеленый луг памяти. Когда вы вызываете malloc или new , в куче выделяется блок памяти. Вам дается указатель для доступа к этому блоку памяти.

int main(int argc, char * argv[])
{
    int * a = new int;
    return *a;
}

Здесь в куче выделяется новое целое число памяти. Вы получаете указатель с именем a , который указывает на эту память.

• a - это локальная переменная, и так оно и есть в «блоке» main

Обоснование динамического распределения памяти

Конечно, использование динамически выделяемой памяти, похоже, тратит туда и сюда несколько байтов на указатели. Однако есть вещи, которые вы просто не можете (легко) сделать без динамического выделения памяти.

Возвращение массива

int main(int argc, char * argv[])
{
    int * intarray = create_array();
    return intarray[0];
}

int * create_array()
{
    int intarray[5];
    intarray[0] = 0;
    return intarray;
}

Что здесь происходит? Вы «возвращаете массив» в create_array . На самом деле вы возвращаете указатель, который просто указывает на часть «блока» create_array , содержащего массив. Что происходит, когда возвращается create_array ? Его ящик уничтожается, и вы можете ожидать, что ваш массив будет поврежден в любой момент.

Вместо этого используйте динамически выделяемую память.

int main(int argc, char * argv[])
{
    int * intarray = create_array();
    int return_value = intarray[0];
    delete[] intarray;
    return return_value;
}

int * create_array()
{
    int * intarray = new int[5];
    intarray[0] = 0;
    return intarray;
}

Поскольку возврат функции не изменяет кучу, ваш драгоценный интаррей уцелел. Не забудьте удалить [] его, когда закончите.