Du POV de la langue, est-ce que Succ/Prev devrait s'appliquer aux pointeurs?

Question

Je me demande si les intrinsèques Succ/Préc devraient pouvoir être utilisés sur des types de pointeurs typés. Tout comme Inc/Dec et les mathématiques (PointerVar+1 et PointerVar-1).

• http://docwiki.embarcadero.com/Libraries/en/System.Succ
• http://www.freepascal.org/docs-html/rtl/system/succ.html

Ceux-ci ne s'appliquent succ/pred aux "types ordinaux" qui ne sont pas répertoriés pointes une partie. Il en est de même pour le rapport Pascal 1972 (appelé types scalaires)

Cependant, les revendications http://www.gnu-pascal.de/gpc/Succ.html#Succ "L'application de Succ aux pointeurs est définie dans Borland Pascal." et il ne semble pas raisonnable d'exclure ces fonctions dans le sillage de Pointers Math.

Cette restriction est-elle justifiée par le langage ou simplement par un problème de mise en œuvre, les fonctions Succ/Pred étant considérées comme quelque peu obscures?

program Project9; // Delphi does have reverse-analogu for Pos/PosEx functions 
{$APPTYPE CONSOLE} // So Delphi IDE (Version Insight) to cut away a last part 
uses    // of string abuses mixing of record helper (LastIndexOf) 
    System.SysUtils; // and System.Copy function. Searchinf to fix it found this... 
var 
    OutPut, RemoteName: string; 
    P: PChar; 
begin 
    try 
    OutPut := 'aaaaaa/zzzzzz'; 
    P := StrRScan(PChar(OutPut), '/'); 

    P := Succ(P); 
    // XE2: [DCC Fatal Error] Project9.dpr(13): F2084 Internal Error: AV0C068241-R00000000-0 
    // 10.1: [dcc32 Error] Project9.dpr(13): E2008 Incompatible types 

    P := 1+P; // Another way to say Succ() - and works in both XE2 and 10.1 
    Inc(P); // Yet one more way to say Succ() - and works in both XE2 and 10.1 too  

    RemoteName := P; 
    except 
    on E: Exception do 
     Writeln(E.ClassName, ': ', E.Message); 
    end; 
end. 

Il est intéressant de le comparer avec le type var changé - P: Pointer; plutôt que PChar.

var P: Pointer; S: String; 

P := Succ(P); // error 
Inc(P);  // error 
P := 1+P;  // works in XE2 if {$POINTERMATH ON}, error if {$POINTERMATH OFF} 
       // error in 10.1 regardless 

S := PChar(P); // crashes XE2 if "P := 1+P;" is there above 

Answer 1

TP ne permet AFAIK aucun type d'augmentation, même pas sur afaik pchar (qui Delphi avant POINTERMATH $ déjà permis). La question est donc différente pour TP (modèle de mémoire segmentée!) Comme pour Delphi. Succ et pred sont définis pour fonctionner sur des valeurs ordinales.

Malgré cela vous pouvez ajouter des entiers aux pointeurs actuellement les pointeurs ne sont pas considérés comme un type ordinal. (voir par exemple ordinal types). On pourrait argumenter qu'il pourrait s'agir d'un type ordinal (un pointeur dans delphi respecte les exigences du lien ci-dessus), mais il ne le fait pas dès que votre modèle de mémoire est segmenté (puisqu'il y a plusieurs minimums et maximums

Une exception pourrait être faite, peut-être, pour succ et pred de toute façon, mais quel serait le point sauf un travail d'espoir? Il doesn't make anything possible that couldn't be done before.

Answer 2

Bien sûr, non. C'est contre les règles de langue. Voici contrat formel Succ et Pred mettent en œuvre (de ISO/IEC 7185:1990):

succ (x)

De l'expression x qui doit être d'un type ordinal, cette fonction renvoie un résultat qui doit être du même type que celui de l'expression (voir 6.7.1). La fonction doit produire une valeur dont le nombre ordinal est supérieur à celui de l'expression x, si une telle valeur existe. Ce sera une erreur si une telle valeur n'existe pas.

pred (x)

De l'expression x qui doit être d'un type ordinal, cette fonction renvoie un résultat qui doit être du même type que celui de l'expression (voir 6.7.1). La fonction doit produire une valeur dont le numéro ordinal est inférieur de un à celui de l'expression x, s'il existe une telle valeur .Ce sera une erreur si une telle valeur n'existe pas.

Comme vous le voyez, Succ et Pred sont définis pour les arguments de types ordinaux seulement, il est donc incompatible avec les types de pointeur (en raison de l'absence de ordinalité inhérente, selon le contrat).