Parfois, j'ai ressenti la surcharge de la méthode peut créer une confusion.
class a {
public:
void copyFloat(float f);
void copyDouble(double d);
};
6 Réponses :
Surcharge avec certitude.
D'accord, il n'est donc pas "évident" quelle fonction est appelée (arguable) ... alors quoi? Vous ne vous souciez pas de prendre différents types de paramètres, il doit simplement faire sa chose. Si vous avez un comportement différent basé sur différentes surcharges, vous avez abusé des surcharges, non signalé une faille entre eux. P>
Un exemple de surcharges abusifs: P>
// good:
struct has_properties
{
void property1(float); // set property1, which happens to be a float
void property2(int); // set property2, which happens to be an int
};
// bad:
struct has_properties
{
void property(float); // set property1, abusing that it's a float
void property(int); // set property2, abusing that it's an int
};
Certes, dans le cas du flotteur par rapport à deux fois vous ne devriez pas la surcharge, il est l'erreur trop sujette. J'ai entendu des gens affirment que vous devriez toujours utiliser des noms différents dans des cas comme ceux-ci juste pour être tout à fait les choses explicites et de faire aussi clair que possible au lecteur et je plutôt d'accord.
Alors toutes les fonctions mathématiques dans
Ouais clairement que ne serait pas bon, je pense que l'exemple que vous avez envoyé plus le long des lignes de ce que les gens s'inquiètent. Si la surcharge fait vraiment pour que l'utilisateur n'a pas à se soucier de quel type il est parce que la bonne chose va se faire de toute façon alors c'est bon, mais s'il y a un comportement différent qui se produit en fonction de ce type, il est c'est là que les choses peuvent obtenir subtile. Comme vous le soulignez ce qui est vraiment un abus de surcharge.
Si vous faites essentiellement la même chose avec les deux fonctions, elles diffèrent simplement dans leurs arguments de type, il pourrait également avoir plus de sens d'utiliser des modèles et de ne pas utiliser la surcharge du tout.
Je voudrais mettre cela dans un commentaire, mais je ne peux pas encore. Puisque vous avez marqué cela comme C ++, je pensais que je devrais vous dire que les méthodes sont généralement appelées fonctions en C / C ++.
méthode est un langage terme agnostique et fait référence aux sous-programmes / fonctions associées à une classe dans la programmation orientée objet. L'utilisation est correcte ici.
Essayez d'éviter d'utiliser des méthodes virtuelles multiples avec le même nom. Ou vous voudrez probablement les remplacer tous dans les classes dérivées. Regardez l'exemple suivant:
#include <string>
struct Base {
virtual void foo(const std::string& arg) {
}
virtual void foo(int arg) {
}
};
struct Derived : Base {
// Only std::string version is overriden.
virtual void foo(const std::string& arg) {
}
};
int main() {
Derived d;
// This fails to compile because the name lookup stops
// after Derived::foo has been found.
d.foo(42);
}
Vous pouvez apporter une fonction de classe de base dans la portée dérivée en incluant un en utilisant la déclaration . Toute surcharge de FOO dans base qui ne sont pas remplacées dans dérivées sont maintenant accessibles. Ce qui suit compilera: struct dérivé: base {à base de base :: foo; Vide virtuel FOO (const std :: string & arg) {}};
Fonctions surchargées est l'approche C ++ pour les fonctions de regroupement qui sont semblables sur leur comportement.
do_it (A a, B b); do_it (B b, int i = 0);