NON, LE C++ N’EST PAS MORT !!!!! Visual Studio 2005 et le C++ Introduction : Pourquoi le C++/CLI ?...
-
Upload
gabrielle-jacquemin -
Category
Documents
-
view
107 -
download
0
Transcript of NON, LE C++ N’EST PAS MORT !!!!! Visual Studio 2005 et le C++ Introduction : Pourquoi le C++/CLI ?...
C++/CLI Code hybride : Comment re-utiliser du code existant avec le Framework .NET ?
Eric MitteletteEric Vernié
NON, LE C++ N’EST PAS MORT !!!!!
Agenda
Visual Studio 2005 et le C++Introduction : Pourquoi le C++/CLI ?C++/CLI : Eléments SyntaxiquesC++/CLI : Garbage collection et destruction déterministe ?C++/CLI : Code hybride ou comment mixer les codes natifs et managésConclusion : C++/CLI « first class langage for .NET »Le future
Visual Studio 2005 et C++
ISO C++ (98% de la norme)Syntaxe C++ qui cible du code natif
C++/CLISyntaxe C++ qui cible le Framework .NET
Introduction : Pourquoi le C++/CLI ?
Ré utiliser les compétences « fines/pointues » des développeurs C++On ne va pas ré écrire des millions de lignes de code pour une nouvelle plateforme : .NET
« We love your C++ Code »
Syntaxe déposée à l’ECMA et ISOTravail initié en 2002 avec les MC++ (Managed Extension for C++)Intégration de C++/CLI avec ISO-C++« LE » language de l’interopérabilité
Utiliser le Framework .NET de façon naturelle en C++
C++/CLI : Eléments Syntaxiques
Une option de compilation « primordiale »
/CLR : émettre du code MSILSupport de la syntaxe CLI « activée »Option pour le projet ou pour un fichier individuellement
Différentes sous option à /CLR/CLR : Pure/CLR : Safe
C++/CLI : Eléments Syntaxiques
Notion d’ “adjective class”
Types C++ et CLR cohérents
Attention : pas d ’héritage multiple de « ref class »Attention : implémentation multiple d’ « interface class »
ref class A abstract { }; // abstractref class B sealed : A { }; // no further derivation ref class C : B { }; // error, B is sealed
ref class A abstract { }; // abstractref class B sealed : A { }; // no further derivation ref class C : B { }; // error, B is sealed
class N { /*…*/ }; // nativeref class R { /*…*/ }; // CLR reference type
value class V { /*…*/ }; // CLR value typeinterface class I { /*…*/ }; // CLR interface type
enum class E { /*…*/ }; // CLR enumeration type
class N { /*…*/ }; // nativeref class R { /*…*/ }; // CLR reference type
value class V { /*…*/ }; // CLR value typeinterface class I { /*…*/ }; // CLR interface type
enum class E { /*…*/ }; // CLR enumeration type
C++/CLI : Eléments Syntaxiques
Pointers et Handles
Sur le tas natifComme d’hab pointeurs (*) stables indépendant du GC
Comme d’hab, attention aux fuites mémoire si pas de delete
Sur le tas managéHandles (^) sont des références d’ objets
Pas d’opérations arithmétiques dessus (cf. interior_ptr)
delete devient optionnel
Sur la pile (vraiment ?)Permet des destructions déterministes
TNatif* t1 = new TNatif;TNatif* t1 = new TNatif;
TNet^ t2 = gcnew TNet;TNet^ t2 = gcnew TNet;
T t3;T t3;
C++/CLI : Eléments Syntaxiques
* est à ^ ce que & est à %
C++/CLI : Eléments Syntaxiques
Propriété
ref class R { int mySize;public: property int Size { int get() { return mySize; } void set(int val) { mySize = val; } }};
R r;r.Size = 42; // use like a field
ref class R { int mySize;public: property int Size { int get() { return mySize; } void set(int val) { mySize = val; } }};
R r;r.Size = 42; // use like a field
ref class R {public: property int Size; // compiler-generated}; // get, set, and backing store
ref class R {public: property int Size; // compiler-generated}; // get, set, and backing store
Notation simplifiée
C++/CLI : Eléments Syntaxiques
Delegate et évènement
delegate void D(int);
ref class R {public: event D^ e; // trivial event; // compiler-generated members
void f() { e(42); } // invoke it};
R^ r = gcnew R();r->e += gcnew D(this, &SomeMethod);r->e += gcnew D(SomeFreeFunction);r->f();
delegate void D(int);
ref class R {public: event D^ e; // trivial event; // compiler-generated members
void f() { e(42); } // invoke it};
R^ r = gcnew R();r->e += gcnew D(this, &SomeMethod);r->e += gcnew D(SomeFreeFunction);r->f();
Vous pouvez écrire, ajouter, enlever et déclencher vous même les évènements.
C++/CLI : Eléments Syntaxiques
GenericSyntaxe des Generics ~comme celle des templatesAdmettent des contraintes et l’héritageInstancié à l’exécution
TemplateDisponible pour le C++/CLIGénéré au moment de la compilation
Les generics et les templates peuvent se combiner…
Attention casse tête chinois et rigueur demandée !
generic<typename T>where T : IFooref class GR { /* … */ };
generic<typename T>where T : IFooref class GR { /* … */ };
C++/CLI : Eléments Syntaxiques
CLR arraysNotation [] non supportée en C++/CLI
array<int>^ a1 = gcnew array<int>(10);array<int>^ a2 = gcnew array<int> { 1, 2, 3 };array<int>^ a3 = { 1, 2, 3 };array<int>^ a4 = gcnew array<int>(10) { 1, 2 };
F(gcnew array<Component> { button1, button2 });
array<int, 2> a5 = gcnew array<int>(10, 20);array<int, 2> a6 = { { 1, 2, 3 }, { 4, 5, 6 } };
C++/CLI: Garbage collection et destruction déterministe ?
Chaque objet .Net est sous contrôle du « Garbage Collector »
La mécanique du « garbage collector » est un pré requis essentiel à tous développeurs C++/CLIGénération, Collection, Compactage, Pattern IDispose et Finalisation
Heap Managed> 3 private heap + 1 private heap pour les « Large Object »
Elément syntaxique~MaClasse et !MaClasse
C++/CLI: Garbage collection et destruction déterministe ?
Une classe qui implémente un Finalizer doit avoir un destructeur Evitons la duplication de code : appelons le finalizer dans le destructeur
ref class R { /* MORE CODE */
!R() { /* Clean-up value type resources */ }
~R() { /* Do early clean-up, clean-up ref classes */ this->!R(); }};
C++/CLI : Code hybride ou comment mixer les codes natifs et managésC++/CLI : le roi de l’interopérabilité
COM InteropPInvoke
Pour tous les languages .NET
C++ InteropIt Just Works !Tous les scenarii possible…et imaginable
Hosting de la CLRContrôle fin de l’exécution du code .NET
Par exemple dans votre code MFC…
C++/CLI : Code hybride ou comment mixer les codes natifs et managés
Ré utiliser votre existantMigration code VC6
Breaking changes (conformité à la norme ISO98)Un seul environnement de développement (VS2005)
Compilateur 64 bits, Optimisation du code (WPO PGO), support de l’OpenMP …. Et bien plus encore
Utilisation des .lib ou dll depuis VS2005Et inversement !
Gestion du code mixtePasser des données, des pointeurs de fonctions, faire des appels « croisés » entre le monde managé et le monde natif
C++/CLI : Code hybride ou comment mixer les codes natifs et managés
Scenarii de code hybrideApps VC6 utilisent vos .lib VS2005Apps VS2005 utilise vos .lib VC6
Code Hybride (mixed code)Utiliser une classe native dans du code CLIUtiliser une classe CLI dans du code natifUtiliser de l’assembleur dans du code CLIUtiliser la BCL dans du code natifUtiliser les « Windows Forms » dans les MFC.NETmodule et .Obj + cl.exe !
Hosting de la CLR.
La boite à outils du développeur hybride
vcclr.h : gcroot<>, auto_gcroot<>AfxWindowsForms.h (MAKE_DELEGATE,/CLR System::Runtime::Interopservicespin_ptr<>, interior_ptr<>tblimp, tlbexpdllimport attributesLes APIs de hosting#pragma unmanaged
C++/CLI : Code hybride ou comment mixer les codes natifs et managés
Conclusion : C++/CLI « first class langage for .NET »
Productivité du développeur accru par la BCLConfort du développeur via l’IDE VS2005Performance au rendez vous-même dans le code managé pur et le code mixteEcrire moins de code en C++/CLI qu’en C#!
Démonstrations
Création d’une ref class simpleDe MFC à .NET
IJW
Des Windows forms dans les MFC
Etude : WPF dans les MFC
Questions
Ressources
Retrouvez nos vidéos sur le site MSDN (FR)
http://www.microsoft.com/france/msdn/visualc/default.mspx
Site MSDN UShttp://msdn2.microsoft.com/en-us/visualc/default.aspx