Est-ce qu'un dialecte de Pascal autorise un nombre variable d'arguments?

Ceci est une question pour les programmeurs plus anciens.Est-ce qu'un dialecte de Pascal autorise un nombre variable d'arguments?

Il y a des années, j'ai rencontré un dialecte de Pascal qui permettait un nombre variable d'arguments, à travers une sorte d'extension.

Est-ce que quelqu'un connaît un dialecte courant de Pascal qui permet un nombre variable d'arguments? Etant donné que Pascal n'est plus aussi populaire qu'auparavant, je ne serais pas surpris si la réponse est non.

BTW, il est plus correct, non, dire nombre variable d'arguments , plutôt que paramètres?

Source

2009-09-22 pavium

Oui, il est, plus correct de dire le nombre variable d'arguments, la fonction ne peut avoir qu'un seul paramètre qui est une liste variable d'arguments, généralement comme le dernier paramètre –

J'aime cette façon de penser: «un paramètre qui est une liste variable de paramètres '+1 (mais vous n'êtes pas vraiment * assez vieux * ;-D) – pavium

Non. La réponse est basée sur les dialectes Pascal que j'ai utilisés; d'autres peuvent être différents.

La raison est que Pascal pousse les arguments sur la trame de la pile dans l'ordre, de sorte que tous les arguments sont accessibles via un décalage fixe du pointeur de la pile. C, par comparaison, pousse les arguments dans l'ordre inverse, de sorte que les paramètres définis sont à décalage fixe, et vous pouvez accéder aux arguments "supplémentaires" via l'arithmétique du pointeur. Je vais essayer un peu d'art ASCII:

 Pascal     C 

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

En ce qui concerne le paramètre par rapport à l'argument: comme je l'ai appris, la fonction (méthode) définit ses paramètres, l'appelant transmet des arguments. Cette définition est venue, je crois, d'un manuel Fortran, donc cela devrait vous donner une idée de mon âge :-)

Source

2009-09-22 12:33:15 kdgregory

Merci, je vais voir si je peux trouver une description des internes d'Apollo DOMAIN Pascal, le dialecte qui a permis des listes variables d'arguments (et que je suis * toujours * en train d'utiliser). Votre explication a l'anneau de la vérité à ce sujet. – pavium

Si vous l'utilisez encore, vous devriez être capable de désassembler un exemple avec différentes séquences d'appel. Je ne serais pas surpris s'ils utilisent les conventions d'appel C. – kdgregory

Pour la documentation d'Apollo, voir ici: http://bitsavers.trailing-edge.com/pdf/apollo/ –

Vous pouvez utiliser des arguments en option avec delphi pour obtenir le même effet:

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

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

Ou méthodes surchargées:

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

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

Ou vous pouvez utiliser un tableau variable pour les paramètres:

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

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

Source

2009-09-22 12:31:34

Super, je me suis qualifié comme vieux ;-). –

Il semble que vous construisiez explicitement le tableau dans votre deuxième exemple, correct? – kdgregory

@Gamecat, je vais mettre à votre expérience de 30 ans, mais il n'y a rien de mal avec * age *. Merci. – pavium

GNU-Pascal (basé sur gcc) afaik mappe 1: 1 à l'appui C. using la fonction quelque chose (arg: pchar; ...) comme la syntaxe

Delphi/Free Pascal a le support "array of const", qui est une version de typesafe, et une directive varargs pour l'interfaçage C (D6 ou D7 +)

Source

2009-10-05 15:22:00

Vous pensez probablement à une bibliothèque qui était disponible pour Turbo Pascal où ils avaient un hack comme celui-ci. Ma syntaxe est un peu rouillée pour les objets et en découle.

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));

Vous pouvez simplement chaîner autant d'arguments que vous le souhaitez. Le dernier devait être terminé avec zéro.

Source

2015-06-10 03:24:40

Est-ce qu'un dialecte de Pascal autorise un nombre variable d'arguments?

Répondre

Questions connexes