pointeur de fonction et pointeur générique pour liste chainée générique

Bonjour à tous, voila j'ai un problème, je dois faire un tp sur les liste chainée générique mais je n'y arrive pas. Il faut que je transforme le fichier element.c

Code:

1
2
3
4
5
6
7
#include <cstdio> 
#include "element.H"
 
void afficheElement(const Element & e)
{
  std::printf("%d ",e);
}

et element.h

Code:

1
2
3
4
5
6
7
8
#ifndef _ELEMENT
#define _ELEMENT
 
typedef int Element;
 
void afficheElement(const Element & e);
 
#endif

en mettant definissant Element de la manière suivante : typedef void * Element et en prévoyant des fonction d'initialisation, d'affectation et de testament
voila ce que j'ai fait: element.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#ifndef _ELEMENT
#define _ELEMENT
 
typedef void * Element;
 
void afficheElement(Element& e, void (*affiche)(Element &));
void compareElt(Element e,Element b,void(*compare)(Element ,Element));
 
 
int * initialisationInt(Element & a,Element b);
void affichageInt(Element & e);
void affectationInt ( Element & a,Element b);
void testamentInt (Element & e);
void compareInt(Element a,Element b);
 
double * initialisationDouble (Element & a, double b);
void affichageDouble (Element & e);
void affectationDouble ( Element & a,Element b);
void testamentDouble (Element & e);
void compareDouble(Element a,Element b);
 
 
 
 
#endif

et element.c

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include <iostream>
#include <stdio.h>
#include "element.h"
using namespace std;
 
void afficheElement(Element & e,void(*affiche)(Element &))
{
     affiche(e);
}
 
 
int * initialisationInt(Element & a, Element b)
{
       a= new (int*); 
       a= b;
       return a;
 
}
 
double* initialisationDouble (Element & a,double b)
{
     a= new (double*); 
     *(reinterpret_cast<double*>(a))=b;
 
 
}    
 
 
void affectationInt ( Element & a,Element b)
{
 
     if (a!=b)
     {
              *(reinterpret_cast<int*>(a)) = *(reinterpret_cast<int*>(b)) ;
     }
}
void affectationDouble ( Element & a,Element b)
{
 
     if (a!=b)
     {
              *(reinterpret_cast<double*>(a)) = *(reinterpret_cast<double*>(b)) ;
     }
}
void affichageInt(Element & e)
{
      printf("%d", *(reinterpret_cast<int*>(e)));     
}
 
void affichageDouble (Element & e)
{
     printf("%f",*(reinterpret_cast<double*>(e)));
}
 
void compareInt(Element a,Element b)
{
     if (*(reinterpret_cast<int*>(b)) < *(reinterpret_cast<int*>(a)))
    {cout<<"le plus petit est"<< *(reinterpret_cast<int*>(b));}
    else cout<<"le plus petit est"<< *(reinterpret_cast<int*>(a));
}
 
void compareDouble(Element a,Element b)
{
    if (*(reinterpret_cast<double*>(a)) > *(reinterpret_cast<double*>(b)))
    cout<<"le plus petit est"<< *(reinterpret_cast<double*>(b));
    else cout<<"le plus petit est"<< *(reinterpret_cast<double*>(a));
}
 
void compareElt(Element e,Element b,void(*compare)(Element ,Element))
{
     compare(e,b);
}
 
void testamentInt (Element & e)
{
     delete reinterpret_cast<int*>(e);
}
 
void testamentDouble (Element & e)
{
     delete reinterpret_cast<double*>(e);
}

Je voulais savoir si c'était bon et si il fallait initialiser comme ma fonction initialiseDouble ou comme ma fonction initialiseInt?
Voila merci

std::printf ? J'ai jamais vu...
Tu fais du C ou du C++ ?
Si tu fais du C comme semble l'indiqué l'extension de tes fichiers alors les operateurs new, delete, rein... ne fonctionneront pas... les references non plus d'ailleurs...
De plus on écrit new int et non pas new int* car dans ton cas tu alloue une case pointeur qui est de la même taille pour n'importe quel type...
Un peu chaotique tout ca ^^

Merci de m'avoir répondu, je sais que c'est confus mais c'est parceque je ne comprends pas donc j'essais un peu tout:)
donc ma fonction

Code:

1
2
3
4
5
6
7
int * initialisationInt(Element & a, Element b)
{
       a= new (int*); 
       a= b;
       return a;
 
}

avec element.h

Code:

1
2
3
4
5
6
7
8
9
10
11
#ifndef _ELEMENT
#define _ELEMENT
 
typedef void * Element;
 
void afficheElement(Element& e, void (*affiche)(Element &));
void compareElt(Element e,Element b,void(*compare)(Element ,Element));
 
 
void initialisationInt(Element & a,Element b);
//b initialisé de type effectif int ou b adresse d'une variable de type int

devrait plutôt s'écrire

Code:

1
2
3
4
5
6
void  initialisationInt(Element & a, Element b)
//je sais pas pourquoi j'ai mis int, c'est censé être void Initialisation
{
       a= new (int); 
       a= b;
}

ou

Code:

1
2
3
4
5
void  initialisationInt(Element & a, Element b)
{
       a= new (int); 
     *(reinterpret_cast<int*>(a))=b;
}

Qu'est-elle supposée faire EXACTEMENT, ta fonction?

Générique en C++, généralement, ça veut dire templates, pas void*...