Qu'est-ce que la surcharge en C ++?
C ++ permet d'écrire du code flexible et facile à comprendre en utilisant le concept connu sous le nom de surcharge. Il permet d'obtenir différentes fonctionnalités au sein du code existant avec des modifications très minimes, en réduisant ainsi le code en double. Fondamentalement, il existe principalement deux types principaux de surcharge qui sont pris en charge par C ++.
C ++ nous permet d'écrire des fonctions avec le même nom mais avec la différence de types de données ou du nombre d'arguments qui lui sont transmis, cette fonctionnalité est connue sous le nom de surcharge de fonction en C ++. Cette fonctionnalité permet aux développeurs de définir les fonctions avec le même nom dans la même portée. Avec le même nom, les fonctions représentent la même fonctionnalité permettant ainsi d'obtenir un polymorphisme au moment de la compilation. La surcharge de fonctions présente un avantage car elle améliore la lisibilité du code.
Il existe une autre fonctionnalité fournie en C ++ qui permet de redéfinir la fonctionnalité existante des opérateurs intégrés, connue sous le nom de surcharge d'opérateur . Cette fonctionnalité permet d'utiliser des opérateurs intégrés sur des types définis par l'utilisateur. La surcharge de l'opérateur simplifie le code en redéfinissant la fonctionnalité selon les besoins de l'utilisateur. Dans cet article, nous nous concentrerons sur la surcharge de la fonction et la surcharge de l'opérateur, nous en verrons les détails et comment il est utilisé en C ++.
Comment fonctionne la surcharge en C ++?
- Surcharge de fonction: Il nous permet de définir la fonction avec le même nom, mais il distingue les fonctions en fonction du type de paramètres qui leur est transmis ou du nombre de paramètres qui leur sont transmis. Ainsi, toutes les fonctions auront le même nom mais auront soit un type de données différent, soit un nombre différent de paramètres qui lui seront transmis. Lorsque la fonction est appelée, le compilateur choisira la fonction avec le type de paramètre correspondant et le nombre d'arguments correspondant. Ses développeurs peuvent désormais choisir la fonction à appeler en fonction des besoins. Ils peuvent choisir la fonction appropriée en passant les paramètres en suivant les règles.
- Surcharge d'opérateur: il permet aux opérateurs de travailler pour les types de données définis par l'utilisateur, c'est-à-dire les classes. Les opérateurs existants sont surchargés et ont le pouvoir de fonctionner sur la classe et les objets définis par l'utilisateur. La surcharge de l'opérateur est obtenue en définissant la fonction avec le nom spécial. La fonction aura le nom 'opérateur' suivi du symbole opérateur. Nous pouvons utiliser le symbole de l'opérateur directement sur le type de données défini par l'utilisateur et effectuer l'opération. L'action ou l'opération nécessaire est définie par nous dans cette fonction spéciale. Au moyen d'une surcharge d'opérateur, nous pouvons effectuer des opérations de différents types sur le même type de type de données.
Types de surcharge en C ++
La surcharge de fonction peut être obtenue de toute façon en termes d'utilisation des paramètres. Lorsque nous disons utilisation de paramètres, il s'agit du type de paramètres ou du nombre de paramètres ou de la séquence de paramètres. Ainsi, la fonction calc (int x, float y) ayant des paramètres (int x, float y) est différente d'une fonction définie comme calc (float x, int y) qui ont des paramètres différents avec le type de données différent.
Il peut y avoir un certain nombre de types dans lesquels la surcharge de fonction peut être réalisée, Voyons l'exemple simple de surcharge de fonction en C ++.
#include
using namespace std;
class Display (
public:
static void show (char message() ) (
cout<< "Only Message:" << message << endl;
)
static void show (int messageId, char message()) (
cout<< "Message with Id:";
cout << messageId << " Message:" << message << endl;
)
);
int main (void) (
Display obj;
char message() = "Welcome";
int messageId = 10;
obj.show(message); //calling overloaded function with 1 parameter
obj.show(messageId, message);//calling overloaded function with 2 parameters
return 0;
)
Ici, nous avons la classe Display qui a une méthode surchargée. La méthode show sera appelée en fonction des arguments qui lui sont passés.
Production:
Seul message: Bienvenue
Un message avec Id: 10 Message: Bienvenue
La surcharge de l'opérateur peut être réalisée sur presque tous les types de données intégrés disponibles en C ++. Il n'y a pas en tant que tels différents types de surcharge de l'opérateur, mais les approches peuvent être différentes et utilisées pour obtenir une surcharge de l'opérateur. Les opérateurs tels que Unary, Binary, Relational, Assignment, etc. peuvent être surchargés en C ++.
Voyons l'exemple simple de surcharge de l'opérateur ++. Dans cet exemple, au lieu du type de données primitif, nous utiliserons l'opérateur ++ sur l'objet de classe défini par l'utilisateur.
#include
using namespace std;
class Bike (
private:
int height;
public:
Bike (): height (80) () //constructor which initializes the height variable
void operator ++() (
height = height + 5;
)
void Specs () (
cout << "The height of the bike is: " < )
);
int main(void)
(
Bike bike;
bike.Specs();
++bike; //calling overloaded operator
bike.Specs();
return 0;
)#include
using namespace std;
class Bike (
private:
int height;
public:
Bike (): height (80) () //constructor which initializes the height variable
void operator ++() (
height = height + 5;
)
void Specs () (
cout << "The height of the bike is: " < )
);
int main(void)
(
Bike bike;
bike.Specs();
++bike; //calling overloaded operator
bike.Specs();
return 0;
)
Donc, nous avons un objet dont la hauteur initiale sera fixée à 80 et sera augmentée de 5 lorsque nous appelons l'opérateur ++ dessus.
Production:
La hauteur du vélo est: 80
La hauteur du vélo est: 85
Règles de surcharge en C ++
Voici les différentes règles de surcharge C ++ comme suit:
Règles pour la surcharge de fonction
- En cas de surcharge de fonction, la fonction doit différer en termes de type de données, de nombre ou de séquence de paramètres. Il ne peut pas différer simplement sur la base du type de fonction de retour.
Règles de surcharge de l'opérateur
- Seuls les opérateurs intégrés peuvent être surchargés, les nouveaux opérateurs ne peuvent pas être surchargés.
- Il y a quatre opérateurs qui ne peuvent pas être surchargés, ce sont . (sélection de membres), :: (résolution de portée), . * (sélection de membres utilisant un pointeur pour fonctionner) et?: (opérateur ternaire).
- L'opérateur surchargé contiendra au moins un opérande du type de données défini par l'utilisateur.
- Certains opérateurs ne peuvent pas être surchargés à l'aide de la fonction friend, mais ils peuvent être surchargés en tant que fonction membre.
Conclusion
Ainsi, la surcharge en C ++ est la caractéristique unique qui nous offre de multiples avantages. Il existe principalement deux types de surcharge, à savoir la surcharge de fonction et la surcharge de l'opérateur. La surcharge de fonctions améliore la lisibilité du code, conservant ainsi le même nom pour la même action. La surcharge des opérateurs permet de redéfinir les fonctionnalités existantes des opérateurs en leur donnant ainsi une signification particulière. Les deux sont très utiles dans la programmation en C ++.
Articles recommandés
Ceci est un guide de surcharge en C ++. Nous discutons ici de son fonctionnement, de ses règles et de deux types de surcharge en c ++, à savoir la surcharge de fonctions et la surcharge d'opérateurs. Vous pouvez également consulter l'article suivant pour en savoir plus -
- Surcharge en PHP
- Copier le constructeur en C ++
- Surcharge vs remplacement
- Instruction Switch en C ++
- Surcharge en Java
- Surcharge Python