[C] COMPARAISON GÉNÉRIQUE (OU COMMENT COMPARER DES ELEMENTS DU TYPE VOID * ...)

#include <stdio.h>
#include <stdlib.h>


typedef enum{TRUE = 1, FALSE = 0} tBoolean;

#define and &&


#define tElement void *


typedef struct sComparator *tComparator;
struct sComparator
{
   tBoolean (*areEqual)(tElement, tElement);
};

tComparator Comparator_allocate()
{
   return (tComparator)malloc(sizeof(struct sComparator));
}


typedef struct sInteger *tInteger;
struct sInteger
{
   int Value;
   
   tInteger (*create)(int);
   
   tComparator Comparator;   
};

tInteger Integer_allocate()
{
   return (tInteger)malloc(sizeof(struct sInteger));
}

tInteger Integer_create(int value)
{
   tInteger This = Integer_allocate();
   This -> Value = value;
   return This;   
}

tBoolean Integer_areEqual(tElement a, tElement b)
{
   tInteger i = (tInteger)a;
   tInteger j = (tInteger)b;
   
   return (i -> Value) == (j -> Value);
}

tInteger Integer;

void createIntegerType(void)
{
   Integer = Integer_allocate();
   Integer -> create = Integer_create;
   tComparator comparator = Comparator_allocate();
   comparator -> areEqual = Integer_areEqual;
   Integer -> Comparator = comparator;
}


typedef struct sComplex *tComplex;
struct sComplex
{
   float RealPart;
   float ImaginaryPart;
   
   tComplex (*create)(float, float);
   
   tComparator Comparator;
};

tComplex Complex_allocate()
{
   return (tComplex)malloc(sizeof(struct sComplex));   
}

tComplex Complex_create(float real_part, float imaginary_part)
{
   tComplex This = Complex_allocate();
   This -> RealPart = real_part;
   This -> ImaginaryPart = imaginary_part;
   return This;
}

tBoolean Complex_areEqual(tElement a, tElement b)
{
   tComplex x = (tComplex)a;
   tComplex y = (tComplex)b;
   
   return ((x -> RealPart) == (y -> RealPart)) and ((x -> ImaginaryPart) == (y -> ImaginaryPart));
}

tComplex Complex;

createComplexType()
{
   Complex = Complex_allocate();
   tComparator comparator = Comparator_allocate();
   Complex -> create = Complex_create;
   comparator -> areEqual = Complex_areEqual;
   Complex -> Comparator = comparator;
}


tBoolean areEqual(tElement a, tElement b, tComparator comparator)
{
   return comparator -> areEqual(a, b);
}

int main(void)
{
   createIntegerType();
   createComplexType();
   
   tInteger i = Integer -> create(4);
   tInteger j = Integer -> create(4);
   
   tComplex x = Complex -> create(1, 1);
   tComplex y = Complex -> create(1, 1);
   
   tBoolean b;
   
   b = areEqual(i, j, Integer -> Comparator);
   if(b) printf("Oui ! Ces 2 entiers sont egaux ! \n");
   
   b = areEqual(x, y, Complex -> Comparator);
   if(b) printf("Oui ! Cest 2 complexes sont egaux ! \n");
   
   system("PAUSE");
   return 0;   
}