Einführung in den parametrisierten Konstruktor in C++

Es gibt viele Methoden in C++. Aber parametrisierte Konstruktoren in C++ sind einige spezielle Arten von Methoden, die instanziiert werden, sobald ein Objekt erstellt wird. Daher sind in C++ zwei Arten von Konstruktoren definiert, nämlich der Standardkonstruktor und der parametrisierte Konstruktor. Es gibt einen winzigen Unterschied zwischen dem Standardkonstruktor und dem parametrisierten Konstruktor. Der Standardkonstruktor ist ein Konstruktortyp, der keine Argumente hat, aber ja, die Objektinstanziierung wird dort auch durchgeführt. Andererseits ist der parametrisierte Konstruktor, wie der Name schon sagt, eine spezielle Art von Konstruktor, bei dem ein Objekt erstellt wird und weitere Parameter an verschiedene Objekte übergeben werden.

Syntax:

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

class class_name {
Access Specifier:
Member - Variables
Member - Functions
public:
class_name(variables) {
// Constructor code
}
//... other Variables & Functions
}

Die Syntax lautet Class_name, gefolgt von einem Zugriffsbezeichner, der Mitgliedsvariablen und Mitgliedsfunktionen enthält. All dies enthält den gesamten Konstruktorcode, dh den Hauptteil des Konstruktors, in dem er auch aufgerufen werden kann.

Wie funktioniert der parametrisierte Konstruktor in C++?

Immer wenn ein parametrisierter Konstruktor gleichzeitig definiert wird, wird ein Objekt instanziiert, das Details oder die Werte und Parameter enthält, die das Objekt enthalten oder besitzen wird. Es wird eine mögliche Situation, Argumente an dieses Objekt zu übergeben. Um einen parametrisierten Konstruktor zu erstellen, müssen dem Objekt einfach Parameter als Wert hinzugefügt werden, so wie wir einen Wert an eine Funktion übergeben.

Ein ähnliches Szenario machen wir, indem wir die parametrisierten Werte an das mit der Klasse erstellte Objekt übergeben. Parameter werden verwendet, um die Objekte zu initialisieren, die im Körper des Konstruktors definiert sind. Immer wenn ein parametrisierter Konstruktor deklariert wird, sollten die Werte als Argumente an die Funktion des Konstruktors übergeben werden, d. h. die Konstruktorfunktion, da sonst die herkömmliche Art der Objektdeklaration nicht funktioniert. Diese Konstruktoren können sowohl implizit als auch explizit aufgerufen werden.

Die Verwendung parametrisierter Konstruktoren hat einige Verwendungszwecke oder Vorteile:

• Wenn Konstruktoren erstellt oder instanziiert werden, werden sie verwendet, um die verschiedenen Datenelemente verschiedener Objekte mit unterschiedlichen Werten zu initialisieren und zu speichern.
• Ein weiteres interessantes Szenario ist, dass sie zum Überladen von Konstruktoren verwendet werden.

Beispiele für parametrisierte Konstruktoren

Hier sind einige Beispiele für einen parametrisierten Konstruktor, der unten angegeben ist:

Beispiel #1

Code:

#include <iostream>
using namespace std;
class ParamA {
private:
int b, c;
public:
ParamA (int b1, int c1)
{
b = b1;
c = c1;
}
int getX ()
{
return b;
}
int getY ()
{
return c;
}
};
int main ()
{
ParamA p1(10, 15);
cout << "p1.b = " << p1. getX() << ", p1.c = " << p1.getY();
return 0;
}

Ausgabe:

Erklärung: In dieser Klasse enthält ParamA zwei Zugriffskennzeichner, einen als privaten Zugriffskennzeichner und einen als öffentlichen Zugriffskennzeichner. Der private Zugriffsspezifizierer beinhaltet eine Deklaration von zwei Variablen, die zu einem späteren Zeitpunkt aufgerufen und referenziert werden. Gefolgt von einem öffentlichen Zugriffsspezifizierer, bei dem die Konstruktorimplementierung gestartet wird. ParamA (int b1, int c1) bezieht sich auf die Konstruktorinitialisierung mit int b1 und int c1 als Parameter, die als Werte an das Objekt übergeben werden, das diese Werte später aufruft. Die Ausgabe erfolgt als 10 und 15 (Werte werden übergeben).

Beispiel Nr. 2

Code:

#include <iostream>
using namespace std;
class ParamCode {
public:
int x;
ParamCode (int i);
~ParamCode ();
};
ParamCode::ParamCode (int i) {
x = i;
}
ParamCode::~ParamCode() {
cout<< "Destructing those objects whose x value is " << x <<" \n";
}
int main () {
ParamCode t1(20);
ParamCode t2(15);
cout<< t1.x << " " << t2.x << "\n";
return 0;
}

Ausgabe:

Erklärung: In Beispiel 2 werden Destruktoren verwendet. Destruktoren werden erstellt, um den Cache zu entfernen, oder wir können die Geschichte eines Konstruktors sagen. Sobald ein Konstruktor erstellt und Werte für diese Konstruktoren initialisiert wurden, liegt es in der Verantwortung des Destruktors, sich um die Existenz des Konstruktors zu kümmern und seinen Verlauf automatisch zu entfernen, damit er keine Auswirkungen auf den neuen Konstruktor oder das Objekt hat, das benötigt wird erstellt.

In der Codeklasse Param werden zuerst die Konstruktoren initialisiert, indem ihr int 1 als Parameter gefolgt von einem Destruktor übergeben wird. Dann wird die Implementierung für den parametrisierten Konstruktor gestartet. Dann erfolgt die Implementierung der Destruktorklasse, die für die Zerstörung des Objekts und die Übergabe der Werte zuständig ist.

Beispiel Nr. 3

Code:

#include <iostream>
using namespace std;
class Professor {
public:
int id;
string name;
float salary;
Professor (int i, string n, float s)
{
id = i;
name = n;
salary = s;
}
void display ()
{
cout<<id<<" "<<name<<" "<<salary<<endl;
}
};
int main(void) {
Professor p1=Professor(10, "Aditya", 90000);
Professor p2=Professor(12, "Anu", 60000);
p1.display();
p2.display();
return 0;
}

Ausgabe:

Erklärung:  In diesem Beispiel wird eine Klasse „Professor“ deklariert, die einen Zugriffsspezifizierer als öffentlichen Typ enthält, gefolgt von Datenelementen als „int id“ und „string name“. Die Ausgabe, die die Implementierung des Konstruktors enthält, zeigt den Namen des Professors, die ID von an der Professor und das Gehalt, das er oder sie verdient. Daran können auch weitere Manipulationen vorgenommen werden.

Beispiel Nr. 4

Code:

#include<iostream>
#include<conio.h>
using namespace std;
class Easyexmple {
int j, k;
public:
Easyexmple (int m, int n) {
j = m;
k = n;
cout << "In this Constructor\n";
}
void Display () {
cout << "Values:" << j << "\t" << k;
}
};
int main () {
Easyexmple Object (30, 40);
Object.Display();
getch ();
return 0;
}

Ausgabe:

Erklärung:  Ein einfaches Klassenbeispiel wird deklariert, das den Zugriffsspezifizierer als öffentlich hat, und dann wird der Konstruktor initialisiert, um Werte zuzuweisen, und dann wird das Objekt erstellt, wo diese Werte übergeben werden, und in diesem Beispiel ergibt sich der Konstruktorwert als 30 und 40 bzw. je nach Eingabe der Werte oder Parameter an den Konstruktor.

Schlussfolgerung

Konstruktoren sind nichts anderes als eine spezielle Art von Methode, bei der wir die Werte übergeben können, wenn nicht, dann wird auch ein Wert an das Endobjekt übergeben. Das Objekt wird die Werte von Member-Variablen und Methoden enthalten, die Teil der Hauptklasse sind, und diese Werte werden schließlich mit Hilfe von Konstruktoren übergeben. Ein parametrisierter Konstruktor hat seinen eigenen Vorteil, dass er den verschiedenen Objekten unterschiedliche Werte gibt und sie auch überladen werden können.