¿Es posible borrar pila de llamadas?

[REHome]

Hola:

He hecho esto. Porque controla que no haya recursividad sin darme cuenta y funciona.

using System;

namespace Pila_de_llamadas_Consola_03
{
    internal class Program
    {
        // Contador para controlar la recursividad.
        private static int contador = 0;

        static void e()
        {
            if (contador < 1) // Limita las llamadas recursivas.
            {
                contador++;
                a();
            }
        }
        static void d()
        { // Aquí.
        }

        static void c()
        {
        }

        static void b()
        {
            c();
            d();
            e();
        }

        static void a()
        {
            b();
        }

        static void Main(string[] args)
        {
            a();

            Console.WriteLine("Fin de programa.");

            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
    }
}

Funcione para este ejemplo de arriba, pero no para lo que estoy haciendo.

En lo que comentas.

En lugar de llamar de unas a otras, puedes regresar con un parámetro a la principal e indicando en ese parámetro a cuál debe ir.

Por lo que veo, no debo llamar a un void a otro void o funciones. Debo terminar ese void o función primero solo para que quite la pila en memoria. Luego como dices, indicar a donde quiero ir, es decir, llamar a otro void, pero este ya estará limpio y no se me queda almacenado sin darme cuenta.

Iba a usar los goto que no usa pila de llamadas en ningún momento, todo el mundo me dicen, prohibido usar goto, porque así evito malas prácticas de programación a cara el futuro.

¿Puedes poner un ejemplo sobre lo que indicas?

Gracias.

[delphi.com.ar]

Es importante aclarar que void es el tipo de dato que devuelve la función, las llamadas son a funciones, métodos o procedimento sin resultado, no a void. Lo que estas haciendo es un ciclo sin salida (A>B>E>A), la pila se va a llenar siempre. Para eso debes controlar la recursividad.

Código Delphi [-]
using System;

namespace Pila_de_llamadas_Consola_01
{
    internal class Program
    {
        static void e()
        {
            a(false);
        }
        static void d()
        { // Aquí.
        }

        static void c()
        {
        }

        static void b()
        {
            c();
            d();
            e();
        }

        static void a(bool recursive)
        {
            if (recursive)
               b();
        }

        static void Main(string[] args)
        {
            a(false);
        }
    }
}

Esto es una adaptación rápida, pero no parece tener lógica, es difícil entender lo que quieres lograr.

[mamcx]

Hay maneras para evitar un stack overflow:

• Usar un continuation passing style, cuya ventaja es que es genérico y consume menos memoria, pero es mas complejo de usar
• Usar un trampiling
• Manejar tu propio stack

Usando la ultima forma, porque parece que estas intentando es hacer un 'Navigation Controller` como: https://developer.apple.com/document...tioncontroller, y es muy fácil de esquematizar:

Código Delphi [-]
type
  TView = (Root, ScreenA, ScreenB);


type
  TNavigationStack = class
  private
    FStack: TArray;
  public
    constructor Create;
    procedure Push(View: TView);
    function Pop: TView;
    function Current: TView;
  end;


constructor TNavigationStack.Create;
begin
  SetLength(FStack, 1);
  FStack[0] := Root;  // Start with the root view
end;

procedure TNavigationStack.Push(View: TView);
begin
  SetLength(FStack, Length(FStack) + 1);
  FStack[High(FStack)] := View;
end;

function TNavigationStack.Pop: TView;
begin
  if Length(FStack) > 1 then
  begin
    Result := FStack[High(FStack)];
    SetLength(FStack, Length(FStack) - 1);
  end
  else
    Result := Root;  // Prevent popping the root view
end;

function TNavigationStack.Current: TView;
begin
  Result := FStack[High(FStack)];
end;