Discussion :

[antow42]

Bonjour à tous,

Dans une application en C++, développée à l'aide de Visual Studio C++, j'utilise le code suivant :

Code :

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

1
2
3
4
5
6
7
 
AutomationExcel * Autom1;
[...]
Autom1->demarrerExcel("Résultats1");
plage.Format( "$A$2:$A$%u", 1001);
Autom1->creerDonnees( "C (Vo/s)", "$A$1",tab,plage,1000,(short)1);
[...]

Je souhaiterais pouvoir mettre un nom au fichier Excel, j'ai essayé mais je n'arrive pas à trouver ! "demarrerExcel("Résultats1")" ne me sert qu'à appeler mon premier onglet Excel. Mais comment nommer le fichier Excel à sa création ? Avez-vous des idées ?

Deuxième problème, que je pense plus complexe.
Dans mon logiciel développé, j'ai un tronc commun où je peux créer une simulation qui va donner à la fin un fichier Excel. Je crée donc une AutomationExcel (une AutomationExcel "globale") dans le tronc commun, et une variable "vide" se met à "true".
Lorsque je crée une simulation, un fichier Excel est créé, et la variable "vide" est mise à "false".
Cela me permet de gérer le fait que si l'utilisateur souhaite créer une autre simulation et qu'il n'a pas fermé le fichier Excel, un message avertit l'utilisateur que s'il ne sauvegarde pas manuellement le fichier Excel, ce dernier va se fermer et la nouvelle simulation va commencer. Tout ceci est géré grâce à la variable "vide", car lorsque le fichier Excel est ouvert, "vide" est à "false". Il suffit donc de tester cette variable pour voir si un fichier Excel est ouvert ...
Mon problème est donc le suivant : lorsque l'application ferme automatiquement Excel, la variable passe à "true" et il n'y a aucun soucis ! Mais si l'utilisateur ferme manuellement le fichier Excel, cette variable ne se modifie pas. Donc l'application crois toujours qu'un fichier Excel est ouvert !!! Et tous les tests deviennent donc faux !!!
Help ! Avez-vous une solution à ce problème ? Avez-vous des pistes ?

Je vous remercie !!!

Cordialement,

Anthony

[antow42]

J'ai essayé de travailler sur le problème de Excel tout le matin, mais je n'y arrive pas ...

En cherchant sur Internet, je n'ai pas trouvé pour donner un nom à un fichier Excel créé par l'application C++.

Et je ne sais pas non plus quel moyen je peux utiliser pour savoir si un fichier Excel est ouvert ou non ...


Merci beaucoup à ceux qui sont intéressés par mes interrogations !


Anthony

[Gabrielly]

Il faut que tu obtiennes l'objet classeur et tu utilises sa méthode d'enregistrement sous un nom donné.

[antow42]

Merci de m'avoir répondu !

Mais comment obtenir un objet classeur ?

Pourriez-vous me donner un exemple ?


Merci bcp !!!

[Gabrielly]

Je vais te présenter l'organisation générale des objets d'Excel

1. D'abord tu as l'objet application d'Excel avec ses méthodes au niveau de l'objet application d'Excel. L'objet application maintient une collection des classeurs qui sont ouverts par ton application. C'est le conteneur des classeurs Excel ouverts. Il est judicieux de passer par l'objet application avant d'atteindre ton classeur.

2. L'objet conteneur des classeurs Excel te perment d'accéder au classeur individuel soit à partir d'un indexe dans la collection soit à partir de son nom. C'est un conteneur au sens propre du terme avec ses méthodes appropriés pour un conteneur des workbooks.

3. Ensuite tu as l'objet classeur Excel le workbook qui est ton fichier excel proprement dit avec ses méthodes au niveau du workbook.

4. Le classeur excel donc le workbook contient un conteneur des feuilles excel qui sont les worksheets. Tu accèdes à ces sheets à partir de leurs indexes ou de leurs noms dans la collection avec ses méthodes appropriés pour un conteneur des worksheets.

5. L'objet feuille d'Excel donc le worksheet contient ses méthodes au niveau de la feuille d'Excel.

6. A partir de la feuille Excel tu obtiens les objets Range ie les rangés sur ta feuille et sur lesquels tu places tes données, tes formules, tes mises en formes.

7. Et tu as tout plein d'autres objets Excel comme les Chart et consort, ils sont très nombreux.

Et donc tu as l'objet application, la collection des classeurs, le classeur, la collection des feuilles, la feuille, les rangées et les autres objets d'Excel.

[antow42]

D'accord, je viens de comprendre, mais bon, je ne sais pas encore ce qu'il faut faire exactement.

Quelqu'un aurait-il une solution, qui s'est confronté à ce problème ?


Merci beaucoup !

[komis]

Salut antow42
désolé j'ai également les mêmes soucis sauf que moi quand j'intègre la classe excel dans mon projet MFC, il y'a beaucoup d'erreurs qui après révision se transforment en erreurs de link externe......... ça fait une semaine que j'essaie de le faire y'a pas moyen. sinon peux tu me passer tes classes pour que je puisse y jeter un coup d'oeil( si ça ne te dérange pas bien sur...)
merci

[Gabrielly]

D'accord, je viens de comprendre, mais bon, je ne sais pas encore ce qu'il faut faire exactement.

Quelqu'un aurait-il une solution, qui s'est confronté à ce problème ?


Merci beaucoup !

Bon, je peux t'aider mais mais ca risque d'etre un peu long.
Ma la solution est efficace.

1. La premiere chose est de savoir avec quel version de Excel tu va travailler.
Excel 1997, Excel 2000, Excel 2002, Excel 2003 ou Excel 2007. Nous pouvons jouer avec la directive import du compilo pour mapper la bonne version.

2. Ensuite il faut chercher un moyen efficace d'avoir une ecriture C++ souple avec les variants ( en d'autres termes par exemple d'affecter directement un CString dans une cellule Excel et vis versa en effectuant une conversion implicite) Je te montrerai ma classe CMcnVariant

3. Ensuite definir des classes derivant des principaux objets d'Excel
4. Et tu les empaquete dans une bonne DLL d'Extension MFC pour exportation dans toute application MFC.

Je vais te montrer la procedure...

[Gabrielly]

Voici un début [FAQ][VC++]Comment déterminer la bonne version d'Excel pour l'automation

A partir du lien ci-haut, la directive import du compilo nous génère les fichiers excel.tlh et excel.tli dans notre namespace "Excel", mso.tlh et mso.tli dans notre namespace "Office", et vbe6ext.tlh et vbe6ext.tli dans notre namespace "VBA".
Vous pouvez vous apercevoir que c'est plein d'énumération, de déclaration d'interfaces, et de pointeurs intelligents. Mais nous employerons pas directements ces composants comme tels.

Ce que nous allons faire c'est de préparer ces composants Excel en leur rajoutant une surcouche par la définition d'une classe spéciale, une classe template d'un pointeur intelligent comme classe de base définit à l'aide d'une macro. La définition de cette classe de base va nous éviter d'utiliser ces composants de façon brute. Elle a pour objective de produire une syntaxe C++ très souple, propre et puissante.
Cette classe n'est pas non plus prévu d'être utiliser directement dans notre code. Elle sert plutôt à préparer nos divers classes enfants MFC qui représenteront chaque entité de nos composants Excel principaux.

[Gabrielly]

Sans plus tarder voici cette classe définit dans le fichier McnComPtrT.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
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
 
#pragma once
 
#include <comdef.h>
#include <comdefsp.h>
 
 
#define MCN_CONSTRUCT_COM_PTR_T(theClass, theBaseClass) \
	public: \
		theClass() \
		{ \
		} \
		explicit theClass( \
			const CLSID& clsid,	IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) \
			:CMcnComPtrT<theBaseClass>(clsid, pOuter, dwClsContext) \
		{ \
		} \
		explicit theClass(  \
			LPCWSTR str, IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) \
			:CMcnComPtrT<theBaseClass>(str, pOuter, dwClsContext) \
		{ \
		} \
		explicit theClass(  \
			LPCSTR str, IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) \
			:CMcnComPtrT<theBaseClass>(str, pOuter, dwClsContext) \
		{ \
		} \
		theClass(const theBaseClass& sp) throw() \
			:CMcnComPtrT<theBaseClass>(sp) \
		{ \
		} \
		theClass& operator=(theBaseClass p) \
		{ \
			HRESULT hr = _QueryInterface(p); \
			if (FAILED(hr) && (hr != E_NOINTERFACE)) { \
				_com_issue_error(hr); \
			} \
			return *this; \
		}
 
// T class must inherit directly of indirectly from _com_ptr_t
 
	template< class T >
	class CMcnComPtrT : public T
	{
	public:
		typedef T baseType;
		typedef CMcnComPtrT<T> thisType;
 
		CMcnComPtrT()
		{
		}
 
		explicit CMcnComPtrT(
			const CLSID& clsid,	IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
			:T(clsid, pOuter, dwClsContext)
		{
		}
 
		explicit CMcnComPtrT(
			LPCWSTR str, IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
			:T(str, pOuter, dwClsContext)
		{
		}
 
		explicit CMcnComPtrT( 
			LPCSTR str, IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
			:T(str, pOuter, dwClsContext)
		{
		}
 
		CMcnComPtrT(const T& sp) throw()
			:T(sp)
		{
		}
 
	protected:
		template<typename _InterfacePtr>
		HRESULT _QueryInterface(_InterfacePtr p) throw()
		{
			HRESULT hr;
			if (p != NULL)
			{
				Interface* pInterface;
				hr = p->QueryInterface(GetIID(), reinterpret_cast<void**>(&pInterface));
				baseType::Attach(SUCCEEDED(hr)? pInterface: NULL);
			}
			else
			{
				baseType::operator=(static_cast<Interface*>(NULL));
				hr = E_NOINTERFACE;
			}
			return hr;
		}
 
	}; // class CMcnComPtrT

La classe template CMcnComPtrT est un pointeur intelligent dont l'argument de son modèle T est une interface d'Excel quelconque générée par la directive import.

Soit l'interface de l'objet application d'Excel tel que générée

Code :

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

1
2
3
4
 
Excel::_Application   // qui est l'interface brute
Excel::_ApplicationPtr  // qui est l'interface prise en charge par le smart pointeur _com_ptr_t
CMcnComPtrT<Excel::_ApplicationPtr> // qui est la nouvelle interface qui améliore le smart pointeur _com_ptr_t tel qu'au niveau de l'opérateur d'affection et des constructeurs.

Pour l'interface de la collection des classeurs Excel on a :

Code :

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

1
2
3
4
 
Excel::Workbooks
Excel::WorkbooksPtr
CMcnComPtrT<Excel::WorkbooksPtr>

Pour l'interface du classeur Excel on a :

Code :

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

1
2
3
4
 
Excel::_Workbook
Excel::_WorkbookPtr
CMcnComPtrT<Excel::_WorkbookPtr>

Pour l'interface de la collection des feuilles d'un classeur Excel on a:

Code :

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

1
2
3
4
 
Excel::Sheets
Excel::SheetsPtr
CMcnComPtrT<Excel::SheetsPtr>

Pour l'interface d'une feuille Excel on a:

Code :

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

1
2
3
4
 
Excel::_Worksheet
Excel::_WorksheetPtr
CMcnComPtrT<Excel::_WorksheetPtr>

Pour l'interface d'une rangée de cellules Excel on a:

Code :

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

1
2
3
4
 
Excel::Range
Excel::RangePtr
CMcnComPtrT<Excel::RangePtr>

[Gabrielly]

Ensuite j'ai mes classes MFC dans une DLL d'extension.
Pour l'objet application d'Excel :

Code :

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

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnExcelApp : public CMcnComPtrT<Excel::_ApplicationPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnExcelApp, Excel::_ApplicationPtr)
        public:  
//... tes méthodes personnelles pour l'objet application
};

Pour l'objet collection des classeurs Excel :

Code :

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

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnWorkBooks : public CMcnComPtrT<Excel::WorkbooksPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnWorkBooks, Excel::WorkbooksPtr)
        public: 
//...  tes méthodes personnelles pour la collection des classeurs
};

Pour l'objet classeur Excel :

Code :

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

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnWorkBook : public CMcnComPtrT<Excel::_WorkbookPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnWorkBook, Excel::_WorkbookPtr)
        public: 
//... tes méthodes personnelles pour le classeur
};

Pour l'objet collection des feuilles du classeur Excel :

Code :

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

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnWorkSheets : public CMcnComPtrT<Excel::SheetsPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnWorkSheets, Excel::SheetsPtr)
        public:
//...  tes méthodes personnelles pour la collection des feuilles
};

Pour l'objet feuille Excel :

Code :

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

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnWorkSheet : public CMcnComPtrT<Excel::_WorksheetPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnWorkSheet, Excel::_WorksheetPtr)
        public:
//...  tes méthodes personnelles pour la feuille
};

Pour l'objet rangée de cellules Excel :

Code :

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

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnRange : public CMcnComPtrT<Excel::RangePtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnRange, Excel::RangePtr)
        public:
//...  tes méthodes personnelles pour la rangée
};

[Gabrielly]

Maintenant je vais te présenter une façon d'accéder aux différents objets d'Excel.

Voici un simple code.

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
20
21
 
MCN::Automation::McnExcel::CMcnExcelApp spExcelApp;  // je commence avec l'objet application
HRESULT hr = spExcelApp.CreateInstance(EXCEL_APPLICATION);  // mappe vers la bonne version
if (FAILED(hr))
{
	CString strError("Echec de chargement de Microsoft Excel");
	return;
}
 
MCN::Automation::McnExcel::CMcnWorkBook spWorkBook = spExcelApp.CreateWorkBook();  // je crée un classeur
spWorkBook.SaveAs("C:\\fichier.xls");
 
CString strFullName = spWorkBook.GetFullName();  // C:\\fichier.xls
 
MCN::Automation::McnExcel::CMcnWorkSheet spWorkSheet = spWorkBook.CreateWorkSheet();  // j'ajoute une feuille
spWorkSheet.PutName("Test");
 
MCN::Automation::McnExcel::CMcnRange spRange = spWorkSheet.GetRange("A1", "G10");  // j'obtiens une rangée
spRange.PutItem(3, 4, "Salut");
 
CString strText = spRange.GetItem(3, 4);  // Salut

la suite

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
20
21
 
MCN::Automation::McnExcel::CMcnWorkBooks spWorkBooks = spExcelApp.GetWorkBookCollection();
spWorkBook = spWorkBooks.GetItem("C:\\fichier.xls", true); // recherche par le nom complet
spWorkBook.Show("Test"); // affiche le classeur avec la feuille Test par défaut
 
MCN::Automation::McnExcel::CMcnWorkSheets spWorkSheets = spWorkBook.GetWorkSheetCollection();
spWorkSheet = spWorkSheets.GetItem("Test"); // recherche la feuille par son nom
 
long nRows = 100;
long nCols = 10
spRange = spWorkSheet.GetRange("H12", nRows, nCols);  // une rangée de 100 lignes et 10 colonnes à partir de H12
 
spRange.AutoFitColumns();  // ajustement automatique des colonnes
MCN::Automation::McnExcel::CMcnRange spColRange = spRange.GetColAt(4); // 4ième colonne
 
double dValue = 14.3;
long nRowFound = -1;
long nColFound = -1;
spColRange.FindData(dValue, nRowFound, nColFound); // cherche la valeur 14.3 dans cette colonne
 
//...

Ces objets Excel permettent d'utiliser ses propres méthodes en faisant objet.PersonalMember() ou d'accéder aux méthodes existantes d'Excel en faisant objet->ExcelMember().
Mais avant d'en arriver là. Excel transit toujours ses données par des variants.
Nous avons la classe COleVariant ou CComVariant pour travailler avec, mais de façon brute Excel utilise la classe _variant_t de <comutil.h>

Ainsi nous voulons que _variant_t soit capable de recevoir presque tout type de données même celle des MFC comme des CString ou des COleDateTime. Nous voulons également que _variant_t soit capable de les restituer automatiquement dans le type souhaité sans que nos yeux puissent aperçevoir un cast explicite.

Voici la classe CMcnVariant :

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
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
 
#pragma once
 
#include <comutil.h>
 
	template<typename T>
	class CCastingVariant : public _variant_t
	{
	public:
		typedef CCastingVariant<T> ThisType;
		typedef _variant_t BaseType;
 
		// Constructors
		//
		inline CCastingVariant() throw()
			:_variant_t()
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const VARIANT& varSrc)
			:_variant_t(varSrc)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const VARIANT* pSrc)
			:_variant_t(pSrc)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const _variant_t& varSrc)
			:_variant_t(varSrc)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const ThisType& varSrc)
			:_variant_t()
		{
			*this = varSrc;
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(VARIANT& varSrc, bool fCopy) // Attach VARIANT if !fCopy
			:_variant_t(varSrc, fCopy)
		{
			m_vtOperation = vt;
		}          
 
		inline CCastingVariant(short sSrc, VARTYPE vtSrc = VT_I2)    // Creates a VT_I2, or a VT_BOOL
			:_variant_t(sSrc, vtSrc)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(long lSrc, VARTYPE vtSrc = VT_I4)     // Creates a VT_I4, a VT_ERROR, or a VT_BOOL
			:_variant_t(lSrc, vtSrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(float fltSrc) throw()                                   // Creates a VT_R4
			:_variant_t(fltSrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(double dblSrc, VARTYPE vtSrc = VT_R8)					// Creates a VT_R8, or a VT_DATE
			:_variant_t(dblSrc, vtSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(COleDateTime dateSrc)									// Creates a VT_DATE
			:_variant_t((DATE)dateSrc, VT_DATE)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const CY& cySrc) throw()                                // Creates a VT_CY
			:_variant_t(cySrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(const _bstr_t& bstrSrc)                // Creates a VT_BSTR
			:_variant_t(bstrSrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(const wchar_t *pSrc)                   // Creates a VT_BSTR
			:_variant_t(pSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(const char* pSrc)                     // Creates a VT_BSTR
			:_variant_t(pSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(const CString& rSrc)                     // Creates a VT_BSTR
			:_variant_t(rSrc.GetString())
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(IDispatch* pSrc, bool fAddRef = true) throw()           // Creates a VT_DISPATCH
			:_variant_t(pSrc, fAddRef)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(bool boolSrc) throw()                                  // Creates a VT_BOOL
			:_variant_t(boolSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(IUnknown* pSrc, bool fAddRef = true) throw()            // Creates a VT_UNKNOWN
			:_variant_t(pSrc, fAddRef)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const DECIMAL& decSrc) throw()                          // Creates a VT_DECIMAL
			:_variant_t(decSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(BYTE bSrc) throw()                                      // Creates a VT_UI1
			:_variant_t(bSrc)
		{
			m_vtOperation = vt;
		}          
 
		inline CCastingVariant(char cSrc) throw()                                      // Creates a VT_I1
			:_variant_t(cSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(unsigned short usSrc) throw()                           // Creates a VT_UI2
			:_variant_t(usSrc)
		{
			m_vtOperation = vt;
		}   
 
		inline CCastingVariant(unsigned long ulSrc) throw()                            // Creates a VT_UI4
			:_variant_t(ulSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(int iSrc) throw()                                       // Creates a VT_INT
			:_variant_t(iSrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(unsigned int uiSrc) throw()                             // Creates a VT_UINT
			:_variant_t(uiSrc)
		{
			m_vtOperation = vt;
		} 
 
#if (_WIN32_WINNT >= 0x0501)
		inline CCastingVariant(__int64 i8Src) throw()                                  // Creates a VT_I8
			:_variant_t(i8Src)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(unsigned __int64 ui8Src) throw()                        // Creates a VT_UI8
			:_variant_t(ui8Src)
		{
			m_vtOperation = vt;
		}          
#endif
 
		// Destructor
		//
		~CCastingVariant() throw()
		{
		}
 
		// MCN Extractors
		//
 
		inline operator BaseType() const throw()
		{
			return *(BaseType*) this;
		}
 
		inline operator CString() const throw() // Extracts as CString object
		{
			_bstr_t bstr = *this;
			return CString(bstr.GetBSTR());
		}
 
		// base class doesn't extract a double as date so CMcnVariant do it itseft
		inline operator double() const // Extracts a double from a VT_R8 or a VT_DATE
		{
			if (V_VT(this) == VT_R8) {
				return V_R8(this); 
			}
			else if (V_VT(this) == VT_DATE) {
				return V_DATE(this); 
			}
 
			BaseType varDest;
			varDest.ChangeType(VT_R8, this);
 
			return V_R8(&varDest);
		}
 
		inline ThisType& operator=(const ThisType& varSrc)
		{
			const BaseType& varBaseSrc = varSrc;
			BaseType::operator=(varBaseSrc);
			m_vtOperation = varSrc.m_vtOperation;
			return *this;
		}
 
		inline ThisType& operator=(const CString& strSrc)    // Assign a CString
		{
			BaseType::operator=(strSrc);
			return *this;
		}
 
		inline ThisType& operator=(double dblSrc)			// Assign a double
		{
			BaseType::operator=(dblSrc);
			return *this;
		}
 
		inline ThisType& operator=(const COleDateTime& dateSrc)    // Assign a COleDateTime
		{
			BaseType::operator=((DATE)dateSrc);
			return *this;
		}
 
		// Comparison operations
		//
		VARTYPE m_vtOperation;
 
		inline bool operator<(const ThisType& varValue2) const throw()
		{
			const BaseType& Value2 = varValue2;
			const BaseType& Value1 = *this;
 
			switch(m_vtOperation)
			{
			case VT_I1:			return ((char)Value1 < (char)Value2)? true: false;
			case VT_I2:			return ((short)Value1 < (short)Value2)? true: false;
			case VT_I4:			return ((long)Value1 < (long)Value2)? true: false;
 
			case VT_CY:			return (((CY)Value1).int64 < ((CY)Value2).int64)? true: false;
			case VT_DECIMAL:	return (((DECIMAL)Value1).Lo64 < ((DECIMAL)Value2).Lo64)? true: false;
 
			case VT_UI1:		return ((BYTE)Value1 < (BYTE)Value2)? true: false;
			case VT_UI2:		return ((unsigned short)Value1 < (unsigned short)Value2)? true: false;
			case VT_UI4:		return ((unsigned long)Value1 < (unsigned long)Value2)? true: false;
 
			case VT_INT:		return ((int)Value1 < (int)Value2)? true: false;
			case VT_UINT:		return ((unsigned int)Value1 < (unsigned int)Value2)? true: false;
 
#if (_WIN32_WINNT >= 0x0501)
			case VT_I8:			return ((__int64)Value1 < (__int64)Value2)? true: false;
			case VT_UI8:		return ((unsigned __int64)Value1 < (unsigned __int64)Value2)? true: false;
#endif
 
			case VT_R4:			return ((float)Value1 < (float)Value2)? true: false;
			case VT_R8:			return ((double)Value1 < (double)Value2)? true: false;
			case VT_DATE:		return ((double)Value1 < (double)Value2)? true: false;
 
			case VT_BSTR:		return ((_bstr_t)Value1 < (_bstr_t)Value2)? true: false;
 
			default:
				ATLASSERT(FALSE);
				return false;
			}
		}
 
		inline bool operator>(const ThisType& varValue2) const throw()
		{
			const BaseType& Value2 = varValue2;
			const BaseType& Value1 = *this;
 
			switch(m_vtOperation)
			{
			case VT_I1:			return ((char)Value1 > (char)Value2)? true: false;
			case VT_I2:			return ((short)Value1 > (short)Value2)? true: false;
			case VT_I4:			return ((long)Value1 > (long)Value2)? true: false;
 
			case VT_CY:			return (((CY)Value1).int64 > ((CY)Value2).int64)? true: false;
			case VT_DECIMAL:	return (((DECIMAL)Value1).Lo64 > ((DECIMAL)Value2).Lo64)? true: false;
 
			case VT_UI1:		return ((BYTE)Value1 > (BYTE)Value2)? true: false;
			case VT_UI2:		return ((unsigned short)Value1 > (unsigned short)Value2)? true: false;
			case VT_UI4:		return ((unsigned long)Value1 > (unsigned long)Value2)? true: false;
 
			case VT_INT:		return ((int)Value1 > (int)Value2)? true: false;
			case VT_UINT:		return ((unsigned int)Value1 > (unsigned int)Value2)? true: false;
 
#if (_WIN32_WINNT >= 0x0501)
			case VT_I8:			return ((__int64)Value1 > (__int64)Value2)? true: false;
			case VT_UI8:		return ((unsigned __int64)Value1 > (unsigned __int64)Value2)? true: false;
#endif
 
			case VT_R4:			return ((float)Value1 > (float)Value2)? true: false;
			case VT_R8:			return ((double)Value1 > (double)Value2)? true: false;
			case VT_DATE:		return ((double)Value1 > (double)Value2)? true: false;
 
			case VT_BSTR:		return ((_bstr_t)Value1 > (_bstr_t)Value2)? true: false;
 
			default:
				ATLASSERT(FALSE);
				return false;
			}
		}
 
		inline bool operator<=(const ThisType& varValue2) const throw()
		{
			const BaseType& Value2 = varValue2;
			const BaseType& Value1 = *this;
 
			switch(m_vtOperation)
			{
			case VT_I1:			return ((char)Value1 <= (char)Value2)? true: false;
			case VT_I2:			return ((short)Value1 <= (short)Value2)? true: false;
			case VT_I4:			return ((long)Value1 <= (long)Value2)? true: false;
 
			case VT_CY:			return (((CY)Value1).int64 <= ((CY)Value2).int64)? true: false;
			case VT_DECIMAL:	return (((DECIMAL)Value1).Lo64 <= ((DECIMAL)Value2).Lo64)? true: false;
 
			case VT_UI1:		return ((BYTE)Value1 <= (BYTE)Value2)? true: false;
			case VT_UI2:		return ((unsigned short)Value1 <= (unsigned short)Value2)? true: false;
			case VT_UI4:		return ((unsigned long)Value1 <= (unsigned long)Value2)? true: false;
 
			case VT_INT:		return ((int)Value1 <= (int)Value2)? true: false;
			case VT_UINT:		return ((unsigned int)Value1 <= (unsigned int)Value2)? true: false;
 
#if (_WIN32_WINNT >= 0x0501)
			case VT_I8:			return ((__int64)Value1 <= (__int64)Value2)? true: false;
			case VT_UI8:		return ((unsigned __int64)Value1 <= (unsigned __int64)Value2)? true: false;
#endif
 
			case VT_R4:			return ((float)Value1 <= (float)Value2)? true: false;
			case VT_R8:			return ((double)Value1 <= (double)Value2)? true: false;
			case VT_DATE:		return ((double)Value1 <= (double)Value2)? true: false;
 
			case VT_BSTR:		return ((_bstr_t)Value1 <= (_bstr_t)Value2)? true: false;
 
			default:
				ATLASSERT(FALSE);
				return false;
			}
		}
 
		inline bool operator>=(const ThisType& varValue2) const throw()
		{
			const BaseType& Value2 = varValue2;
			const BaseType& Value1 = *this;
 
			switch(m_vtOperation)
			{
			case VT_I1:			return ((char)Value1 >= (char)Value2)? true: false;
			case VT_I2:			return ((short)Value1 >= (short)Value2)? true: false;
			case VT_I4:			return ((long)Value1 >= (long)Value2)? true: false;
 
			case VT_CY:			return (((CY)Value1).int64 >= ((CY)Value2).int64)? true: false;
			case VT_DECIMAL:	return (((DECIMAL)Value1).Lo64 >= ((DECIMAL)Value2).Lo64)? true: false;
 
			case VT_UI1:		return ((BYTE)Value1 >= (BYTE)Value2)? true: false;
			case VT_UI2:		return ((unsigned short)Value1 >= (unsigned short)Value2)? true: false;
			case VT_UI4:		return ((unsigned long)Value1 >= (unsigned long)Value2)? true: false;
 
			case VT_INT:		return ((int)Value1 >= (int)Value2)? true: false;
			case VT_UINT:		return ((unsigned int)Value1 >= (unsigned int)Value2)? true: false;
 
#if (_WIN32_WINNT >= 0x0501)
			case VT_I8:			return ((__int64)Value1 >= (__int64)Value2)? true: false;
			case VT_UI8:		return ((unsigned __int64)Value1 >= (unsigned __int64)Value2)? true: false;
#endif
 
			case VT_R4:			return ((float)Value1 >= (float)Value2)? true: false;
			case VT_R8:			return ((double)Value1 >= (double)Value2)? true: false;
			case VT_DATE:		return ((double)Value1 >= (double)Value2)? true: false;
 
			case VT_BSTR:		return ((_bstr_t)Value1 >= (_bstr_t)Value2)? true: false;
 
			default:
				ATLASSERT(FALSE);
				return false;
			}
		}
 
		static T* CastFromVariant(VARIANT var)
		{
			if(var.vt != VT_BYREF || var.byref == NULL)
				return NULL;
			return (T*) var.byref;
		}
 
		static VARIANT CastToVariant(T* pT)
		{
			if(pT == NULL)
				return CComVariant();
 
			VARIANT var;
			var.byref = (void*) pT;
			var.vt = VT_BYREF;
			return var;
		}
 
	};  // class CCastingVariant
 
 
	typedef CCastingVariant<void> CMcnVariant;