Re: renames

Le mardi, 16 aoû 2005, à 22:34 Europe/Paris, Laurent GUERBY a écrit :

> On Tue, 2005-08-16 at 22:05 +0200, Thomas De Contes wrote:
>> Bonjour :-)
>>
>>
>> J'ai :
>> p :machin renames s.p(cnd.m);
>>
>> s et cnd sont des variables
>> s.p est un tableau de machin, cnd.m est l'index
>>
>> Je modifie cnd.m après cette déclaration,
>> et apparemment, quand j'utilise p après, cnd.m a l'ancienne valeur,
>> cad que qqch aurait été figé au moment de la déclaration du renames
>>
>> Ca me surprends, parce que je pensais que "renames" c'était uniquement
>> un raccourci, et que *tout* était recalculé à chaque fois
>>
>>
>> Est ce que qqn pourrait m'expliquer comment ça marche exactement, svp 
>> ?
>> quand il y a des fonctions par exemple
>
> renames s'applique a des objets et non a des expressions symboliques
> c'est pour ca que tu as ce comportement. Quand il y a des fonctions
> c'est l'objet resultat de l'appel initial.

aaaah !! ok :-))


Le mercredi, 17 aoû 2005, à 09:19 Europe/Paris, Jean-Pierre Rosen a 
écrit :

> Il y a une règle très simple en Ada: toute déclaration est élaborée, 
> et sa signification ne change pas après l'élaboration.

Je crois que j'arrive pas encore à cerner tout ce que recouvre 
"élaborer"

> Dans le cas d'un rename, on *élabore* la déclaration; pour celà, on 
> *évalue* l'expression, puis le nom désigne le résultat de cette 
> évaluation. Cela n'a rien à voir avec une substitution de style 
> "macro".

Ok, je pense comprendre le cas particulier du rename :-)


> C'est d'ailleur un bon moyen de faire le presque equivalent d'une
> affectation sur des objets dont le type est limité privé :
>
> procedure PP is
>    type T is limited null record;
>    Tmp : T;
>    function F return T is
>    begin
>       return Tmp;
>    end F;
>    -- Y : T := F; -- Illegal
>    Y : T renames F; -- Legal
> begin
>    null;
> end PP;

Alors ça veut dire que dans :

procedure PP is
    type enormetruc is null record;
    function F return enormetruc is
       Tmp : enormetruc;
    begin
       gros calcul de plusieurs minutes;
       return Tmp;
    end F;
    Y : T renames F;
begin
    null;
end PP;

Le gros calcul est fait une seule fois, au moment du renames ?
Je croyais qu'il serait fait à chaque utilisation de Y !!

Ca veut dire qu'au moment de l'"élaboration" de Y, il y a 2 choses :
- La fonction est calculée
- Allocation d'un emplacement mémoire pour y mettre le résultat de la 
fonction (en l'occurrence ça doit être celui de Tmp qui est gardé), qui 
sera pointé à chaque utilisation de Y (ce qu'il n'y aurait pas si Y 
pointait qqch de modifiable)
C'est bien ça ? :-)

Génial, ça veut dire qu'il y a plein de déclarations de constantes qui 
vont sauter, et de pragma Preelaborate qui vont réapparaître :-)))

_______________________________________________
Site WWW de l'association Ada-France: http://www.ada-france.org/
[email protected]
http://www.ada-france.org/mailman/listinfo/ada-france