Migrer du C++ au C#

Droit de diffusion:
L'ensemble ou partie de ce document ainsi que le code mis à disposition, ne peut être diffusé sur d'autres sites Web sans l'autorisation au préalable de son créateur.

Certaines parties de cet article sont extraites de l'article : "C++ -> C#: What You Need to Know to Move from C++ to C#" de Jesse Liberty.

Avant Propos :
Ce document a pour but de présenter les principales différences entre le C++ et le C# et d'aider les personnes désireuses de réaliser le portage d'une application C++ en C#.

Sommaire:

Introduction
1. Les pièges
2. Les principales différences entre le C++ et le C#
3. Les types de valeur et de référence
4. Les structures
5. Tout dérive de la classe Object
6. La gestion des paramètres des prototypes de fonctions
7. Le mot clé "new"
8. Les propriétés
9. Les tableaux
Conclusion

Introduction

Le langage C# s'appuit sur la syntaxe et la sémantique du C++, permettant au programmeur C de bénéficier des avantages de .NET et de la Common Language Runtime. Alors que la transition du C++ vers le C# peut paraître aisée, il y a un certain nombre d'éléments qui ont changé que nous allons étudier tels que l'opérateur new, les structures, les constructeurs, les destructeurs.

1. Pièges

Vous trouverez ci-joint l'exemple complet.

6. La gestion des paramètres des prototypes de fonctions

En C# comme en C++ une méthode ne peut avoir qu'une seule valeur en retour. Pour pallier à cette limitation en C++ les paramètres sont passés par références ou via des pointeurs. La méthode appelée change la valeur des paramètres et les rend accessibles à la méthode appelante. En C# quand vous passez une référence à une méthode vous avez accès à l'objet d'origine, comme en C++ avec le passage par référence ou les pointeurs. En revanche cela ne fonctionne pas avec les types de valeurs. Si vous souhaitez passer un type de valeur par reference alors il faut le faire précéder du mot clé ref.

Il est important de préciser que le mot réservé ref doit être utilisé aussi bien dans la déclaration de la méthode que dans la méthode appelante.

Vous pouvez maintenant déclarer les champs age,ID,yearsServed dans la méthode appelante et les passer à la méthode GetStats et récupérer les valeurs modifiées en retour.

En  C# il est nécessaire d'initialiser les variables avant de les passer à la méthode GetStats (definite assignment). Il est possible d'éviter cette initialisation en utilisant le mot clé out. En utilisant le mot clé out  en C#, vous indiquez que la variable n'est pas initialisée et qu'elle est passée par référence.

Fred.GetStats(out age, out ID,out yearsServed);

Comme lors de l'utilisation du mot clé ref, le mot clé out doit être utilisé aussi bien dans la déclaration de la méthode que dans la méthode appelante.

Fred.GetStats(out age,out ID,out yearsServed);

7. Le mot clé "new"

En C++, le mot clé New instancie un objet sur le tas. Le langage C# fait de même avec les types de reference. Pour les types de valeurs comme les structures, l'objet est créé sur la pile et un constructeur est appelé.

Vous pouvez aussi créer une structure sur la pile sans utiliser le mot clé New, mais attention car New initialise l'objet. Ce qui veut dire que toutes les valeurs de structure doivent être initialisées à la main (avant le passage à une méthode).

using System; // Une structure simple avec 2 variables membres et un constructeur public struct Point {     public Point(int x, int y)     {         this.x = x;         this.y = y;     }     public int x;    public int y;  } public class Tester {     public static void Main()     {         Tester t = new Tester();         t.Run();     }     public void Run()     {         Point p1 =new Point (5, 12);         SomeMethod (p1);         Point p2;         // Création sans appeler la méthode New      // Ce code ne compilera pas car les variables de p2 n'ont pas été initialisées     //SomeMethod(p2);     // Initialisation des variables manuellement         p2.x = 1;         p2.y = 2;          SomeMethod(p2);      }       private void SomeMethod(Point p)     {         Console.WriteLine("Point at {0} x {1}",p.x, p.y);     } }

8. Les propriétés

En C++, les programmeurs essaient de garder les variables membres privées. C'est le principe même de l'encapsulation qui permet de modifier l'implémentation d'une classe sans en changer l'interface. Concrètement, le développeur C++ va créer des accesseurs permettant de modifier les valeurs de variables membres privées.

En C#, les propriétés sont les premiers membres d'une classe. Pour un client, une propriété ressemble à une variable membre mais pour le développeur de la classe il s'agit plutôt d'une méthode. Les propriétés favorisent  l'encapsulation et offrent au client un accès facilité aux membres de la classe.

Par exemple considérons une classe Employee avec une propriété Age permettant à un client de valoriser ou d'extraire l'age d'une employé.

public int Age {     get     {        return age;     }     set     {         age = value;     } }

Le mot clé value  est défini implicitement au travers de la propriété. Si vous écrivez

Fred.Age = 17;

le compilateur va attribuer à value la valeur 17.

Il est possible d'implémenter une propriété en lecture seule, il suffit de ne pas implémenter d'accesseur Set .

public int YearsServed {     get     {      return yearsServed;     } }

9. Les tableaux

Le C# propose une classe de gestion des tableaux plus complète que le tableau traditionnel C/C++. Par exemple, il est impossible d'écrire en dehors des limites d'un tableau. De plus C# propose une classe ArrayList dont la taille peut grossir dynamiquement en fonction des besoins du programme.

Il existe trois types de tableaux : unidimensionnel, multidimensionnel et des tableaux de tableaux (jagged array).

Vous pouvez créer un tableau à une dimension de la manière suivante :

int[] myIntArray = new int[5];

ou l'initialiser ainsi :

int[] myIntArray = { 2, 4, 6, 8, 10 };

Vous pouvez créer un tableau à deux dimensions de la manière suivante :

int[,] myRectangularArray = new int[rows, columns];

ou l'initialiser ainsi :

int[,] myRectangularArray = { {0,1,2}, {3,4,5}, {6,7,8}, {9,10,11} };

Comme les jagged array sont des tableaux de tableaux il est nécessaire de fournir uniquement une seule dimension.

int[][] myJaggedArray = new int[4][];

et ensuite de créér chacun des tableaux internes : 

myJaggedArray[0] = new int[5]; myJaggedArray[1] = new int[2]; myJaggedArray[2] = new int[3]; myJaggedArray[3] = new int[5];

Parce que les tableaux dérivent de l'objet System.Array, ils disposent de nombreuses méthodes parmis lesquelles Sort et Reverse .

Conclusion

A travers cet article nous avons abordé les principales différences entre le C# et le C++. Il en ressort que le passage au C# pour un développeur C++ expérimenté devrait se faire sans trop de difficultés la syntaxe se rapprochant beaucoup entre ces deux langages. Attention toutefois à ne pas tomber dans la facilité et à programmer en C# comme vous le feriez en C++ au risque d'avoir des comportements inattendus.

Remarque :
Il est tout à fait possible qu'il y ait des erreurs dans le document. Si vous en trouvez, ou bien souhaitez un peu plus d'explication sur certains points, veuillez m'envoyer un message privé via le forum afin de mettre à jour l'ensemble de ce document. D'avance merci.

Document réalisé par Leduke