Динамическое распределение памяти, c++ Опции

[Rocket]

Доброго времени суток, Уважаемые Форумчане! Вот столкнулся с заданием, которое необходимо реализовать, как можно быстрей... Значит, нужно написать программу, моделирующую динамическое распределение памяти в операционной системе. В качестве модели оперативной памяти программа должна использовать байтовый массив размера не менее 256 байт. Использование других глобальных переменных в программе запрещено. В программе в обязательном порядке должны присутствовать следующие функции:
а) Выделить участок заданного размера. В случае успеха вывести начальный адрес выделенного участка. Если участка подходящего для выделения не найдено, необходимо вывести диагностическое сообщение о нехватке памяти.
б) Освободить ранее выделенный участок. В качестве параметра функция должна принимать начальный адрес освобождаемого участка. Ранее выделенный участок может быть освобожден только целиком (освобождение части участка не допускается).
в) Получение информации о свободных/занятых участках в «оперативной памяти» (количество участков каждого типа, начальные адреса, размеры, общее количество занятой и свободной памяти).
А хранить всю информацию, я должен ввиде списков блоков; алгоритм выделения- двоичное разбиение.
Помогите, пожалуйста с реализацией! Возможно у кого-ибудь найдутся соответветсвующие наработки....
Что вообще из себя представляет двоичное разбиение?...

[volvo]

Мне просто необходима Ваша помощь в реализации...

Ну, ты же понимаешь, что если написать программу вместо тебя, то это тебе ничего не даст... Помочь - можно... Что именно у тебя вызывает наибольшую сложность? Начни хоть что-нибудь делать, потом будет видно, как можно продвигаться дальше, какими средствами ты умеешь пользоваться...

Я вот набросал программку, которая умеет только выделять память и печатать списки свободных блоков (чтобы хоть как-то проконтролировать правильность выполнения), но во-первых, в ней использовались vector-ы из STL, а во-вторых, не совсем понятно вот что:

MemoryManager mm;

    int X = mm.requestAlloc(26);
    std::cout << "Alloc result = " << X << std::endl;
    mm.printLists();
    int Y = mm.requestAlloc(15);
    std::cout << "Alloc result = " << Y << std::endl;
    mm.printLists();

Допустим, все работает. Как именно должно происходить "возвращение" памяти в систему. Я о том, откуда MemoryManager должен знать, что X - это адрес начала блока из 32-х, а Y - адрес начала блока из 16-ти элементов? Это что, хранить кроме списка свободных блоков еще и список выделенных? Или как?

В общем, ждем начала твоей реализации...

[Rocket]

В общем, ждем начала твоей реализации...

Вот она :

#include <iostream>
#include <cmath>
using namespace std;

char ram[258]; 

int get_mem(int byte) 
{
    int block=1;
    int cx=0, result=0, j=0;

    block=(int)ceil((double)byte/3);
    if(block > 86) { cout <<"Error!!!" <<endl; return -1; }

    for(int i=0;i<258;i=i+3)
    {
        switch(ram[i] | 0)
        {
            case 0: cx++; break;
            case 128: cx=0; break;
        }
        if(cx==block)
        {
            result=i;
            break;
        }
        if(i==255 && cx!=block)
        {
            cout <<"Error!!!" <<endl;
            return -1;
        }
    }
    j=result;
    cx=0;
    while(cx!=block)
    {
        ram[j]=ram[j] | 128;
        //ram[j+1]=byte;
        cx++;
        if(cx==block) { ram[j+1]=byte; break; }
        j=j-3;
    }
    return j;
} 
//---------------------------------------------
void del_mem(int address)
{
    int block, byte;

    byte=ram[address+1];
    block=(int)ceil((double)byte/3);
    for(int i=address;i<address+block*3;i=i+3)
        ram[i]=ram[i] & 0;
}
//-----------------------------------------
void inf()
{
    int block=0, free_block=0;
    int p, free_mem, nf_mem, i;
   
    for(int j=0;j<258;j=j+3)
    {
        if((ram[j] | 0) == 0 ) free_block++;
        else block++;
    }

    nf_mem=block*3;
    free_mem=free_block*3;
    cout <<"number of free blocks: " <<free_block <<endl;
    cout <<"number of not free blocks: " <<block <<endl;
    i=0;
    while(i<258)
    {
        switch(ram[i] | 0)
        {
            case 0: i=i+3; break;
            case 128: p=(int)ceil((double)ram[i+1]/3);
                      cout <<"address " <<i <<' ' <<"size: " <<p*3 <<endl;
                      i=i+p*3;
                      break;
        }
    }
    cout <<"count of free memory: " <<free_mem <<" bytes" <<endl;
    cout <<"count of not free memory: " <<nf_mem <<" bytes" <<endl;
}
//-----------------------------------------
int main()
{
    int a, b;
    char choise='0';

    while(choise!=27)
    {
        cout <<"=====================================================" <<endl;
        cout <<"1. get memory" <<endl;
        cout <<"2. free memory" <<endl;
        cout <<"3. information of memory" <<endl;
        cout <<"exit- Esc" <<endl;
        cout <<"Make your choise: ";
        cin >>choise;
        cout <<"=====================================================" <<endl;
        switch(choise)
        {
            case '1': cout <<endl;
                      cout <<"Enter byte: ";
                      cin >>a;
                      b=get_mem(a);
                      break;
            case '2': cout <<endl;
                      cout <<"Enter address: ";
                      cin >>a;
                      del_mem(a);
                      break;
            case '3': inf();
                      break;
            default: break;
        }
    }

    return 0;
}

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