0Pricing
C# Academy · Lección

Sobrecarga de operadores aritméticos

Defina +, -, * para sus propios tipos.

Sobrecarga de operadores aritméticos es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

¿Por qué sobrecargar los operadores aritméticos?

La sobrecarga de operadores permite que sus propios tipos utilicen símbolos conocidos como +, - y *. En tipos que representan valores, como vectores, dinero o números complejos, esto hace que el código se lea como matemáticas en lugar de como llamadas a métodos.

La sintaxis de operator +

Un operador sobrecargado se declara como un método public static cuyo nombre es operator seguido del símbolo. Al menos uno de los parámetros debe ser del tipo contenedor.

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);
    }
}

Resta y multiplicación

Puede sobrecargar varios operadores en el mismo tipo. Aquí añadimos la resta y la multiplicación por un escalar a nuestro vector.

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);
    }
}

Los operadores siempre son static

Los operadores sobrecargados deben ser static. No actúan sobre un this oculto; en su lugar, los operandos se pasan como parámetros explícitos. El compilador asigna el símbolo al método.

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);
    }
}

Operadores unarios

Los operadores unarios, como la negación, reciben un solo operando. Sobrecargue operator - con un parámetro para admitir expresiones como -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));
    }
}

Operandos de tipos mixtos

Uno de los operandos puede ser de un tipo diferente. Proporcionar ambos órdenes permite a los usuarios escribir la expresión de forma natural en cualquiera de los sentidos.

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));
    }
}

Devolver valores nuevos

Los operadores aritméticos no deben modificar sus operandos. Calculan y devuelven un valor new, y dejan los valores originales sin cambios, igual que 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);
    }
}

Encadenar operaciones aritméticas

Como cada operador devuelve el mismo tipo, las expresiones se encadenan de forma natural y respetan la precedencia y la asociatividad habituales.

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);
    }
}

Operadores en clases

La sobrecarga de operadores también funciona en clases, no solo en estructuras. Tenga cuidado con null: un operando de clase podría ser null, por lo que debe comprobarlo si es necesario.

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 tipo numérico completo

Aquí tiene un pequeño tipo de fracción con suma. Muestra cómo la sobrecarga convierte un tipo de dominio en algo que se comporta como un número integrado.

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));
    }
}

Pruébelo usted mismo

Añada suma y multiplicación por un escalar a una estructura similar al dinero y, después, construya una expresión que se lea como una operación aritmética normal.

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);
    }
}

Comprobación rápida

Recuerde la signatura de un operador sobrecargado.

Resumen

La sobrecarga de operadores aritméticos hace que los tipos que representan valores se lean como matemáticas.

  • Declárelos como public static con la palabra clave operator.
  • Al menos uno de los parámetros debe ser del tipo contenedor.
  • Devuelva un valor nuevo; nunca modifique los operandos.
  • Proporcione ambos órdenes de operandos para la aritmética de tipos mixtos.

Preguntas frecuentes

¿La lección «Sobrecarga de operadores aritméticos» es gratis?

Sí — el texto completo de «Sobrecarga de operadores aritméticos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Sobrecarga de operadores aritméticos»?

Defina +, -, * para sus propios tipos. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Sobrecarga de operadores aritméticos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Sobrecarga de operadores aritméticos
  2. Sobrecarga de operadores de comparación
  3. Conversiones definidas por el usuario
  4. Prácticas recomendadas para sobrecargar operadores
← Volver a C# Academy