Fonctions templétisées et include

Version imprimable

24/04/2009, 11h33
Trunks

Fonctions templétisées et include
Bonjour,

Dans le fichiers Tools.h, j'ai des fonctions templétisées qui me servent de helpers. Quand j'inclue Tools.h dans plusieurs fichiers .cpp, alors j'ai un problème au linkage, le linker me dit que les fonctions templétisées ont déjà été définies.

Comment faire?
Code:

1 2 3 4 5 template<typename T> bool FromCtrl(const CWnd& ctrl, T& value) { ... }
Citation:

CardReaderManager.obj : error LNK2005: "bool __cdecl FromCtrl(class CWnd const &,class CString &)" (?FromCtrl@@YA_NABVCWnd@@AAVCString@@@Z) already defined in TestCardReaderDlg.obj

Tu as bien mis les include guards
Code:

1 2 3 4 5 6 #ifndef _TOOLS_H #define _TOOLS_H // ton code #endif
?

Oui bien sûr :)

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
// Tools.h : header file
//
 
#if !defined(AFX_TOOLS_H__A7F90A01_5A01_48E8_BD2A_4187C96CB127__INCLUDED_)
#define AFX_TOOLS_H__A7F90A01_5A01_48E8_BD2A_4187C96CB127__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
#include <sstream>  
 
template<typename T>
bool FromCtrl(const CWnd& ctrl, T& value)
{
    CString str;
    ctrl.GetWindowText(str);
#ifdef _UNICODE
    std::wistringstream iss(static_cast<const TCHAR*>(str));
#else
	std::istringstream iss(static_cast<const TCHAR*>(str));
#endif
    // tenter la conversion vers Dest
    return iss >> value != 0;
}
 
template<>
bool FromCtrl<CString>(const CWnd& ctrl, CString& value)
{
    ctrl.GetWindowText(value);
 
    return TRUE;
}
 
template<typename T>
bool ToCtrl(CWnd& ctrl, const T& value)
{
#ifdef _UNICODE
    std::wostringstream oss(static_cast<T>(value));
#else
	std::ostringstream oss(static_cast<T>(value));
#endif
    // tenter la conversion vers Dest
    bool ret = oss << value != 0;
 
	if (!ret)
	{
		return FALSE;
	}
 
    CString str = oss.str().c_str();
    ctrl.SetWindowText(str);
 
	return TRUE;
}
 
template<>
bool ToCtrl<const CString>(CWnd& ctrl, const CString& value)
{
    ctrl.SetWindowText(value);
 
    return TRUE;
}
 
bool ToCtrl(CWnd& ctrl, const TCHAR* value)
{
    ctrl.SetWindowText(value);
 
    return TRUE;
}
 
#endif // !defined(AFX_TESTCARDREADERDLG_H__A7F90A01_5A01_48E8_BD2A_4187C96CB127__INCLUDED_)

24/04/2009, 12h22
Sylvain Togni
Ceci n'est pas un template de fonction
Code:

1 2 3 4 5 6 7 template<> bool FromCtrl<CString>(const CWnd& ctrl, CString& value) { ctrl.GetWindowText(value); return TRUE; }
mais une spécialisation, c'est-à-dire une vraie fonction, il faut donc soit la déclarer "inline" soit la mettre dans un .cpp.
24/04/2009, 12h59
Trunks
C'est exactement ça, bien vu :king:

Question subsidiaire:

Quel est l'intérêt entre une spécialisation de fonction et une fonction nomal surchargée?
Code:

1 2 3 4 5 6 template<> bool FromCtrl<CString>(const CWnd& ctrl, CString& value) => bool FromCtrl(const CWnd& ctrl, CString& value)

La cohérence de ton code ?
La résolution (le terme n'est peut être pas le bon) n'est pas la même :

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
 
#include <iostream>
#include <string>
 
void fonction(int)
{
   std::cout<<"int"<<std::endl;
}
template<class T>
void fonction(T)
{
   std::cout<<"template T"<<std::endl;
}
template<>
void fonction<int>(int)
{
   std::cout<<"template int"<<std::endl;
}
 
 
int main()
{
   int i(5);
   std::string str("tutu");
   fonction(i);
   fonction<int>(i);
   fonction(str);
  return 1;
}

24/04/2009, 14h58
Trunks

Bizarre, sous VC++ 6.0, il entre 2 fois dans la version non templétisée de int.

Bref peu importe, c'était juste par curiosité :ange: