#include<stdio.h>
#include<stdlib.h>
#define BUF_SIZE 1024 // определяем структуру которая называется block. имеет указатель next на струтуру такого же типа
typedef struct block{
int size;
struct block* next;
}block;
//насколько я помню тип чар весит один байт. следовательно тут мы создаем массив из чаров.
//т.е каждая ячейка будет весит 1 байт
//BUF_SIZE задефайнен на 1024. тобишь мы определили массив в 1024 байт.
char memory[BUF_SIZE];
// функция выделения памяти ну собсна маллок
void* mymalloc(int size){
//создадим некий указатель p типа нашей структуры
block* p;
// и еще два: last и tmp. это для того, чтобы бегать по памяти как надо)
block *last = NULL, *tmp = NULL;
// зададим флаг. обрати внимание что он static а значит что 1 присвоится при первой
// инициализации. говоря русским языком сколько бы раз не вызывала
// эту функцию а эта строчка сработает лишь один раз. (если не ясно открывай книгу и читай)
static int flag = 1;
// итак проверим если флаг тру значит мы впервые вызвали функцию.
//создаём первый блок
if(flag){
// это типа начало нашей памяти
p = (block*)memory;
// говорим, что он пустой
p->size = 0;
//говорим что следующий это прямо твой сосед впритык к тебе стоит)
p->next = p+1;
//переходим к соседу
p = p+1;
// соседу говорим что ты большой и свободный. и размер твой- эта вся память минус размер твоей структуры и размера структуры соседа что там сзади остался...
p->size = BUF_SIZE-2*sizeof(block);
// говорим что впереди тебя никого нет
p->next = NULL;
// и опускаем флаг типа все созданно и готово к работе.
flag = 0;
}
//проверка размера. случай когда нас попросили замолочить <=0 память. тогда вылетаем.
if(size <= 0) return NULL;
//пробегаемся по массиву
//это magic цикл.
/*
last = p = (block*)memory двойное присваивание. тобишь last=p.
где р изначально будет указывать на первый блок, тот который пустой
*//*
бежим до тех пор пока последующий блок существует <И> размер текущего меньше нужного размера
*/
for(last = p = (block*)memory; p->next != NULL && p->size < size; last = p, p = p->next);
//системная печать закоменчена
//printf("%d----%d\n", p->size, size+sizeof(block));
// если размер текущего больше суммы нужного размера и размера блока тогда
if(p->size > size + sizeof(block)){
//printf("1\n");
//вычитаем из размера текущего свобоного размер суммы нужного и структуры
p->size -= (size + sizeof(block));
//tmp указатель на тип структуры находящейся по адресу относительно адреса найденного свободного блока
//плюс размера самой структуры плюс оставшеся свобоной памяти от найденного блока.
//тут лучше нарисуй картинку и сразу поймешь. tmp это тупо стрелочка которую нужно вернуть чтобы в дальнейшем мы могли обратится к этому выделенному уже участку памяти
tmp = (block*)((char*)p + sizeof(block) + p->size);
// нашему выделенному учатску памяти задали его размер
tmp->size = size;
//сказали что после него никого нет. да это и не надо впринципе
tmp->next = NULL;
//ну и вернули юзеру указатель на его участок. пусть творит с ним че хочет.терь он в рабстве юзера.
return (void*)(tmp + 1);
}else if(p->size == size){
//а это случай когда все очень круто совпало!
//printf("2\n");
//в этом случае мы должны полностью. выделить свободный блок и отдать его юзеру.
// но есть проблемка. ведь перед ним запросто могут быть свободные блоки которые ссылаюстся на него, да и после него тоже есть на которые он ссылается (это определнно нашим циклом)
// поэтмоу мы выделяем сие блок
tmp = (block*)((char*)p + sizeof(block));
// и говорим что следующий блок у предыдущего блока, будет последующий блок того что мы выделили.
// на рисунке у себя нарисуй стрелочку от предыдущего к последующему относительно текущего
last->next = p->next;
// теперь связь есть. и нам нужно убрать ссылку на следующий иначе хня получится
p->next = NULL;
// возвращаем его юзеру
return (void*)tmp;
}else{
// ну остается третий случай когда жопа. говорим об этом юзеру. мол много хочешь - ничерта не получишь =)
//printf("3\n");
printf("Not memory\n");
return NULL;
}
}
void myfree(void* ptr) {
// ну также создаем предыдущий текущий и тот который мы будем освобождать из рабства Юзера!
block *last, *nex, *p;
// говорим что текущий есть то место, по какому адресу нас прислали но незабываем про структурку поэтому вычтем из адреса и получим черную дверь для редактирования блока =)
// может мне детективы писать? 0_о или фэнтэзи)
p = (block*)((char*)ptr - sizeof(block));
//говорим что стартовый блок это самый первый системный тобишь блок нашей всей памяти
block* start = (block*)memory;
//и начинаем еще один magic цикл
//итак в нем говорится: крутится от начального до тех пор пока текущий блок существует
//и адрес текуущего меньше чем наш адрес!!!
// при этом тащим за собой предыдущий блок от текущего =))) зачем? увидишь) напарник в долгих походах всегда нужен)
for(last = nex = start; nex != NULL && p > nex; last = nex, nex = nex->next);
//заметили что у magic-цикла нет тела?))) к чему бы это?)
//наверное к тому что он определил тот свободный блок что стоит сразу после нашего освобождаемого блока и соответсвенно предыдущий того.. вобщем мы попытались оккупировать освобожадемый блок.
if(last == nex) {
//да такая неприятность тоже может случится...
start = p;
p->next = nex;
}
else {
// говорим освобождаемому блоку, мол теперь ты свободен и ты всегда будешь следовать за следующим
p->next = nex;
// а предыдущему говорим, извини чувак, но тебе придется пропустить перед собой тока что освободившийся блок
last->next = p;
}
//свободная паямть после освободившегося куска
//вот та magic строчка что в скобках это сравнение, подсчитанного адреса в ручную с тем что имеем
if((block*)((char*)p + p->size + sizeof(block)) == nex) {
//если такое случилось это значит что они стоят рядом. а следовательно не будем создавать множество мелких республик. ВЕРШИМ СОЮЗ! объединяем. текущий и следующий.
// ну типа говорим что терь ты текущий будешь ссылаться на тот что стоит перед твоим впереди идущим соседом
p->next = nex->next;
// и твой размер теперь равен твоему + размеру впереди идущего соседа и плюс размера блока
p->size += nex->size + sizeof(block);
}
//свободная память до освободившегося куска
// тут мы проверям кто стоит сзади тебя. а вдруг свободный! тогда снова создадим союз)
if(last->size!=0 && (block*)((char*)last + last->size + sizeof(block)) == p) {
last->next = p->next;
last->size += p->size + sizeof(block);
}
return;
}
void pr(){
// ну типа ссылается на начало нашей памяти
block* p = (block*)memory;
printf("\n______________________\n");
//бежим от начала и по всем свободным блокам
for(;p;p = p->next){
//печатаем их размер
printf("| %d ", p->size);
}
//красиво завершаем изоображение нашей памяти.
printf("\n______________________\n");
}
// что тут вторится думаю объяснять не стоит сами разберетесь. =) и вконце концов вы книжку начали читать!???? а!?
int main(void){
printf("===NEW===\n");
size_t *a = mymalloc(-1);
pr();
printf("\n======\n");
a = mymalloc(20);
printf("a=mymalloc(20) --%d\n",a);
size_t* d=mymalloc(33);
printf("d=mymalloc(33) --%d\n",d);
size_t* b=mymalloc(600);
printf("b=mymalloc(600) --%d\n",b);
size_t* dd=mymalloc(33);
printf("dd=mymalloc(33) --%d\n",dd);
size_t* c=mymalloc(100);
printf("c=mymalloc(100) --%d\n",c);
printf("======\n");
pr(); printf("\n======\n");
myfree(a);
myfree(b);
myfree©; printf("free(a);free(b);free©;");
printf("\n======\n");
pr();printf("\n======\n");
b=mymalloc(600);printf("b=mymalloc(600) --%d",b);
pr();printf("\n======\n");
myfree(b);
myfree(dd);
myfree(d);
printf("\n===free(all)===\n");
pr();
return 0;
}
