Ответ на »сообщение 689« (Артем)
___________________________
Да, кстати - пример функции (три строчечки) которая в дельфи вылетает с переполнением стека я вам уже приводил.
Могу еще раз:

function Summ(inbr:integer):integer;
begin
  if inbr < 1 then Result := 1
  else Result := inbr + Summ(inbr-1) ;
end;

Прогоните с цифрой 1,000,000 и добейтесь выполнения без переполнения стека.
Может использовать {$MAXSTACKSIZE}
Ждем результатов :))

Ответ на »сообщение 690« (Артем)
___________________________
Я отвечал на вопрос о переполнении стека при процедуре быстрой сортировки, чему очень удивился и привел свой код, в котором переполнения не возникает даже при маленьком значении MAXSTACKSIZE.


А я отвечал на ваше "не возникает переполнения при 50,000" Вы уцепились за это 50,000.
"Большой массив" не означает 50,000.
Это может быть 1,000,000 в отдном случае и 20,000 в другом. Зависит от конкретной реализации функции.

Неужели при использовании нехвостовой рекурсии в неудачно спроектированной функции в ФЯ не возникает переполнение стека? 

Конечно возникает. Чудес не бывает. Стек он и в Африке стек. :))
Просто в ФЯ рекурсия - это основной инструмент. Без него как без рук. Поэтому tail call elimination обязательное требование ко всем компиляторам ФЯ.
А в ИЯ, рекурсия это игрушка, для ведения споров на форумах. Типа "мы тоже так могем".
Я уже приводил цитату из сообщения одного из разработчиков delphi.
На вопрос почему в дельфи не реализована оптимизация рекурсии, он ответил буквально следующее:
"Рекурсию ПРАКТИЧЕСКИ НИКТО НЕ использует, и мы не будем тратить свое время на фичу, которая НИКОМУ НЕ НУЖНА." :)) Это к вопросу есть ли рекурсия в ИЯ. Нет ее, поскольку НИКОМУ НЕ НУЖНА. :))

Ответ на »сообщение 686« (Jack Of Shadows)
___________________________
Но переполнение будет обязательно.
Это в отличие от лиспа и хаскеля. Где можно подождать полдня, но все таки дождаться выполнения функции.

Неужели при использовании нехвостовой рекурсии в неудачно спроектированной функции в ФЯ не возникает переполнение стека? Выражаясь словами Станиславского: "НЕ ВЕРЮ!". Или, может, у кого-то проблемы не только с обнаружением рекурсии в ООП-коде, но и с практикой в ФЯ?  :)

Ответ на »сообщение 683« (Jack Of Shadows)
___________________________

Вы вообще как это обсуждение читаете ? Знакомые слова выдергиваете ?
Ведь четко было сказано что РЕКУРСИЯ приводит к переполнению стека, а не обработка массива.
Массив можно и в цикле обработать и никакого переполнения не будет.
Кому вы тут что собираетесь сови кодом доказывать ? :))


Вагиф, не занимайтесь демагогией. На меня это не действует. Я отвечал на вопрос о переполнении стека при процедуре быстрой сортировки, чему очень удивился и привел свой код, в котором переполнения не возникает даже при маленьком значении MAXSTACKSIZE.

Если в моем коде

  procedure QuickSort(var A: array of Integer; iLo, iHi: Integer);
  var
    Lo, Hi, Mid, T: Integer;
  begin
    Lo := iLo;
    Hi := iHi;
    Mid := A[(Lo + Hi) div 2];
    repeat
      while A[Lo] < Mid do Inc(Lo);
      while A[Hi] > Mid do Dec(Hi);
      if Lo <= Hi then
      begin
        T := A[Lo];
        A[Lo] := A[Hi];
        A[Hi] := T;
        Inc(Lo);
        Dec(Hi);
      end;
    until Lo > Hi;
    if Hi > iLo then QuickSort(A, iLo, Hi);
    if Lo < iHi then QuickSort(A, Lo, iHi);
  end;

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

как показала практика более чем 30 лет (не ваш практика hugi, а практика миллионов программистов, сотен тысяч больших систем, и сотен миллионов строк кода) ООП неудачный способ реализации полиморфизма и инкапсуляции

Интересно, это вам нашептали на ушко миллионы программистов, или это очередной пример демагогии?

Ответ на »сообщение 685« (Geniepro)
___________________________
Ну, во-первых, мой вам совет: никогда не отлаживайте свой код в dpr-файле консольного проекта Дельфи. Это старый глюк от Борланда.

Перепишем ваш код в модуль. Пусть это будет уже GUI-проект (но можно и в консольный, только не в dpr, а в отдельный юнит),

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

const N = 50000;
var  a : array [1..N] of longint;


procedure QuickSort (Start, Finish : longint);
var i, j, r, t : longint;
begin
  if Start<Finish then
  begin
    r := a[Start];
    i := Start - 1;
    j := Finish + 1;
    while i < j do
    begin
      repeat Inc(i) until a[i] >= r;
      repeat Dec(j) until a[j] <= r;
      if i < j then begin t := a[i]; a[i] := a[j]; a[j] := t end
    end;
    QuickSort (Start, j);
    QuickSort (j + 1, Finish)
  end
end;



procedure TForm1.Button1Click(Sender: TObject);
var i:integer;
begin
  for i:= 1 to N do begin a[i] := N - i end;

  QuickSort (1, N);

  for i:= 1 to N do begin
    Memo1.Lines.Add(IntToStr(a[i]));
  end;
end;


end.

По умолчанию максимальный размер стека - {$MAXSTACKSIZE $0100000}.
Увеличьте его - {$MAXSTACKSIZE $01000000}. И ваша программа отработает. Вообще, по умолчанию размер стека в Дельфи маленький. Если будут интенсивно использоваться рекурсивные функции – его надо увеличивать.

Теперь о том, почему у меня все отработало и при стеке по умолчанию. Потому, что у меня более оптимальная и правильная рекурсивная функция. Посмотрите на нее внимательнее. :)

Ответ на »сообщение 686« (Jack Of Shadows)
___________________________


Мы уже перемывали это. Опять по новой ?

Ну так ведь повторенье - мать ученья... :-))

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

Ответ на »сообщение 669« (Артем)
___________________________
Артем, специально для вас, поискал и нашел пример с рекурсией, который выдает stack overflow: »сообщение 303«

Сказать конкретно на скольких итерациях вылетит ошибка переполнения невозможно.
Каждый раз это будет зависеть от того сколько локальных переменных было использовано.
То есть в одних случаях это будет 40,000 повторений, в других 1,000,000

Но переполнение будет обязательно.
Это в отличие от лиспа и хаскеля. Где можно подождать полдня, но все таки дождаться выполнения функции.
Мы уже перемывали это. Опять по новой ?

Ответ на »сообщение 669« (Артем)
___________________________

Блин, ну вы заставляете меня заниматься всякой ерундой. Я вот взял и из 500000 элементов массив обработал. Размер стека пол умолчанию. Даже оптимизацию не включал и фреймы для стека. Никакого перепонения. Привожу свой код, если не трудно, приведите свой

Забавно, ваш код и у меня нормально отрабатывает, а вот чуть-чуть отличающийся вариант даёт сбой и вызывает отладчик MS JIT-debugger с сообщением "An unhandled win32 exception occured in qSort.exe [260]"

program qSort;  {$APPTYPE CONSOLE}
  uses SysUtils;

  const N = 50000;
  var  a : array [1..N] of longint;
        i : longint;

  procedure QuickSort (Start, Finish : longint);
  var i, j, r, t : longint;
  begin
    if Start<Finish then
    begin
      r := a[Start];
      i := Start - 1;
      j := Finish + 1;
      while i < j do
      begin
        repeat Inc(i) until a[i] >= r; 
        repeat Dec(j) until a[j] <= r;
        if i < j then begin t := a[i]; a[i] := a[j]; a[j] := t end
      end;
      QuickSort (Start, j);
      QuickSort (j + 1, Finish)
    end
  end;

begin
  for i:= 1 to N do begin a[i] := N - i end;

  QuickSort (1, N);

  for i:= 1 to N do begin Write (a[i]:9, ' ') end; 
end.

Хотя массив размером в 40000 элементов сортируется без проблем...
А на полумиллионе значений ваще зависает...
Вообще-то я уже не уверен, что тут проблема со стеком, но если не с ним, то с чем тогда?

Ответ на »сообщение 667« (hugi)
___________________________
hugi, Буча я читал. Надеюсь вы тоже. Любой кто читал Буча, знает что никакого доказательства верности идей ООП ни он никто другой не приводил.
Это я не о полиморфизме и инкапсуляции. Это я о конкретном механизме ООП при помощи которого достигается полиморфизм и инкапсуляция.
А их можно получить множетсвом разных способов. ООП не единственный.
И как показала практика более чем 30 лет (не ваш практика hugi, а практика миллионов программистов, сотен тысяч больших систем, и сотен миллионов строк кода) ООП неудачный способ реализации полиморфизма и инкапсуляции.


А я то, несведущий человек, всю жизнь думал, что инкапсуляция и полиморфизм -- это СРЕДСТВА ООП, а ни как не цели!!!


Средствами ООП полиморфизм и инкапсуляция быть не могут hugi. :)) Я еще раз повторяю их можно достигнуть разными способами. Та же модульность - это СРЕДСТВО достижения инкапсуляции. Инкапсуляция это ИДЕЯ, а ООП - реализация этой идеи.
То же с полиморфизмом. Это ИДЕЯ. ООП - средство, механизм воплощения этой идеи.
Не единственный механизм, и не самый удачный.

В следующий раз будьте внимательнее читая Буча. А то перепутав цель со средством (интересно как вы себе представляете инкапсуляцию как средство :)) Это что инструмент ?, синтаксис ? тулза ? форомула ? ) можно много чего наговорить :))

Ответ на »сообщение 669« (Артем)
___________________________
Блин, ну вы заставляете меня заниматься всякой ерундой. Я вот взял и из 500000 элементов массив обработал. Размер стека пол умолчанию. Даже оптимизацию не включал и фреймы для стека. Никакого перепонения. Привожу свой код, если не трудно, приведите свой


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

Вы вообще как это обсуждение читаете ? Знакомые слова выдергиваете ?
Ведь четко было сказано что РЕКУРСИЯ приводит к переполнению стека, а не обработка массива.
Массив можно и в цикле обработать и никакого переполнения не будет.
Кому вы тут что собираетесь сови кодом доказывать ? :))