Как можно реализовать динамическое выделение памяти для переменных под ДОС? Что то наподобие функций C malloc() и т.д. Про функции 48h и 49h int21h я в знаю. Нужно именно выделение памяти из кучи. Хотя бы натолкните на мысль или чего почитать подскажите. Или исходники этих функций где нарыть.

void
Нужно именно выделение памяти из кучи
Свой менеджер кучи написать хочешь? Зачем?

Или исходники этих функций где нарыть.
Например, смотри CRTL BC++v3.1.

Вообщето это курсовой такой. Называется реализация функций С для работы с динамической памятью. Должно быть писано на С с asm вставками. А за CRTL спасибо сейчас буду рыть, блин как я сразу не подумал.

Функции 48h и 49h - это и есть динамическое выделение памяти "из кучи". Правда, не очень хорошего качества, но тем не менее... А какой компилятор будет использован для этого проекта?

хм, есть смысл выделять память под массивы, потому что какой смысл для выделения её под переменные до 4байт размером фключительно. Хм, а чем тебя функции дос не устраивают, чем тебя дософская куча не устраивает. К тому же не забывай, дос - однозадачная система. а вообще, молодой человек, прошу вас к Кирилл Григоричу Финогенову, уж он то вам покажет что к чему
Рудаков, Финогенов, Программируем на языке ассемблера IBM PC, Обнинск, 1997

Извольте-с

Компилятор будет использоваться BC 5.02 Все это будет писано на встроенном ассемблере (BASM кажись). А вообще то я порылся вчера в CRTL (вот уж действительно дельный совет), так эти функции (malloc, free) не пользуются функциями 48 и 49. Насколько я понял создается в памяти список свободных блоков памяти (причем выделять можно произвольного размера, а не с выравниванием по параграфам), и ведется очень активная работа со стеком. Не знаю: такое подозрение что динамическая память реализуется за счет перераспределения стека. Кстати это замечание мне в инете уже попадалось. К тому же есть 2 реализации malloc для near и far указателей, в зависимости от модели памяти используемой программой. Чувствую это я не смогу осилить за разумное время, будем выделять всеж параграфами :-) Все таки есть вопрос к аудитории: как можно из запущеной программы определить какую модель памяти она использует?

void
Вообще модель памяти - это условность.

Можно использовать условную компиляцию. В Borland C определены макросы: __COMPACT__, __HUGE__, __LARGE__, __MEDIUM__, __SMALL__, __TINY__, а в Microsoft C - M_I86mM, _M_I86mM где m = T, S, C, M, L или H

Если без макросов, то можно попробовать такой код (проверял BC++v3.1 и MSVC++v1.52) (отличить large от huge мне не удалось)

#include <stdio.h>

typedef enum {
  mm_unknown = 0,
  mm_tiny,
  mm_small,
  mm_medium,
  mm_compact,
  mm_large_or_huge,
} memory_model;

memory_model detect_memory_model(void)
{
  int v1 = sizeof(void *);
  int v2 = sizeof(void (*)(void));

  int b2 = sizeof(unsigned short);
  int b4 = sizeof(unsigned long);

  if (b2 == v1 && b2 == v2)
  {
    unsigned short rCS, rDS;

    __asm push cs
    __asm pop  rCS
    __asm push ds
    __asm pop  rDS

    return rCS == rDS ? mm_tiny : mm_small;
  }

  else if (b2 == v1 && b4 == v2)
    return mm_medium;

  else if (b4 == v1 && b2 == v2)
    return mm_compact;

  else if (b4 == v1 && b4 == v2)
    return mm_large_or_huge;

  return mm_unknown;
}

int main(void)
{
  char *mm_text = "";

  switch (detect_memory_model())
  {
  case mm_unknown:
    mm_text = "unknown";
    break;

  case mm_tiny:
    mm_text = "tiny";
    break;

  case mm_small:
    mm_text = "small";
    break;

  case mm_medium:
    mm_text = "medium";
    break;

  case mm_compact:
    mm_text = "compact";
    break;

  case mm_large_or_huge:
    mm_text = "large or huge";
    break;

  default:
    mm_text = "?";
  }

  printf("memory model is %s\n", mm_text);

  return 0;
}

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

Сканирование exe не поможет? Сорьки, я не в курсе как там в досе ехешники писались. Но в винде это делается через заголовок.

void
Либо я не правильно понял той термин неиспользуемой области сегмента, либо - компиляторы не дураки пишут. Зачем создавать сегмент больше, чем это необходимо? В конце сегмента может быть неиспользуемое пространство, объем которого зависит от атрибута выравнивания сегмента. Теоретически не более 4кБ, а под dos’ом практически не более 16-ти байт.

Вообщето насколько я понял в С действительно создается сегмент больше чем нужно (все таки это не asm). Кстати расположение heap зависит от модели памяти. Но я ковырял модель small, поэтому вот мои наблюдения. Сегмент данных и стека совпадает. Между ними где-то посередине heap. Причем heap этот есть там по умолчанию, так как некоторые C функции используют его неявно. Если посмотреть dump сегмента данных, то там даже есть слова heap end. В общем по большому счету нужно найти его начало. И использовать эту область по своему. Есть такое мнение: все глобальные переменные хранятся в сегменте данных и я думаю что можно подсчитать сколько памяти нужно под них. Все локальные переменные функций хранятся в стеке, в общем думаю можно подсчитать тоже, ну или на крайняк просто области стека дать хороший запас. Тогда получится что этот остаток можно использовать под heap. Правда все это носит искуственный характер. Я например не представляю как это можно посчитать из программы. Еще одно смущает. Если функции используют heap неявно, то любое мое вмешательство в его работу приведет к краху программы. Похоже что все это создается на уровне компилятора и влезть туда не представляется возможным. Теперь другая формулировка вопроса. Если он уже там есть, то почему бы им не воспользоваться. То есть теперь требуется написать реализации функций для корректной работы с С heap. Может у кого есть доки по реализации heap в С? Как получить к нему доступ? Может кто чего посоветует?