IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Kotlin Discussion :

Surcharge d'opérateurs et ambiguïté


Sujet :

Kotlin

  1. #1
    Membre éprouvé
    Profil pro
    Inscrit en
    juin 2008
    Messages
    595
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : juin 2008
    Messages : 595
    Points : 1 027
    Points
    1 027
    Par défaut Surcharge d'opérateurs et ambiguïté
    Bonjour,

    En voulant surcharger les opérateurs "+" et +=" (plus et plusAssign) j'obtiens à l'utilisation de ces opérateurs une erreur d'ambiguïté.
    La doc renseigne que si l'opérateur plus est disponible on obtient une ambiguïté si on cherche à utiliser plusAssign.

    Je trouve ça particulièrement curieux, la syntaxe n'est pourtant pas la même: Le compilateur est dans la choucroute?
    On a pourtant pour les types de base les deux opérateurs disponibles simultanément:
    A = A+B
    A+= B

    Et dans ma classe "X", je ne peux donc pas écrire:

    X1 + X2
    X1 += X2

    Je dois choisir une des deux syntaxes mais pas les deux, et donc je ne peux surcharger qu'un seul opérateur

    Quelqu'un peut-il me donner la raison de cette restriction, et un éventuel moyen de la contourner?

    Merci,
    Claude

  2. #2
    Membre averti
    Profil pro
    professeur des universités à la retraite
    Inscrit en
    août 2008
    Messages
    364
    Détails du profil
    Informations personnelles :
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : professeur des universités à la retraite

    Informations forums :
    Inscription : août 2008
    Messages : 364
    Points : 435
    Points
    435
    Par défaut
    On dirait bien que tu as mis le doigt sur quelque chose.
    Le problème est abordé dans Kotlin in action (le livre rédigé par des chercheurs de JetBrains, l'entreprise qui est à l'origine de Kotlin), chapitre 7, paragraphe 7.1.2
    L'idée semble être ceci : de deux choses l'une, ou bien ta classe est immutable (ce qui est le cas recommandé en Kotlin) et dans ce cas il est impossible de modifier une instance de la classe et donc d'utiliser un opérateur +=,
    ou bien elle ne l'est pas et dans ce cas on considère qu'il est plus clair d'utiliser seulement +=.

    Par exemple un script Kotlin comme ceci :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class MyClass(var num: Int) {
     
        operator fun plus(other: MyClass): MyClass = MyClass(this.num + other.num)
     
        operator fun plusAssign(other: MyClass): Unit {
            this.num = this.num + other.num
        }
    }
     
    val five = MyClass(5)
    var initiallyOne = MyClass(1)
    initiallyOne += five
    println(initiallyOne.num)
    Donne un message d'erreur :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    Overload.kts:14:14: error: assignment operators ambiguity: 
    public final operator fun plus(other: Overload.MyClass): Overload.MyClass defined in Overload.MyClass
    public final operator fun plusAssign(other: Overload.MyClass): Unit defined in Overload.MyClass
    initiallyOne += five
    Tandis que si on supprime le 'plus' tout va bien :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class MyClass(var num: Int) {
     
        operator fun plusAssign(other: MyClass): Unit {
            this.num = this.num + other.num
        }
    }
     
    val five = MyClass(5)
    var initiallyOne = MyClass(1)
    initiallyOne += five
    println(initiallyOne.num) // 6
    EDIT On trouve aussi une brève indication là-dessus dans la documentation officielle : https://kotlinlang.org/docs/reference/operator-overloading.html#assignments

  3. #3
    Membre éprouvé
    Profil pro
    Inscrit en
    juin 2008
    Messages
    595
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : juin 2008
    Messages : 595
    Points : 1 027
    Points
    1 027
    Par défaut
    Merci pour l'info.

    Claude

  4. #4
    Membre éprouvé
    Profil pro
    Inscrit en
    juin 2008
    Messages
    595
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : juin 2008
    Messages : 595
    Points : 1 027
    Points
    1 027
    Par défaut
    Juste pour info: Maintenant (en mars 2020), ça semble avoir été corrigé, j'utilise les deux sans problème.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [C#] Tri d'objet et surcharge d'opérateur
    Par Royd938 dans le forum Windows Forms
    Réponses: 6
    Dernier message: 17/12/2007, 00h26
  2. Petit probléme de surcharge d'opérateur .
    Par Clad3 dans le forum C++
    Réponses: 20
    Dernier message: 11/04/2005, 20h15
  3. Problème de surcharge d'opérateurs
    Par Hell dans le forum C++
    Réponses: 17
    Dernier message: 17/01/2005, 16h01
  4. Cumul de surcharges d'opérateurs
    Par Nats dans le forum C++
    Réponses: 2
    Dernier message: 11/10/2004, 13h37
  5. [VB .NET] Surcharge d'opérateur
    Par Franckintosh dans le forum VB.NET
    Réponses: 2
    Dernier message: 07/09/2004, 19h05

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo