Surcharge d'opérateurs en

À propos de Surcharge d'opérateurs

Les principaux opérateurs arithmétiques et de comparaison peuvent être adaptés pour être utilisés par vos propres classes et structures. C'est ce qu'on appelle la surcharge d'opérateurs.

Cet article traite en détail de la syntaxe, ainsi que des opérateurs qui peuvent être surchargés et de ceux qui ne le peuvent pas.

La plupart des opérateurs ont la forme suivante :

static <return type> operaator <operator symbols>(<parameters>);

Les opérateurs de conversion ont la forme suivante :

static (explicit|implicit) operator <cast-to-type>(<cast-from-type> <parameter name>);

Les opérateurs se comportent de la même manière que les méthodes statiques.

• Un symbole d'opérateur remplace l'identifiant d'une méthode, et ils prennent des paramètres et un type de retour. Les règles de type pour les paramètres et le type de retour suivent ton intuition, et tu peux compter sur le compilateur pour te fournir des indications détaillées.
• Pour les opérations binaires, le premier paramètre prend l'argument de gauche de l'opération.
• La signature d'un opérateur comprend deux paramètres (dans le cas des opérations binaires) et un type de retour, ou bien un seul paramètre et un type de retour dans le cas des opérateurs unaires.
• Pour les opérateurs binaires, l'un des types de paramètre doit être celui de la classe qui déclare l'opérateur.
• Dans le cas des conversions de type, le paramètre ou le type de retour doit être le type de la classe qui déclare l'opérateur.
• Pour les opérateurs d'incrémentation et de décrémentation, le paramètre et le type de retour doivent être ceux de la classe qui déclare l'opérateur.

Exemples de syntaxe :

struct Point
{
    decimal x;
    decimal y;

    public static bool operator ==(Point pt, Point ptOther)
    {
        return pt.x == ptOther.x && pt.y == ptOther.y;
    }

    public static bool operator !=(Point pt, Point ptOther)
    {
        return !(pt == ptOther);
    }

    public static Point operator *(Point pt, decimal scale)
    {
        var ptNew = new Point();
        ptNew.x = pt.x * scale;
        ptNew.y = pt.y * scale;
        return ptNew;
    }

    public static implicit operator Point((decimal x, decimal y) xy)
    {
        var pt = new Point();
        pt.x = xy.x;
        pt.y = xy.y;
        return pt;
    }

    public static explicit operator (decimal x, decimal y)(Point pt)
    {
        return (pt.x, pt.y);
    }
}

Il est souvent judicieux d'implémenter une méthode Equals() et de l'appeler depuis l'opérateur ==. De même, pour les comparaisons, tu peux implémenter l'interface IComparable. Dans les deux cas, tu fais d'une pierre deux coups, avec à peine plus d'une pierre.

Note que tu ne peux pas créer d'opérateurs à partir de symboles qui ne font pas partie de l'ensemble standard des opérateurs. Tu ne peux utiliser que des symboles existants, et uniquement pour les opérations dont la documentation précise qu'elles peuvent être surchargées. La liste des opérateurs qui peuvent être surchargés se trouve ici.

Note que l'ordre des paramètres est important lorsqu'ils sont de types différents. Dans l'exemple de code ci-dessus, pt * 10m est une expression valide, alors que 10m * pt ne compilera pas.

Références

Cette documentation sur la surcharge d'opérateurs détaille la syntaxe.