Discussion :

[ToTo13]

Bonjour,

j'ai le petit morceau de programme suivant, dans lequel j'appelle différentes fonctions, en fonction du type à traiter. J'appelle une des fonctions SegmentInterX ou SegmentX (en fonction de mon problème), qui doit s'occuper de dispatcher le traitement à la bonne fonction (HistX, InterHistX, AvX ou FmX).

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#ifndef DILATE_H
#define DILATE_H
 
namespace mylib
{
namespace Dilate
{
 
void HistX(const UINT8 *src, const int sewidth, UINT8 *res) {...}
 
void InterHistX(const UINT8 *src, const int sewidth, UINT8 *res) {...}
 
template<typename T> void FmX(const T *src, const int sewidth, T *res) {...}
 
template<typename T> void AvX(const T *src, const int sewidth, T *res) {...}
 
 
 
template<typename T> void SegmentX(const T *src, const int sewidth, T *res)
	{
	if ( sewidth <= 13 ) AvX(src, sewidth, res) ;
	else 
		if ( std::is_same<T, UINT8>::value ) HistX(src, sewidth, res) ;
		else FmX(src, sewidth, res) ;
	}
 
template<typename T> void SegmentInterX(const T *src, const int sewidth, T *res)
	{
	if ( std::is_same<T, UINT8>::value )
		if ( sewidth <= 13 ) AvX(src, sewidth, res) ;
		else InterHistX(src, sewidth, res) ;
	else
		if ( sewidth <= 13 || channel != 1 ) AvX(src, sewidth, res) ;
		else FmX(src, sewidth, res) ;
	}
 
} // namespace Dilate
} // namespace mylib
#endif	/* DILATE_H */

Mais lorsque je compile, j'ai une "Duplicate symbols error" pour les deux fonctions InterHistX et HistX.

1. Pourquoi ?
2. Pourquoi sur ces fonctions en particulier et pas sur les deux autres ?
3. Pourquoi si je transforme ces fonctions en template (ce qui est inutile car elles ne peuvent traiter que des UINT8) ET que je fais un cast (UINT8*) lors de l'appel dans les fonctions SegmentInterX et SegmentX, alors tout fonctionne correctement ? (mais je trouve ça môche !!!)

Merci par avance !!!

[dragonjoker59]

Tes deux fonctions incriminées ne sont ni inline, ni template (donc inlinées), ni statiques (portée locale au fichier), donc pour deux fichiers .cpp incluant ton header, le compilateur va générer deux fois le code nécessaire à la fonction HistX et pareil pour la fonction InterHistX.
Au moment du link il se trouve donc avec ces 2 fonctions dupliquées, et il te le dit donc.

Plusieurs solutions: inliner tes fonctions, les rendre statiques, ou les déclarer dqns ton header et les implémenter dans un seul cpp. (je te conseille la dernière solution)

[ToTo13]

Merci pour ta réponse !

les déclarer dans ton header et les implémenter dans un seul cpp. (je te conseille la dernière solution)

J'avais essayé... mais j'ai dû faire une bêtise. Je vais retester.
J'ai pour l'instant utilisé une autre solution : déclarer les fonctions template, utiliser un static_assert à l'intérieur de la fonction et un cast dans la fonction qui appelle. C'est un peu moche, mais c'est la seule chose qui compilait correctement.

[dragonjoker59]

Merci pour ta réponse !


J'avais essayé... mais j'ai dû faire une bêtise. Je vais retester.
J'ai pour l'instant utiliser une autre solution : déclarer les fonctions template, utiliser un static_assert à l'intérieur de la fonction et un cast dans la fonction qui appelle. C'est un peu moche, mais c'est la seule chose qui compilait correctement.

J'aimerais bien voir ça... Ca sent l'horreur...

[ToTo13]

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#ifndef DILATE_H
#define DILATE_H
 
namespace mylib
{
namespace Dilate
{
 
template<typename T> void HistX(const T *src, const int sewidth, T *res)
	{
	static_assert(std::is_same<T, UINT8>::value, "") ;
	...
	}
 
template<typename T> void InterHistX(const UINTT8 *src, const int sewidth, T *res)
	{
	static_assert(std::is_same<T, UINT8>::value, "") ;
	...
	}
 
template<typename T> void FmX(const T *src, const int sewidth, T *res) {...}
 
template<typename T> void AvX(const T *src, const int sewidth, T *res) {...}
 
 
 
template<typename T> void SegmentX(const T *src, const int sewidth, T *res)
	{
	if ( sewidth <= 13 ) AvX(src, sewidth, res) ;
	else 
		if ( std::is_same<T, UINT8>::value ) HistX((UINT8*)src, sewidth, (UINT8*)res) ;
		else FmX(src, sewidth, res) ;
	}
 
template<typename T> void SegmentInterX(const T *src, const int sewidth, T *res)
	{
	if ( std::is_same<T, UINT8>::value )
		if ( sewidth <= 13 ) AvX(src, sewidth, res) ;
		else InterHistX((UINT8*)src, sewidth, (UINT8*)res) ;
	else
		if ( sewidth <= 13 || channel != 1 ) AvX(src, sewidth, res) ;
		else FmX(src, sewidth, res) ;
	}
 
} // namespace Dilate
} // namespace mylib
#endif	/* DILATE_H */

Du bidouillage sans aucun doute, mais ça compile. Je vais retenter en ne faisant que les déclarations dans le header.

[dragonjoker59]

Je ne peux que te conseiller vivement d'enlever ces templates inutiles, et de faire beaucoup plus simple :

Dilate.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef DILATE_H
#define DILATE_H
 
namespace mylib
{
namespace Dilate
{
 
	void HistX(const UINT8 *src, const int sewidth, UINT8 *res);
 
	void InterHistX(const UINT8 *src, const int sewidth, UINT8 *res);
 
	...
	...
	...
 
} // namespace Dilate
} // namespace mylib
#endif	/* DILATE_H */

Dilate.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include "Dilate.h"
 
namespace mylib
{
namespace Dilate
{
 
	void HistX(const UINT8 *src, const int sewidth, UINT8 *res)
	{
	...
	}
 
	void InterHistX(const UINT8 *src, const int sewidth, UINT8 *res)
	{
	...
	}
 
} // namespace Dilate
} // namespace mylib