{"id":27,"date":"2008-03-04T19:57:36","date_gmt":"2008-03-04T18:57:36","guid":{"rendered":"http:\/\/linux.leunen.com\/?p=27"},"modified":"2008-03-15T10:35:05","modified_gmt":"2008-03-15T09:35:05","slug":"redefinition-vs-surcharge","status":"publish","type":"post","link":"https:\/\/www.leunen.com\/linux\/2008\/03\/redefinition-vs-surcharge\/","title":{"rendered":"C++ – Red\u00e9finition vs surcharge"},"content":{"rendered":"

La confusion entre ces deux termes existe plus en anglais (overriding<\/em> vs overloading<\/em>)qu’en fran\u00e7ais. N\u00e9anmoins il est int\u00e9ressant de rappeler les diff\u00e9rences entre ces deux termes et leurs particularit\u00e9s surtout lorsque cela concerne des fonctions membres et qu’en plus, la red\u00e9finition ou la surcharge se fait dans une classe d\u00e9riv\u00e9e.
\nDans les deux cas, il s’agit d’avoir plusieurs fonctions avec le m\u00eame nom.
\nPrenons l’exemple d’une classe de base Base<\/em> qui poss\u00e8de deux fonctions f()<\/em> et g()<\/em> dont l’une est virtuelle.<\/p>\n

\r\nclass<\/span> Base\r\n{\r\n  public<\/span>:\r\n    void<\/span> f();\r\n    virtual<\/span> void<\/span> g();\r\n};<\/pre>\n
D\u00e9rivons maintenant une classe de notre classe Base<\/em> et cr\u00e9ons dans cette classe d\u00e9riv\u00e9e une fonction qui a la m\u00eame signature que nos fonctions dans la classe Base:<\/p>\n
\r\nclass<\/span> Derived1 : public<\/span> Base\r\n{\r\n  public<\/span>:\r\n    void<\/span> f();            \/\/ Red\u00e9finit Base::f()\r\n<\/span>    virtual<\/span> void<\/span> g();    \/\/ Red\u00e9finit Base::g()\r\n<\/span>};<\/pre>\n
La m\u00eame signature signifie que la fonction a le m\u00eame nom et les m\u00eames param\u00e8tres que la fonction originale. C’est bien le cas ici. f()<\/em> et g()<\/em> ont bien le m\u00eame nom et les m\u00eames param\u00e8tres (ou abscence de param\u00e8tre). Notez que pour avoir la m\u00eame signature qu’une fonction virtuelle, la fonction doit aussi \u00eatre virtuelle ce qui est bien le cas ici. La fonction h\u00e9rite de la classe de base son caract\u00e8re virtuel et donc, le virtual<\/em> devant la fonction pourrait \u00eatre omis. Cependant, c’est une bonne pratique que de le mettre ne fut-ce que pour des raisons de code bien document\u00e9.<\/p>\n
\r\nclass<\/span> Derived2 : public<\/span> Base\r\n{\r\n  public<\/span>:\r\n    void<\/span> f(int<\/span>);         \/\/ surcharge de Base::f()\r\n<\/span>    virtual<\/span> void<\/span> g(int<\/span>); \/\/ surcharge de Base::g()\r\n<\/span>};<\/pre>\n
Si comme dans notre classe Derived2<\/em>, le nom est le m\u00eame mais que la signature est diff\u00e9rente, on parle de surcharge de fonction.
\n Attention:<\/strong> dans le cas de Derived2<\/em>, les deux fonctions f()<\/em> et g()<\/em> non seulement surchargent les deux fonctions f()<\/em> et g()<\/em> de Base<\/em> mais en plus elles les cachent. Ce qui veut dire que f()<\/em> et g()<\/em> de Base<\/em> ne sont plus accessibles. Par exemple, vous ne pouvez plus \u00e9crire ceci:<\/p>\n
\r\nDerived2 d2;\r\nd2.f();                  \/\/ erreur Base::f() est cach\u00e9e\r\n<\/span><\/pre>\n
L’erreur donn\u00e9e par g++<\/em> est l’erreur: no matching function for call to Derived2::f()<\/code><\/p>\n
Si vous tenez \u00e0 pouvoir utiliser la fonction f()<\/em> dans la classe de base malgr\u00e9 le fait que la surcharge de cette fonction cache la fonction f()<\/em> dans Base<\/em>, vous devez r\u00e9\u00e9crire votre classe Derived2<\/em> de cette fa\u00e7on:<\/p>\n
\r\nclass<\/span> Derived2 : public<\/span> Base\r\n{\r\n  public<\/span>:\r\n    using<\/span> Base::f;       \/\/ permet d'utiliser Base::f()\r\n<\/span>    void<\/span> f(int<\/span>);         \/\/ surcharge de Base::f()\r\n<\/span>    virtual<\/span> void<\/span> g(int<\/span>); \/\/ surcharge de Base::g()\r\n<\/span>};<\/pre>\n
La clause using<\/em> vous permet de l’utiliser en sp\u00e9cifiant au compilateur qu’il s’agit de la fonction pr\u00e9sente dans la classe de base.<\/p>\n","protected":false},"excerpt":{"rendered":"
La confusion entre ces deux termes existe plus en anglais (overriding vs overloading)qu’en fran\u00e7ais. N\u00e9anmoins il est int\u00e9ressant de rappeler les diff\u00e9rences entre ces deux termes et leurs particularit\u00e9s surtout lorsque cela concerne des fonctions membres et qu’en plus, la red\u00e9finition ou la surcharge se fait dans une classe d\u00e9riv\u00e9e. Dans les deux cas, il […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[4],"tags":[],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t