Qu'est-ce que “pass-par nom” et comment ça fonctionne exactement?

J'ai trouvé une bonne explication à Passer-Par-Nom De Paramètre Passant. Essentiellement, le corps d'une fonction est interprété lors de l'appel de temps après textuellement la substitution de paramètres effectifs dans le corps de la fonction. En ce sens, la méthode d'évaluation est similaire à celle de préprocesseur C macros.

Par la substitution des paramètres effectifs dans le corps de la fonction, le corps de la fonction peut à la fois lire et écrire les paramètres donnés. En ce sens, la méthode d'évaluation est similaire à passé par référence. La différence, c'est que depuis avec passe-par-nom du paramètre est évalué l'intérieur de la fonction, d'un paramètre comme a[i] dépend de la valeur actuelle de i l'intérieur de la fonction, plutôt que de se référer à la valeur au a[i] avant que la fonction a été appelée.

La page ci-dessus a d'autres exemples de cas où le passe-par-nom est à la fois utile et dangereux. Les techniques rendues possibles par le passe-par-nom sont largement dépassée aujourd'hui par d'autres techniques plus sûres telles que le passage par référence et les lambda fonctions.

Pour ceux dans l'avenir:

Notions dans les Langages de Programmation par
John C. Mitchell a également été utile.

Passer-par-Nom. Peut-être le plus étrange
fonction d'Algol 60, avec le recul, est
l'utilisation de passe-par-nom. Dans
passer-par-nom, le résultat d'une
appel de procédure est la même que si l'
paramètre formel, ont été remplacés dans
le corps de la procédure. Cette règle
pour définir le résultat d'une procédure
appel par la copie de la procédure et
la substitution de paramètres formels
est appelé le Algol 60 règle de copie.
Bien que la règle de copie fonctionne bien pour
pure programmes fonctionnels, comme
illustré par β réduction lambda
le calcul, l'interaction avec le côté
effets pour le paramètre formel sont un
peu étrange. Voici un exemple
programme montrant une technique visée
comme Jensen de l'appareil: passer un
expression et une variable qu'il contient
à une procédure afin que la procédure
pouvez utiliser un paramètre pour changer la
emplacement visé par l'autre:

---

 begin integer i;
        integer procedure sum(i, j);
            integer i, j;
                comment parameters passed by name;
            begin integer sm; sm := 0;
                for i := 1 step 1 until 100 do sm := sm + j;
                sum := sm
            end;
        print(sum(i, i*10 ))
 end

---

Dans ce programme, la procédure
somme(i,j) ajoute les valeurs de j comme je l'ai
va de 1 à 100. Si vous regardez la
code, vous vous rendrez compte que le
la procédure n'a pas de sens à moins que
des changements pour que je cause un peu de changement dans la
la valeur de j; sinon, la procédure
calcule 100*j. Dans l'appel
sum(i, i*10) montré ici, la boucle for
dans le corps de la procédure de somme s'ajoute
la valeur de i*10 que je passe de 1 à
100.

Flatlander a un exemple révélateur de la façon dont il fonctionne dans la Scala ici. Supposons que vous vouliez mettre en œuvre tout:

def mywhile(condition: => Boolean)(body: => Unit): Unit =
  if (condition) {
    body
    mywhile(condition)(body)
  }

On peut appeler cela comme suit:

var i = 0
mywhile (i < 10) {
  println(i)
  i += 1
}

Scala n'est pas Algol 60, mais peut-être qu'il jette un peu de lumière.

ALGOL a été conçu pour des algorithmes mathématiques. J'aime la somme fonctionner comme un exemple de l'appeler par son nom.

Désolé mon ALGOL est un peu rouillé, la syntaxe est probablement pas le droit.

.FUNCTION SUM(var,from,to,function)
.BEGIN
  .REAL sum =0;
  .FOR var = from .TO to .DO sum = function;
  return sum;
.END

Vous pourrait utiliser la somme de

  Y = sum(x,1,4,sum(y,3,8,x+y));

Au-dessus de l'intérieure de la somme(y,3,8,x+y) permettrait de générer une fonction sans nom pour passer à l'extérieur de la somme d'appel. Les variables x et y ne sont pas passés par valeur, mais de nom. Dans le cas des variables appeler par son nom est l'équivalent de l'appel en fonction de l'adresse de référence en C. C'est un peu déroutant lorsque la récursivité est impliqué.

Emprunte fait ALGOL machines. Ils avaient 48 bits mot de la mémoire avec 3 drapeau bits. Le drapeau bits de mise en œuvre de la cal par nom d'ALGOL. c'était une pile de linge, afin que lorsque la fonction a été chargé sur la pile de les appeler par leur nom fag serait la cause d'être appelé. Le compilateur de générer sans nom fonctions lorsque expressions ont été utilisées comme arguments. Une variable qui serait une simple référence indirecte. Une erreur se produit l'écriture d'une fonction.