SURCHARGE D'OPÉRATEURS : TUTORIAL

Below or in the zip

// project created on 27/11/2002 at 16:55
using System;

class MainClass
{
	public static void Main(string[] args)
	{
		ClpComplexe C1 = new ClpComplexe();
		ClpComplexe C2 = new ClpComplexe(5,3);
				
		C1.Reel = 2;
		C1.Imaginaire = -4;		
		Console.Out.WriteLine("C1: " + C1.Reel + "+" + C1.Imaginaire + "j");
		Console.Out.WriteLine("C2: " + C2.Reel + "+" + C2.Imaginaire + "j\n");
				
		//Opération possible grâce à la surcharge de l'opérateur +
		//ClpComplexe + ClpComplexe
		ClpComplexe C3 = C1 + C2;
		
		Console.Out.WriteLine("Old C1: " + C1.Reel + "+" + C1.Imaginaire + "j");
		
		//ClpComplexe + ClpComplexe
		C1 = C2 + C3;
		//ClpComplexe * ClpComplexe
		ClpComplexe C4 = C2 * C3;
		//ClpComplexe - Complexe où Complexe est un ClpComplexe déterminé par (int * ClpComplexe)
		C4 = C4 - (2 * C1);
		//Idem mais avec inversion des arguments
		//ClpComplexe - Complexe où Complexe est un ClpComplexe déterminé par (ClpComplexe * int)
		C4 = C4 - (C1 * 2);
		
		Console.Out.WriteLine("C1: " + C1.Reel + "+" + C1.Imaginaire + "j");
		Console.Out.WriteLine("C2: " + C2.Reel + "+" + C2.Imaginaire + "j");
		Console.Out.WriteLine("C3: " + C3.Reel + "+" + C3.Imaginaire + "j");
		Console.Out.WriteLine("C4: " + C4.Reel + "+" + C4.Imaginaire + "j");
	}
}

class ClpComplexe
{
	private int iReel;
	private int iImaginaire;	
	
	//Constructeur par défaut
	public ClpComplexe()
	{
		this.iReel = 0;
		this.iImaginaire = 0;		
	}
	
	//Constructeur avec deux arguments
	public ClpComplexe(int iReel, int iImaginaire)
	{
		this.iReel = iReel;
		this.iImaginaire = iImaginaire;
	}
	
	//Propriété Reel
	public int Reel
	{
		get
		{
			return this.iReel;
		}
		set
		{
			this.iReel = value;
		}		
	}
	
	//Propriété Imaginaire
	public int Imaginaire
	{
		get
		{
			return this.iImaginaire;
		}
		set
		{
			this.iImaginaire = value;
		}		
	}
	
	//Surcharge de l'opérateur + pour pouvoir additionner deux nombres complexes
	public static ClpComplexe operator +(ClpComplexe C1, ClpComplexe C2)
	{
		return new ClpComplexe(C1.Reel + C2.Reel, C1.Imaginaire + C2.Imaginaire);
	}
	
	//Surcharge de l'opérateur - pour pouvoir soustriare deux nombres complexes
	public static ClpComplexe operator -(ClpComplexe C1, ClpComplexe C2)
	{
		return new ClpComplexe(C1.Reel - C2.Reel, C1.Imaginaire - C2.Imaginaire);
	}
	
	//Surcharge de l'opérateur * pour pouvoir multiplier deux nombres complexes
	public static ClpComplexe operator *(ClpComplexe C1, ClpComplexe C2)
	{
		return new ClpComplexe((C1.Reel * C2.Reel - C1.Imaginaire * C2.Imaginaire),
		                       (C1.Reel * C2.Imaginaire - C2.Reel * C1.Imaginaire));
	}
	
	//Surcharge de l'opérateur * pour pouvoir multiplier par iMultiple un nombre complexe
	public static ClpComplexe operator *(int iMultiple, ClpComplexe C1)
	{
		return new ClpComplexe((iMultiple * C1.Reel), (iMultiple * C1.Imaginaire));
	}
	
	//Surcharge de l'opérateur * pour pouvoir multiplier par iMultiple un nombre complexe
	public static ClpComplexe operator *(ClpComplexe C1, int iMultiple)
	{
		return new ClpComplexe((iMultiple * C1.Reel), (iMultiple * C1.Imaginaire));
	}
}