Einführung in das Überladen von Funktionen in C ++
C ++ - Programmierung verfügt über erstaunliche Funktionen, und eine der wichtigsten Funktionen ist das Überladen von Funktionen. Dies bedeutet, dass ein Code mehr als eine Funktion mit demselben Namen, jedoch mit unterschiedlichen Argumentlisten hat. Die Argumentliste bezeichnet die Reihenfolge der Argumente und Datentypen der Argumente. Funktionsüberladung wird verwendet, um ähnliche Operationen durchzuführen. Es wird verwendet, um die Lesbarkeit des Codes zu verbessern. Funktion neu definiert, da es keinen Sinn macht, zwei verschiedene Funktionen zu erstellen, um dieselbe Arbeit immer wieder auszuführen.
Syntax
void add(int a, int b);
void add(float a, float b);
Beide haben die gleiche Funktion, aber die Argumente sind unterschiedlich. Wenn Sie also mit der gleichen Funktion verschiedene Datentypen addieren möchten, können Sie die Funktion zum Überladen von Funktionen für die Programmierung mit C ++ verwenden.
Hier ist der C ++ - Code, um das Überladen von Funktionen in der C ++ - Programmierung zu demonstrieren:
Code:
#include
using namespace std;
void print(int x) (
cout << " Here is the integer " << x << endl;
)
void print(double y) (
cout << " Here is the float " << y << endl;
)
void print(char const *v) (
cout << " Here is the character* " << v << endl;
)
int main() (
print(20);
print(20.30);
print("three");
return 0;
)
Verschiedene Möglichkeiten zum Überladen von Funktionen in C ++
Es gibt verschiedene Möglichkeiten, eine Funktion in der Programmiersprache C ++ zu überladen. Mal sehen, wie wir das machen können:
1. Funktionsüberladung
Erhöht die Lesbarkeit des Codes bei der Programmierung. Es kann definiert werden, dass 2 oder mehr Funktionen mit demselben Namen überladen werden, aber unterschiedliche Parameter werden als Funktionsüberladung bezeichnet.
Syntax:
DataType Functionname (parameter list)
(
Function body
)
Beispiel 1
Der folgende C ++ - Code demonstriert das Überladen von Funktionen durch Ändern der Anzahl der Argumente in der C ++ - Programmierung:
Code:
#include
using namespace std;
class Calculate (
public:
static int addition(int a, int b)(
return a + b;
)
static int addition(int a, int b, int c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
static int addition(int a, int b)(
return a + b;
)
static int addition(int a, int b, int c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
static int addition(int a, int b)(
return a + b;
)
static int addition(int a, int b, int c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)
Beispiel # 2
Hier ist der C ++ - Code, der das Überladen von Funktionen durch verschiedene Argumenttypen in der C ++ - Programmierung demonstriert:
Code:
#include
using namespace std;
class Calculate (
public:
int addition(int a, int b)(
return a + b;
)
float addition(float a, float b, float c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
int addition(int a, int b)(
return a + b;
)
float addition(float a, float b, float c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
int addition(int a, int b)(
return a + b;
)
float addition(float a, float b, float c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)
2. Überladen des Bedieners
In der Programmiersprache C ++ sind mehrere Operatoren integriert. Ein Codierer kann diese Operatoren verwenden, um diese eingebauten Operatoren zu überladen oder neu zu definieren. Es handelt sich um einen Polymorphismus zur Kompilierungszeit, bei dem ein überladener Operator zum Ausführen von Aufgaben für benutzerdefinierte Datentypen verwendet wird. Fast viele Operatoren können in der Programmiersprache C ++ überladen werden.
Syntax:
ReturnType Classname :: operator OperatorSymbol (parameter list)
(
Function body
)
Beispiel 1
Hier ist der C ++ - Code, um das Überladen von Operatoren in der C ++ - Programmierung zu demonstrieren:
Code:
#include
using namespace std;
class Demo
(
private:
int count;
public:
Demo(): count(5)()
void operator ++()
(
count = count+1;
)
void DisplayCount() ( cout<<"The Count is : "< );
int main()
(
Demo d;
// this calls void operator ++()" function
++d;
d.DisplayCount();
return 0;
)#include
using namespace std;
class Demo
(
private:
int count;
public:
Demo(): count(5)()
void operator ++()
(
count = count+1;
)
void DisplayCount() ( cout<<"The Count is : "< );
int main()
(
Demo d;
// this calls void operator ++()" function
++d;
d.DisplayCount();
return 0;
)
Beispiel # 2
Mal sehen, wie Funktionsüberladung tatsächlich funktioniert? bei der Programmierung mit C ++ Codierungsbeispielen:
Code:
#include
using namespace std;
void show(int);
void show(float);
void show(int, float);
int main() (
int x = 10;
float y = 255.5;
show(x);
show(y);
show(x, y);
return 0;
)
void show(int variable) (
cout << "The Integer number is : " << variable << endl;
)
void show(float variable) (
cout << "The Float number is: " << variable << endl;
)
void show(int variable1, float variable2) (
cout << "The Integer number is: " << variable1;
cout << " And The Float number is:" << variable2;
)
Code Erklärung:
Im obigen Code haben wir eine Funktion erstellt, um die Ausgabe verschiedener Datentypen anzuzeigen. Wenn Sie jedoch feststellen, dass der Funktionsname identisch ist und die Argumente unterschiedlich sind. Dann initialisierten wir eine Variable mit dem Namen x und wiesen ihr einen Wert und einen Wert zu, der auch der Gleitkommavariablen y zugewiesen wurde. Nachdem wir den Variablen x und y Werte zugewiesen haben, haben wir die gezeigte Funktion aufgerufen, um den Eingabewert auf dem Ausgabebildschirm anzuzeigen.
Wie man an den Funktionsnamen sieht, ist das Argument aber in allen drei Fällen unterschiedlich. Zuerst haben wir die Funktion show only integer variable aufgerufen, danach haben wir show function aufgerufen, um die Ausgabe nur für float variable anzuzeigen. Schließlich haben wir die show-Funktion aufgerufen, die sowohl Integer- als auch Float-Variablen enthält, um die Ausgabe auf dem Bildschirm als Ausgabe anzuzeigen.
So funktioniert die Funktion zum Überladen von Funktionen in der Programmiersprache C ++. Abhängig von verschiedenen Datentypen kann dieselbe Funktion verwendet werden, um ähnliche Vorgänge auszuführen.
Beispiel # 3
Hier ist der C ++ - Code, um das Überladen von Funktionen in der C ++ - Programmierung zu demonstrieren:
Code:
#include
using namespace std;
class X
( int x;
public:
X()()
X(int j)
(
x=j;
)
void operator+(X);
void display();
);
void X :: operator+(X a)
(
int n = x+ax;
cout<<"The addition of two objects is : "< )
int main()
(
X a1(505);
X a2(409);
a1+a2;
return 0;
)#include
using namespace std;
class X
( int x;
public:
X()()
X(int j)
(
x=j;
)
void operator+(X);
void display();
);
void X :: operator+(X a)
(
int n = x+ax;
cout<<"The addition of two objects is : "< )
int main()
(
X a1(505);
X a2(409);
a1+a2;
return 0;
)
Code Erklärung:
Im obigen Code haben wir eine Klasse X und eine Ganzzahlvariable x erstellt und dann zwei Konstruktoren deklariert, damit wir keine Objekte zum Aufrufen der Funktion erstellen müssen, da der Konstruktor ein neu erstelltes Klassenobjekt unmittelbar nach der Zuweisung eines Speichers automatisch initialisiert . Es werden zwei Funktionen für Operator und Display erstellt, um das Hinzufügen von zwei Objekten mithilfe von Funktionsüberladungskonzepten in unserem Code anzuzeigen.
Fazit
Zusammenfassend lässt sich sagen, dass die Funktion zum Überladen von Funktionen in C ++ auf verschiedene Arten verwendet werden kann, um die Lesbarkeit von Code zu verbessern. Dies spart Speicherplatz und Kompilierungszeit beim Programmieren mit der C ++ - Sprache. Das Konzept des Polymorphismus zur Kompilierungszeit wird auch durch Überladungskonzepte für Operatoren eingeführt, bei denen nahezu jeder Operator überladen werden kann.
Empfohlene Artikel
Dies ist eine Anleitung zum Überladen von Funktionen in C ++. Hier werden die verschiedenen Möglichkeiten zum Überladen von Funktionen in C ++ zusammen mit verschiedenen Beispielen und Codeimplementierungen erläutert. Sie können auch den folgenden Artikel lesen, um mehr zu erfahren -
- Wie funktioniert die rekursive Funktion in C ++?
- Top 3 Datentypen in C ++
- Beispiele für das Überladen und Überschreiben in C ++
- String Array in C ++ ein Array aus mehreren Strings