Introduction à Copy Constructor en C #

Le constructeur, qui copie des variables d'un autre objet et crée un nouvel objet, est appelé constructeur de copie. En C #, le constructeur de copie est également un constructeur paramétré. Un constructeur paramétré est un constructeur qui contient un paramètre du même type de classe. Le constructeur de copie est utile chaque fois que nous voulons initialiser une nouvelle instance aux valeurs d'une instance existante. Ainsi, le constructeur Copy est un constructeur qui envoie essentiellement les valeurs d'un objet à un autre objet sans affecter les valeurs de l'objet existant.

Comment fonctionne Copy Constructor en C #?

En C #, nous pouvons utiliser un constructeur de copie si nous voulons auditer une classe ou se souvenir des anciennes valeurs de classe. C # ne fournit pas de constructeur de copie. Cependant, nous pouvons utiliser un constructeur de copie avec un autre constructeur.

Syntaxe
class Name (
// Parameterized Constructor
public Name(parameters)
(
// code
)
public Name(Name instance of class) //copyconstructor
(
//code
)
)

Le nom du constructeur est identique à son nom de classe. Méthode La signature du constructeur se compose du nom de la méthode et de sa liste de paramètres. Il peut y avoir n'importe quel nombre de constructeurs dans une classe. Le constructeur de copie n'est pas le seul constructeur d'une classe. Un autre constructeur est requis avec un constructeur de copie pour créer un objet. Voici l'exemple qui montre comment utiliser le constructeur de copie pour une classe.

Exemple 1: sans constructeur de copie

Code

class Demo
(
//variables
string name;
int age;
public Demo(string name, int age) //parameterized constructor
(
this.name = name;
this.age = age;
)
public void getData()
(
Console.WriteLine("Name is:(0)", name);
Console.WriteLine("Age is:(0)", age);
)
)
class Program
(
// Main method
static void Main(string() args)
(
Demo obj = new Demo("John", 20);
obj.getData();
Console.ReadLine();
)
)

Dans l'exemple ci-dessus, il n'y a qu'un seul constructeur paramétré qui a deux variables. getData () est utilisé pour afficher les valeurs de l'objet.

Production:

Avec Copy Constructor

Code

class Demo
(
string name;
int age;
public Demo(string name, int age) //paramertrized constructor
(
this.name = name;
this.age = age;
)
public Demo(Demo d) //copy constructor
(
this.name = d.name;
this.age = d.age;
)
public void getData()
(
Console.WriteLine("Name is:(0)", name);
Console.WriteLine("Age is:(0)", age);
)
)
class Program
(
//main method
static void Main(string() args)(
Demo obj = new Demo("John", 20);
obj.getData();
Demo obj1 = new Demo(obj); //new object
obj1.getData();
Console.ReadLine();
)
)

Dans l'exemple ci-dessus, Demo est une classe qui contient deux constructeurs. Un constructeur de copie est toujours utilisé avec un autre constructeur. Un constructeur de copie envoie les propriétés de nom et d'âge d'un objet à un autre objet. Ci-dessous est la sortie du programme ci-dessus. Comme les premières valeurs concernent l'objet existant et le constructeur de copie, copiez ces valeurs et créez un nouvel objet avec les mêmes valeurs que celles de l'objet existant.

Exemple 2

Code

class pen
(
// variables
private string name;
private string color;
private int price;
// Copy constructor
public pen(pen a)
(
name = a.name;
color = a.color;quantity = a.price;
)
// Parameterized constructor
public pen(string name, string color, int price)(
this.name = name;
this.color = color;
this.quantity =price;
)
public void getPendetails()
(Console.WriteLine("Name is:(0)", name);
Console.WriteLine("color is:(0)", color);
Console.WriteLine("price is:(0)", price);
)
// Main Method
public static void Main()
(
// Create a new object.
pen p1 = new pen("Parker", "Blue", 30);
pen p2 = new pen(p1);
p2.getPendetails();
Console.ReadLine();
))
)

Dans le programme ci-dessus, nous initialisons trois variables pour un stylet de classe qui définit les propriétés de la classe. Le constructeur de copie copie les propriétés d'un stylo d'un objet à un autre. La fonction main () initialise un objet avec les valeurs comme paramètres pour le constructeur paramétré. Ensuite, les valeurs sont affichées à l'aide de getPendetails (). Le nouvel objet n'affecte pas les valeurs d'objet existantes. La sortie est montrée ci-dessous

Production:

Exemple 3

Code

class Calculate
(
//variables
private int a;
private int b;
public Calculate(int x, int y) // parameterized constructor
(
a = x;
b = y;
)
public Calculate(Calculate cal) //copy constructor
(
a = cal.a;
b = cal.b;
)
public int getSum()
(
return a + b;
)
)
class Sum
(
// main method
static void Main(string() args)
(
// create a new object
Calculate c1 = new Calculate(34, 4);
Calculate c2 = new Calculate(c1);
c2.getSum();
Console.ReadLine();
)
)

Maintenant, comprenons le programme ci-dessus.

La classe contient les variables a et b et deux constructeurs c'est-à-dire un constructeur paramétré et un constructeur de copie.

Code

class Calculate
(
//variables
private int a;
private int b;
public Calculate(int x, int y) //parameterized constructor
(
a = x;
b = y;
)
public Calculate(Calculate cal) //copy constructor
(
a = cal.a;
b = cal.b;
)
public int getSum()
(
return a + b;
)
)

Le constructeur de copie envoie les valeurs de cal cal dans a et b. La fonction gets () renvoie la somme de a et b. Le main () est dans la classe Sum qui initialise le c1 en tant que paramètres, puis copie le constructeur qui reçoit la valeur de l'objet c1 vers l'objet c2. La somme de a et b s'affiche à l'aide de getSum ().

Code

class Sum
(
// main method
static void Main(string() args)
(
Calculate c1 = new Calculate(34, 4);
Calculate c2 = new Calculate(c1);
c2.getSum();
Console.ReadLine();
)
)

Production:

Règles pour copier le constructeur en C #

  • Le nom du constructeur de copie doit être le même que le nom de la classe.
  • Un autre constructeur est requis avec un constructeur de copie pour copier un objet.
  • Il n'y a pas de type de retour de constructeur de copie.
  • Le constructeur de copie ne peut pas être final, statique et abstrait.

Conclusion

Ainsi, chaque fois que vous souhaitez copier une valeur d'objet vers d'autres objets, vous pouvez utiliser un constructeur de copie. C'est une façon de dire au compilateur comment copier les valeurs d'un objet dans un autre objet. Cela se produit lorsque nous transmettons des paramètres à un objet. L'interface ICloneable est également utilisée en ajoutant une méthode Clone à votre classe qui fait une copie de l'objet existant. Dans le constructeur de copie, vous pouvez spécifier un comportement personnalisé en donnant un ID unique ou en copiant certains champs obligatoires et pas d'autres.

Articles recommandés

Cela a été un guide pour copier le constructeur en C #. Ici, nous discutons comment fonctionne le constructeur de copie en C #, avec les règles, la syntaxe et l'exemple de code approprié. Vous pouvez également parcourir nos articles pour en savoir plus-

  1. Instruction C # if
  2. Boucle Do # while
  3. Fonctions C #
  4. Copier le constructeur en C ++ avec un exemple
  5. Introduction à Constructor en C
  6. Types de constructeur en C # avec implémentation de code

Catégorie:

Développement de logiciels