Home / Questions / 449221
Accepted
Iván Rodríguez
Asked: 2022-05-04 16:42:48 +0800 CST 2022-05-04 16:42:48 +0800 CST

How to overload operators correctly in C#?

  • 772

I am trying to do operator overloading on a class. I was guided by the example that Microsoft gives on its page.

Operator overloading (C# reference)

But I'm getting some errors and I don't know how to fix it:

DataObject.cs(8,49): Error CS1002: Expected ; DataObject.cs(8,57): Error CS1519: The token '+' is invalid in a class, struct, or interface member declaration DataObject.cs(8,65): Error CS1519: The token ';' is not valid in a class, struct, or interface member declaration

This is my code:

//-------------------------------------------------- 

public class DataObject<T> 
{
    private T data;
    public static DataObject<T> operator +(DataObject<T> b) => data + b.data;
}

//-------------------------------------------------- 

public class Int : DataObject<int>
{ 

}

//-------------------------------------------------- 

public class Calcula
{
    public Int Suma(Int a, Int b)
    {
        return a + b;
    }

    public void Suma(Int a, Int b, Int result)
    {
        result = a + b;
    }
}

//-------------------------------------------------- 

public class EntryPoint
{
    static void Main()
    {
        Int a = new Int();
        Int b = new Int();
        Int result = new Int();

        Calcula calcula = new Calcula();

        a = 5;
        b = 7;

        calcula.Suma(a, b, result);
        Console.Write("\n result=" + result);


        a = 3;
        b = 6;

        result = calcula.Suma(a, b);
        Console.Write("\n result=" + result);        

    }
}

Could someone tell me how to do this correctly? Thank you so much!!

c#

2 Answers

  1. Best Answer

    You could try something like what I'll show you below.

    The key is to use methods that return references. Here the official documentation doc

    public class Creator
{
   public ref CustomInt Create(ref CustomInt i)
      => ref i;

   public CustomInt Create(int i)
      => new CustomInt { Data = i };               
}

public class Operator
{
   public ref CustomInt Sum(ref CustomInt i, params CustomInt[] ints)
   {
      foreach (var item in ints)
      {
         i.Data += item.Data;
      }
            
      return ref i;
   }

   public ref CustomInt Sum(ref CustomInt i, params int[] ints)
   {
      foreach (var item in ints)
      {
         i.Data += item;
      }
            
      return ref i;
    }
}

public class CustomInt
{
    private static readonly Creator _creator = new Creator();
    public static readonly Operator Operator = new Operator();

    public int Data { get; set; }

    public static implicit operator int(CustomInt d)
       => _creator.Create(ref d);

    public static implicit operator CustomInt(int d)
       => _creator.Create(d);

    public static CustomInt operator +(CustomInt a, CustomInt b)
       => Operator.Sum(ref a, b);

    public static CustomInt operator +(CustomInt a, int b)
       => Operator.Sum(ref a, b);

    public override string ToString()
       => Data.ToString();

    public void Clear()
       => this.Data = 0;
}

    And here you have the Main method, where different Tests are carried out and, it seems, it fulfills what you want:

    static void Main(string[] args)
{
   // Declaracion de variables
   CustomInt ciSumando_1;
   CustomInt ciSumando_2;
   CustomInt ciResult;
   CustomInt ciResultRef;
   int intSumando_1;
   int intSumando_2;
   int intSumandi_1_Ref;

   // Asignacion de valores
   ciResult = new CustomInt();
   ciResultRef = ciResult;
   ciSumando_1 = 5;
   ciSumando_2 = 7;
   intSumando_1 = 1;
   intSumando_2 = 2;
   intSumandi_1_Ref = intSumando_1;

   // Prueba de referencia entre int's
   Console.WriteLine("[Test Referencias - ints] :  " + Object.ReferenceEquals(intSumando_1, intSumandi_1_Ref));
   Console.WriteLine("");

   // Suma de CustomInts utilizando Operator para CustomInt e ints y pruba de referencia entre CustomInts ... (1)
   ciResult.Clear();
   int initialResultValue = ciResult.Data;
   ciResult = CustomInt.Operator.Sum(ref ciResult, ciSumando_1, ciSumando_2);
   Console.WriteLine($"Operation: {initialResultValue} + {ciSumando_1} + {ciSumando_2} = {ciResult}");
   Console.WriteLine("[Test Referencias - Operator(CustomInt, CustomInt, CustomInt)] :   " + Object.ReferenceEquals(ciResultRef, ciResult));
   Console.WriteLine("");

   // Cambio de valores CustomInts
   ciSumando_1 = 3;
   ciSumando_2 = 6;

   // Misma prueba que (1)
   ciResult.Clear();
   initialResultValue = ciResult.Data;
   ciResult = CustomInt.Operator.Sum(ref ciResult, ciSumando_1, ciSumando_2);
   Console.WriteLine($"Operation: {initialResultValue} + {ciSumando_1} + {ciSumando_2} = {ciResult}");
   Console.WriteLine("[Test Referencias - Operator(CustomInt, CustomInt, CustomInt) - Previa reasignacion de valores a operandos] : " + Object.ReferenceEquals(ciResultRef, ciResult));
   Console.WriteLine("");

   //  Suma de CustomInt e ints utilizando Operator y pruba de referencia entre CustomInts ... (@)
   ciResult.Clear();
   initialResultValue = ciResult.Data;
   ciResult = CustomInt.Operator.Sum(ref ciResult, intSumando_1, intSumando_2);
   Console.WriteLine($"Operation: {initialResultValue} + {intSumando_1} + {intSumando_2} = {ciResult}");
   Console.WriteLine("[Test Referencias - Operator(CustomInt, int, int)] :" + Object.ReferenceEquals(ciResultRef, ciResult));
   Console.WriteLine("");

   // Suma de CustomInts utilizando operador +
   ciResult.Clear();
   initialResultValue = ciResult.Data;
   ciResult += ciSumando_1;
   ciResult += ciSumando_2;
   Console.WriteLine($"Operation: {initialResultValue} + {ciSumando_1} + {ciSumando_2} = {ciResult}");
   Console.WriteLine("[Test Referencias - +(CustomInt, CustomInt, CustomInt)] : " + Object.ReferenceEquals(ciResultRef, ciResult));
   Console.WriteLine("");

   // Suma de ints y CustomInts utilizando operador +
   ciResult.Clear();
   initialResultValue = ciResult.Data;
   ciResult += intSumando_1;
   ciResult += intSumando_2;
   Console.WriteLine($"Operation: {initialResultValue} + {intSumando_1} + {intSumando_2} = {ciResult}");
   Console.WriteLine("[Test Referencias - +(CustomInt, int, int)] : " + Object.ReferenceEquals(ciResultRef, ciResult));
   Console.WriteLine("");
}

    Don't forget to add validations to the methods of the Operator class.

    • 1

  2. At the moment I have reached this solution... but I don't like it because I lose the instances of the original objects and I would like to keep them... If someone knows how to do the same but keeping the instances and puts his answer here I will accept it.

    NOTE: I don't use a static instance because if not I can only declare a single object.

    //-------------------------------------------------- 


using System.Collections.Generic;

using System;

//-------------------------------------------------- 


public class Int
{
    private Int instance;
    private int data;

    public Int()
    {
        instance = this;
    }

    public static implicit operator int(Int d)
    {
        return d.data;
    }
    
    public static implicit operator Int(int d)
    {
        return new Int { data = d };
    }

    public static Int operator +(Int a, Int b)
    {
        //return new Int { data = a.data + b.data };
        a.data = a.data + b.data;
        return a;
    }

    public override string ToString()
    {
        return data.ToString();
    }

    public static Int operator +(Int a, int b)
    {
        //return new Int { data = a.data + b };
        a.data = a.data + b;
        return a;
    }
}

//-------------------------------------------------- 


public class Calcula
{
    
    public Int Suma(Int a, Int b)
    {
        return a + b;
    }
    
    public void Suma(Int a, Int b, out Int result)
    {
        result = (a + b);
    }
}

//-------------------------------------------------- 


public class EntryPoint
{
    static void Main()
    {
        Int a = new Int();
        Int b = new Int();
        Int result = new Int();
        Int resultRef = result;


        Console.Write("\n " + Object.ReferenceEquals(resultRef, result));

        Calcula calcula = new Calcula();

        a = 5;
        b = 7;

        calcula.Suma(a, b, out result);
        Console.Write("\n result=" + result);

        a = 3;
        b = 6;

        result = calcula.Suma(a, b);
        Console.Write("\n result=" + result);


        Console.Write("\n " + Object.ReferenceEquals(resultRef, result));

    }
}

//-------------------------------------------------- 

//C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe DataObject.cs

//--------------------------------------------------

    Program output:

    True
    result=12
    result=9
    False

    Thank you very much!!

    • 0