SimplonSphere
In Code We Trust

Réimplémenter les opérateurs ++ et — dans Swift 2.2

    Home  /  Geek Lifestyle  /  Réimplémenter les opérateurs ++ et — dans Swift 2.2

Réimplémenter les opérateurs ++ et — dans Swift 2.2

plus-minus

 

Introduction

Langage en constante évolution depuis son lancement le 2 juin 2014 par Apple, Swift vient de passer en version 2.2. L’un des changements les plus marquants du langage à cette occasion est la dépréciation des opérateurs d’incrémentation et décrémentation préfixe ou suffixe ++ et --.

Cette modification fait suite à une proposition de Chris Lattner qui est pourtant le créateur Swift. L’argument principal avancé par Chris Lattner pour supprimer ces opérateurs historiques est qu’ils généraient trop de confusion dans le résultat attendu selon leur utilisation avant ou après la variable à modifier (voir Remove the ++ and — operators).

Voici un exemple d’utilisation des opérateurs ++ et -- qui était parfaitement valide avec Swift 2.1:

 

var a = 10
print(a++) // prints 10
print(a) // prints 11
 
var b = 10
print(–b) // prints 9
print(b) // prints 9

 


Avec Swift 2.2, l’utilisation des opérateurs ++ et -- génère désormais un message d’alerte: '++ / --' is deprecated: it will be removed in Swift 3. Avec Swift 3, prévu avant la fin de l’année, l’utilisation de ces opérateurs ne sera plus du tout autorisée et générera une erreur de compilation. Aussi, Apple recommande désormais d’utiliser les opérateurs += et -+.

 

var a = 10
a += 1
print(a) // prints 11
 
var b = 10
b -= 1
print(b) // prints 9

 


Réimplémenter ++ et — pour le type Int

A l’annonce de ce changement dans le langage, certaines personnes se sont demandé s’il était possible de réimplémenter ces opérateurs. Si une telle réimplémentation dans un projet réel n’est pas recommandée, elle constitue cependant un bon excercice pour découvrir certains concepts avancés du langage.

La solution la plus simple pour cela fait appel à defer, inout, prefix operator et postfix operator. Ainsi, la première étape consiste à redéfinir chacun des opérateurs:

 

prefix operator ++ {}
prefix operator — {}
postfix operator ++ {}
postfix operator — {}

 


Il faut ensuite implémenter les fonctions liées à ces opérateurs:

 

prefix func ++(inout a: Int) -> Int {
    a += 1
    return a
}
 
prefix func –(inout a: Int) -> Int {
    a -= 1
    return a
}
 
postfix func ++(inout a: Int) -> Int {
    defer { a += 1 }
    return a
}
 
postfix func –(inout a: Int) -> Int {
    defer { a -= 1 }
    return a
}

 


Ici, le paramètre a étant de type Int – c’est à dire un value type et non un reference type – il faut lui adjoindre le mot-clé inout afin de pouvoir modifier la valeur du paramètre à l’extérieur de la fonction.

Pour les opérateurs d’incrémentation et décrémentation suffixe, il faut retourner la valeur du paramètre puis augmenter immédiatement sa valeur grâce à defer.

Le code complet (testé dans un Playground)

 

prefix operator ++ {}
prefix operator — {}
postfix operator ++ {}
postfix operator — {}
 
prefix func ++(inout a: Int) -> Int {
    a += 1
    return a
}
 
prefix func –(inout a: Int) -> Int {
    a -= 1
    return a
}
 
postfix func ++(inout a: Int) -> Int {
    defer { a += 1 }
    return a
}
 
postfix func –(inout a: Int) -> Int {
    defer { a -= 1 }
    return a
}
 
var a = 10
print(a++) // prints 10
print(a) // prints 11
 
var b = 10
print(–b) // prints 9
print(b) // prints 9

 


Sources et liens utiles:

 

 

Author | Imanou Petit Comments | 0 Date | 8 avril 2016

categories & tags

leave a reply

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *