C ++ surcharge de la fonction et la surcharge des opérateurs

En C ++ surcharge de fonction

Dans la même portée, vous pouvez déclarer plusieurs fonctions fonction similaire avec le même nom, mais ces paramètres formels (le nombre se réfère au type ou séquentiellement paramètre) fonction avec le même nom doit être différent. Vous pouvez non seulement en revenant aux différents types de fonctions surchargées.

Les exemples suivants, le même nom que la fonctionprint () est utilisée pour différents types de données de sortie:

#include <iostream>
using namespace std;
 
class printData 
{
   public:
      void print(int i) {
        cout << "Printing int: " << i << endl;
      }

      void print(double  f) {
        cout << "Printing float: " << f << endl;
      }

      void print(char* c) {
        cout << "Printing character: " << c << endl;
      }
};

int main(void)
{
   printData pd;
 
   // Call print to print integer
   pd.print(5);
   // Call print to print float
   pd.print(500.263);
   // Call print to print character
   pd.print("Hello C++");
 
   return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

En C ++ surcharge des opérateurs

Vous pouvez redéfinir ou remplacer la plupart du C ++ Les opérateurs intégrés. Cela vous permet d'utiliser les types d'opérateurs personnalisés.

L'opérateur est surchargé avec le nom de la fonction spéciale, le nom de la fonction est suivie par l'opérateur principal et l'opérateur pour remplacer les symboles. Et d'autres fonctions, les opérateurs surchargés ont un type de retour et la liste des paramètres.

Box operator+(const Box&);

Déclaration de l'opérateur d'addition pour deux objets Box sont ajoutés, la déclaration finale des objets Box. La plupart des opérateurs surchargés peuvent être définies comme des fonctions normales ou non-membres sont définies comme des fonctions de membre de classe. Si l'on définit la fonction ci-dessus en tant que classes de fonctions non-membres, alors nous avons besoin de passer deux paramètres pour chaque opération, comme suit:

Box operator+(const Box&, const Box&);

L'exemple suivant illustre le concept opérateur de surcharge de la fonction de membre. Ici, l'objet passé en paramètre, les propriétés d'un objet à l' aide decet opérateur est accessible comme suit:

#include <iostream>
using namespace std;

class Box
{
   public:

      double getVolume(void)
      {
         return length * breadth * height;
      }
      void setLength( double len )
      {
          length = len;
      }

      void setBreadth( double bre )
      {
          breadth = bre;
      }

      void setHeight( double hei )
      {
          height = hei;
      }
      // 重载 + 运算符，用于把两个 Box 对象相加
      Box operator+(const Box& b)
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
   private:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
};
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   Box Box3;                // 声明 Box3，类型为 Box
   double volume = 0.0;     // 把体积存储在该变量中
 
   // Box1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // Box2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // Box1 的体积
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // Box2 的体积
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // 把两个对象相加，得到 Box3
   Box3 = Box1 + Box2;

   // Box3 的体积
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

les opérateurs surchargés peuvent / ne peuvent pas être surchargés opérateurs

Ce qui suit est une liste des opérateurs peut être surchargé:

Ce qui suit est une liste d'opérateurs ne peut pas être surchargé:

Des exemples de surcharge des opérateurs

Ce qui suit fournit une variété d'exemples de l'opérateur surcharge pour vous aider à mieux comprendre le concept de surcharge.