C'è qualche dialetto Pascal consentire a un numero variabile di argomenti?

Question

Questa è una domanda per anziani programmatori.

Anni fa, ho incontrato un dialetto di Pascal che ha permesso un numero variabile di argomenti, attraverso una sorta di estensione.

Qualcuno sa di un dialetto corrente di Pascal che consente a un numero variabile di argomenti?

Dato che Pascal non è così popolare come una volta di essere, non sarei sorpreso se la risposta è no.

A proposito, è è più corretto, non è vero, a dire numero variabile di argomenti , anziché parametri

Answer 1

No. La risposta è basata sui dialetti Pascal che ho usato; altri possono essere diversi.

Il motivo è che Pascal spinge argomenti sullo stack frame in ordine, in modo che tutti gli argomenti sono accessibili tramite un offset fisso dal puntatore stack. C, in confronto, spinge gli argomenti in ordine inverso, i parametri così definiti sono a offset fisso, ed è possibile accedere argomenti "extra" mediante l'aritmetica dei puntatori. Cercherò un po 'arte ASCII:

        Pascal                  C

                                ---------------------
                                |     extra arg     |
        ---------------------   ---------------------
        |     1st param     |   |     3rd param     |
        ---------------------   ---------------------
        |     2nd param     |   |     2nd param     |
        ---------------------   ---------------------
SP ->   |     3rd param     |   |     1st param     |
        ---------------------   ---------------------

Per quanto riguarda il parametro rispetto argomento: come ho imparato, la funzione (metodo), definisce i suoi parametri, il chiamante passa gli argomenti. Tale definizione è venuto, credo, da un manuale Fortran, in modo che dovrebbe dare un'idea di quanti anni ho: -)

Answer 2

È possibile utilizzare argomenti opzionali con Delphi per ottenere lo stesso effetto:

procedure Proc(const A: Integer; const B: Integer = 15);

Proc(10);  // B = 15
Proc(20,30);

o sovraccarico metodi:

procedure Proc(const A: Integer); overload;
procedure Proc(const A,B: Integer); overload;

Proc(10);     // Variant 1
Proc(20,30);  // Variant 2

In alternativa, è possibile utilizzare una matrice di variabili per i parametri:

procedure Message(const AMessage: string; const AArgs: array of const);

Message('Hello %s', [Name]);
Message('%s %s', [Greeting, Name]);

Answer 3

GNU-Pascal (GCC based) per quanto ne so mappe 1: 1 al supporto C. utilizzando la funzione qualcosa (arg: PChar; ...), come la sintassi

Delphi / Free Pascal ha "serie di const" supporto, che è una versione typesafe, e una direttiva varargs per il C interfacciamento (D6 o D7 +)

Answer 4

Probabilmente state pensando di una libreria che era disponibile per Turbo Pascal dove avevano un hack come questo. La mia sintassi è un po 'un arrugginito per gli oggetti e discendente da esso.

type
  TValue = object;

  TInteger = object(TValue)
    Value : Integer;
  end

  TString = object(TValue)
    Value : String;
  end

  TParam = record
    Value : TValue;
    Param : TParam;
  end;

  TValue = object;

{ Definition of Function }
function Test (Arg : TParam);

{ Usage }
var
  I : TInteger;
  S : TString;

Test (TParam (I, TParam (S, nil));

Si potrebbe semplicemente catena come tanti argomenti, come si voleva. L'ultimo doveva essere terminato con zero.