Cela dépend de votre position dans le cycle de développement, mais parfois lorsque vous esquissez un algorithme, vous souhaitez effectuer une abstraction sur des blocs complexes sans les implémenter immédiatement.
def full_algo():
init_stuff()
process_stuff()
...
Vous savez comment ça init_stuff
va marcher, c'est assez simple dans votre tête mais vous n'en avez pas vraiment besoin tout de suite, donc vous le déclarez comme une fonction vide. Il permettra à votre code de se compiler et de s'exécuter sans se soucier des détails sanglants.
Une autre utilisation des applications publiées consiste à utiliser l'héritage. Supposons que vous ayez une grande classe qui définit le comportement du code spécifique à la plate-forme. Vous pourriez vous retrouver avec une logique similaire à celle-ci:
init_filesystem();
access_files();
release_filesystem();
Ce code fonctionnera sur de nombreuses plates-formes, mais certaines plates-formes peuvent ne pas nécessiter l'initialisation du système de fichiers. Ensuite, votre héritage ressemblera à ceci (virtuel avec = 0 en C ++ signifie simplement que les classes dérivées DOIVENT implémenter ces méthodes):
class FileSystem{
virtual void init_filesystem() = 0;
virtual void access_files() = 0;
virtual void release_filesystem() = 0;
};
Une implémentation particulière de cette classe (interface) pourrait alors ne rien faire pour certaines de ces méthodes. Alternativement, la classe de base pourrait déclarer des méthodes vides pour init / release au lieu de les déclarer virtuelles.
Enfin (et honteusement), vous maintenez parfois une application très ancienne. Vous craignez que la suppression de méthodes ne casse les choses. Cela se produit lorsque vous avez un héritage complexe qui n'est pas correctement compris ou lorsque vous avez beaucoup de pointeurs de fonction (rappels). Vous supprimez simplement le code à l'intérieur d'eux afin qu'ils soient appelés de toute façon sans rien casser.