Problème pointeur sur fonction static

Bonjour, en compilant avec le Common Language Runtime (CLR), j'obtiens le
message d'erreur suivant << Error 1 error C3374: can't take address of 'CB::salt' unless creating delegate instance >>
avec le code suivant
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ref class CA { public: CA (*pf) (int j); }; ref class CB { public: static CA salt(int j); }; int main(array<System::String ^> ^args) { CB b; CA a; a.pf = &CB::salt; return 0; }
Est ce que c'est normal docteur?! :oops:

Ben en fait, je ne sais même pas si on peut utiliser des pointeurs de fonction normaux avec des fonctions du CLR...

Et je ne sais pas comment marchent les delegates en C++/CLI (je ne les ai utilisés qu'en C#)...

Mais surtout, ça me parait bizarre une fonction qui retourne directement une ref class au lieu de retourner un handle vers elle...

tu devrais regarder du coté des delegate dans la faq C++/CLI http://dotnet.developpez.com/faq/cpp...whatisdelegate

Je vous donne le morceau de code du programme dans lequel j'opère et l'erreur produise avec la compilation en CLI (étant donné que j'ai converti du code C++ en C++/cli) :

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
// VERSION C++
// .h
// cpBB est une instance d'une typedef struct qui devient une ref class CBox // avec la conversion 
typedef struct cpShape{
 
	cpBB (*cacheData)(struct cpShape *shape, cpVect p, cpVect rot);
	cpBB bb;
        //...
}cpShape;
 
cpShape* cpShapeInit(cpShape *shape, cpShapeType type, cpBody *body);
cpBB cpShapeCacheBB(cpShape *shape);
 
typedef struct cpCircleShape{
	cpShape shape;
	// ...
}cpCircleShape; 
 
cpCircleShape *cpCircleShapeInit(cpCircleShape *circle, cpBody *body, cpFloat radius, cpVect offset);
cpBB cpCircleShapeCacheData(cpShape *shape, cpVect p, cpVect rot);
 
// .cpp
cpShape*
cpShapeInit(cpShape *shape, cpShapeType type, cpBody *body)
{
        //...
	cpShapeCacheBB(shape);
 
	return shape;
}
 
cpBB
cpShapeCacheBB(cpShape *shape)
{
	cpBody *body = shape->body;
 
	shape->bb = shape->cacheData(shape, body->p, body->rot);
	return shape->bb;
}
 
cpCircleShape *
cpCircleShapeInit(cpCircleShape *circle, cpBody *body, cpFloat radius, cpVect offset)
{
	circle->shape.cacheData = &cpCircleShapeCacheData;
        cpShapeInit((cpShape *)circle, CP_CIRCLE_SHAPE, body);
        //...
	return circle;
}
 
static cpBB
cpCircleShapeCacheData(cpShape *shape, cpVect p, cpVect rot)
{
	cpCircleShape *circle = (cpCircleShape *)shape;
 
	circle->tc = cpvadd(p, cpvrotate(circle->c, rot));
	return bbFromCircle(circle->tc, circle->r); // retourne instance cpBB
}
 
// VERSION C++/CLI
// .h
public ref class CShape
{
public: 
          CShape(ShapeType type, CBody ^body);
          //déclarations...
 
	static CBox ^cacheBox(CShape ^shape);
	CBox ^(*cacheData)(CShape ^shape, CVect ^p, CVect ^rot);		
	CBox ^CachedBox; 
};
 
 
public ref class CCircleShape
{
public:
	CCircleShape(CBody ^body, float radius, CVect ^offset);
 
        CShape ^shape;		
	CBox ^CacheData(CShape ^shape, CVect ^p, CVect ^rot); 
};
 
// .cpp
PhysicEngine::Shapes::CShape::CShape(ShapeType type, CBody ^body)
{ 
	this->cacheBox(this);
        // ...
}
 
CBox ^PhysicEngine::Shapes::CShape::cacheBox(CShape ^shape)
{
	CBody ^body = shape->body;
 
	shape->CachedBox = shape->cacheData(shape, body->p, body->rot);
	return shape->CachedBox;
}
 
 
PhysicEngine::Shapes::CCircleShape::CCircleShape(CBody ^body, float radius, CVect ^offset)
{
	this->shape->cacheData = &CCircleShape::CacheData; /* même type d'erreur que celle énoncé dans mon premier message */
	this->shape = gcnew CShape(PhysicEngine::ShapeType::CP_CIRCLE_SHAPE, body);
}
 
CBox ^PhysicEngine::Shapes::CCircleShape::CacheData(CShape ^shape, CVect ^p, CVect ^rot)
{
	CCircleShape ^circle = (CCircleShape ^) (shape); /* Le cast ne marche pas et rend un pointeur nul */
 
	circle->tc = CVect::vadd(p, CVect::vrotate(circle->c, rot));
	return BoxFromCircle(circle->tc, circle->r);
}

Vous l'aurez compris : il faut que je puisse,
d'une part pouvoir prendre l'adresse de la fonction CacheData de la classe CCircleShape dans un pointeur de fonctions situé dans CShape pour ensuite pouvoir appeler cette fonction pour l'initialisation de l'instance Shape situé dans une instance CircleShape,
et d'une autre part pouvoir faire un cast de l'instance CShape de l'instance CircleShape pour pouvoir l'initialiser en tant que CircleShape lors de l'appel du pointeur de la fonction CacheData.
Est-ce que vous seriez capable de corriger mes erreurs de conversion si ce n'est trop vous demander?
Je n'ai pas assez d'expérience en matière de langage C++/CLI pour pouvoir adapter C++ et CLI...
Un grand merci !

Solution (à partir du premier code) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
ref class CA
{
public:
	CA (*pf) (int j);
};
 
ref class CB
{
public:
	// ...
};
 
static CA fCB(int j); // on nomme la fonction comme si elle appartiennait à la classe CB (+ joli) //
 
int main(array<System::String ^> ^args)
{
	CB b;
	CA a;
	a.pf = &fCB; // On a plus de soucis du fait de la non-appartenance à une classe quelle qu'elle soit
        return 0;
}