Презентация на тему Динамические структуры данных

начала работы программы под глобальные переменные (до main()) или

статические переменные (static) и освобождается только при завершении программы. Cтатическая память инициализируется случайными значениями. Поскольку область статической памяти выделяется заранее (в момент начала работы программы), она имеет фиксированный размер, что не всегда удобно и оправдано (например, массивы фиксированной длины).

Динамическая память (куча- Heap), выделяется явно по запросу программы из ресурсов операционной системы и контролируется указателем. По окончании работы программы, вся затребованная программой динамическая память возвращается ОС.

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

связана с некоторым указателем, подходящего типа

int* p; p = new

int; *p = 10; cout << *p; // 10 delete p; // память освобождена

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

При создании одной динамической переменной можно сразу инициализировать её значение:

int* p; p = new int(10); cout << *p; // 10 delete p; // память освобождена

Динамической переменной называется переменная, память для которой выделяется во время работы программы с помощью оператора New.

памяти происходит с помощью оператора new , который выделяет

новую ячейку памяти для переменной, и возвращает указатель на нее:

7

7

1.

2.

3.

4.

5.

6.

динамической памяти, получая динамический массив. Для этого его размер

указывается в квадратных скобках после типа int [n]. Чтобы удалить динамический массив и освободить память используется оператор delete[].
int* p; p = new int [12]; for (int i=0; i<12; i++) {   *(p+i) = i + 1;     cout << *(p+i) << ' '; // 1 2 3 ... 12 } delete [] p; // память освобождена

Cразу после создания динамический массив автоматически заполняется нулями.

10 элементов
float **ptrarray = new float* [2];  // две строки в

массиве
    for (int count = 0; count < 2; count++)
        ptrarray[count] = new float [5];  // и пять столбцов

float **ptrarray - указатель второго  порядка , который ссылается на массив указателей  float* [2]

// освобождение памяти, отводимой под двумерный дин. массив
     for (int count = 0; count < 2; count++)
         delete [] ptrarray[count];
//      где 2 – количество строк в массиве

Объявление и удаление двумерного динамического массива выполняется с помощью цикла.

фрагмента динамической памяти, записать новый адрес, то фрагмент динамической

памяти будет потерян
int* p; p = new int(12); int a = 777; p = &a; // теперь до 12 никак не добраться

Проблема становится особенно острой, когда в памяти теряются целые массивы (они занимают больше места, чем отдельные переменные).
int* p; for (int i=1; i<=10; i++) {     p = new int[100]; } delete[] p;
Всего массивов будет создано 10, но только от последнего из них память будет освобождена после выхода из цикла.
9 массивов * 100 элементов * 4 байта = 3600 байт потерянной памяти,

Важно вовремя освобождать занятую память!

управление памятью, чем с помощью New и Delete, которые

работают с блоками памяти, соответствующими типам указателей.

размера: 

void * malloc(int size); // выделить область памяти размером
                    // в

size байтов и возвратить адрес

#include
int *intarray; /* захватываем пространство для 20 целых */ intarray = (int*) malloc(20*sizeof(int));

Функция malloc() возвращает указатель без типа.
Если выделить память не удалось, функция возвращает значение NULL.

блоков:
void * calloc(int n, int size); // n - количество блоков

// size – размер каждого блока в байтах

#include
lalloc = (long*) calloc(40, sizeof(long));

Возвращает указатель на первый байт выделенной области памяти.
Если выделить память не удалось, функция возвращает значение NULL.

realloc( void* ptr, int size);
// ptr – указатель на первоначальную

область памяти
// size – новый размер области памяти.

#include
har *realloc(ptr,size);

*ptr); //ptr - указатель на захваченный блок памяти

char

*alloc; /* захватывает 100 байтов и освобождает их */ if ((alloc=malloc(100))==NULL /* проверяет на правильность указателя */ printf("unable to allocate memory\n"); else { . . free(alloc); /* освобождает память для heap */ }

контролируются.
С их помощью можно работать с обычными переменными

и их массивами, но никак не с объектами.

Операции new/delete используют собственную систему контроля данных в динамической памяти, поэтому при работе с объектами необходимо использовать исключительно их.

Отсюда рекомендации:
   не применять для динамической переменной или динамического массива одновременно функции и операции управления динамической памятью;
   при работе с объектами использовать только операции  new/delete;
   при освобождении памяти из-под динамического массива «подсказывать» транслятору, что указатель ссылается именно на массив, записывая перед указателем пустые скобки: delete [] pd1.

*p1, char *p2){                 
char  *out; int   n1,n2;
for (n1=0; p1[n1]!='\0'; n1++);            // длина первой строки
for

(n2=0; p2[n2]!='\0'; n2++);            // длина второй строки
if ((out = new char [n1+n2+1]) == NULL)
      return NULL;                             // выделить память под результат
for (n1=0; *p1!='\0';)  out[n1++] = *p1++;
while(*p2!=0) out[n1++] = *p2++;      // копировать строки
out[n1] = '\0';
return out;
}