C# Academy · Leçon

Surcharge des opérateurs arithmétiques

Définissez +, - et * pour vos propres types.

Surcharge des opérateurs arithmétiques est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Pourquoi surcharger les opérateurs arithmétiques ?

La surcharge des opérateurs permet à vos propres types d’utiliser des symboles familiers comme +, - et *. Pour les types assimilables à des valeurs, tels que les vecteurs, l’argent ou les nombres complexes, le code se lit ainsi comme des mathématiques plutôt que comme une suite d’appels de méthodes.

Syntaxe de l’opérateur +

Un opérateur surchargé est déclaré comme une méthode public static dont le nom est operator suivi du symbole. Au moins un paramètre doit être du type qui le contient.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }

    public static Vector2 operator +(Vector2 a, Vector2 b)
        => new Vector2(a.X + b.X, a.Y + b.Y);

    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var sum = new Vector2(1, 2) + new Vector2(3, 4);
        Console.WriteLine(sum);
    }
}

Soustraction et multiplication

Vous pouvez surcharger plusieurs opérateurs sur un même type. Ici, nous ajoutons la soustraction et la multiplication par un scalaire à notre vecteur.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }

    public static Vector2 operator -(Vector2 a, Vector2 b)
        => new Vector2(a.X - b.X, a.Y - b.Y);
    public static Vector2 operator *(Vector2 a, int k)
        => new Vector2(a.X * k, a.Y * k);

    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var v = new Vector2(5, 6) - new Vector2(2, 1);
        Console.WriteLine(v);
        Console.WriteLine(new Vector2(2, 3) * 4);
    }
}

Les opérateurs sont toujours statiques

Les opérateurs surchargés doivent être static. Ils ne s’appliquent pas à un this implicite ; les opérandes sont transmis en tant que paramètres explicites. Le compilateur associe le symbole à la méthode.

using System;

public struct Money
{
    public decimal Amount;
    public Money(decimal amount) { Amount = amount; }

    public static Money operator +(Money a, Money b)
        => new Money(a.Amount + b.Amount);

    public override string ToString() => "$" + Amount;
}

public class Program
{
    public static void Main()
    {
        var total = new Money(10.5m) + new Money(4.25m);
        Console.WriteLine(total);
    }
}

Opérateurs unaires

Les opérateurs unaires, comme la négation, prennent un seul opérande. Surchargez operator - avec un paramètre pour prendre en charge des expressions telles que -v.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }

    public static Vector2 operator -(Vector2 a)
        => new Vector2(-a.X, -a.Y);

    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(-new Vector2(3, -7));
    }
}

Opérandes de types mixtes

Un opérande peut être d’un type différent. Fournir les deux ordres permet aux utilisateurs d’écrire naturellement l’expression dans les deux sens.

using System;

public struct Temperature
{
    public double Celsius;
    public Temperature(double c) { Celsius = c; }

    public static Temperature operator +(Temperature t, double delta)
        => new Temperature(t.Celsius + delta);
    public static Temperature operator +(double delta, Temperature t)
        => new Temperature(t.Celsius + delta);

    public override string ToString() => Celsius + "C";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Temperature(20) + 5);
        Console.WriteLine(5 + new Temperature(20));
    }
}

Renvoyer de nouvelles valeurs

Les opérateurs arithmétiques ne doivent pas modifier leurs opérandes. Ils calculent et renvoient une nouvelle valeur, en laissant les valeurs d’origine inchangées, comme le fait int.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    public static Vector2 operator +(Vector2 a, Vector2 b)
        => new Vector2(a.X + b.X, a.Y + b.Y);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var a = new Vector2(1, 1);
        var b = new Vector2(2, 2);
        var c = a + b;
        Console.WriteLine("a unchanged: " + a);
        Console.WriteLine("result: " + c);
    }
}

Enchaîner les opérations arithmétiques

Comme chaque opérateur renvoie le même type, les expressions s’enchaînent naturellement et respectent la priorité et l’associativité habituelles.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    public static Vector2 operator +(Vector2 a, Vector2 b) => new Vector2(a.X + b.X, a.Y + b.Y);
    public static Vector2 operator *(Vector2 a, int k) => new Vector2(a.X * k, a.Y * k);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var result = new Vector2(1, 1) + new Vector2(2, 2) * 3;
        Console.WriteLine(result);
    }
}

Opérateurs sur les classes

La surcharge des opérateurs fonctionne également avec les classes, et pas seulement avec les structures. Faites attention à null : un opérande de type classe peut être nul ; ajoutez donc une protection si nécessaire.

using System;

public class Complex
{
    public double Re, Im;
    public Complex(double re, double im) { Re = re; Im = im; }
    public static Complex operator +(Complex a, Complex b)
        => new Complex(a.Re + b.Re, a.Im + b.Im);
    public override string ToString() => Re + " + " + Im + "i";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Complex(1, 2) + new Complex(3, 4));
    }
}

Un type numérique complet

Voici un petit type représentant une fraction, avec l’addition. Il montre comment la surcharge transforme un type métier en un type qui se comporte comme un nombre intégré au langage.

using System;

public struct Fraction
{
    public int Num, Den;
    public Fraction(int num, int den) { Num = num; Den = den; }

    public static Fraction operator +(Fraction a, Fraction b)
        => new Fraction(a.Num * b.Den + b.Num * a.Den, a.Den * b.Den);

    public override string ToString() => Num + "/" + Den;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Fraction(1, 2) + new Fraction(1, 3));
    }
}

Essayez par vous-même

Ajoutez l’addition et la multiplication par un scalaire à une structure représentant de l’argent, puis construisez une expression qui se lit comme une opération arithmétique ordinaire.

using System;

public struct Money
{
    public decimal Amount;
    public Money(decimal a) { Amount = a; }
    public static Money operator +(Money a, Money b) => new Money(a.Amount + b.Amount);
    public static Money operator *(Money a, int qty) => new Money(a.Amount * qty);
    public override string ToString() => "$" + Amount;
}

public class Program
{
    public static void Main()
    {
        var price = new Money(4.50m);
        var total = price * 3 + new Money(2.00m);
        Console.WriteLine(total);
    }
}

Vérification rapide

Rappelez-vous la signature d’un opérateur surchargé.

Récapitulatif

La surcharge des opérateurs arithmétiques permet aux types assimilables à des valeurs de se lire comme des expressions mathématiques.

Déclarez-les avec public static et le mot-clé operator.
Au moins un paramètre doit être du type qui le contient.
Renvoyez une nouvelle valeur ; ne modifiez jamais les opérandes.
Fournissez les deux ordres d’opérandes pour les opérations arithmétiques entre types mixtes.

Questions Fréquemment Posées

La leçon « Surcharge des opérateurs arithmétiques » est-elle gratuite ?

Oui — le texte complet de « Surcharge des opérateurs arithmétiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Surcharge des opérateurs arithmétiques » ?

Définissez +, - et * pour vos propres types. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Surcharge des opérateurs arithmétiques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Surcharge des opérateurs arithmétiques
Surcharge des opérateurs de comparaison
Conversions définies par l’utilisateur
Bonnes pratiques pour la surcharge des opérateurs

← Retour à C# Academy