Le contrôle d'avertissement atteint la fin de la fonction non-vide

Lorsque nous écrivons les programmes en C++. Après avoir exécuté des programmes, nous obtenons parfois l'erreur: «AVERTISSEMENT: le contrôle atteint la fin de la fonction non-vide», ce qui signifie que certaines fonctions qui devraient renvoyer certaines valeurs atteignent la terminaison. Il pourrait ne pas donner de valeur plus tard. Pour le moment, il est bon de voir si chaque flux de contrôle contient ou non une valeur de retour. Pour reconnaître cette faute, nous devons d'abord reconnaître le fonctionnement du compilateur.

Il existe deux variétés d'inexactitudes qui se produisent lors de l'exécution d'un programme.

Erreurs de temps de compilation: Défaut qui peut être reconnu à l'aide de l'utilisation du compilateur sans exécuter le code. Habituellement, ce sont des erreurs de syntaxe qui sont reconnues sans exécuter le code.

Erreurs d'exécution: Défaut qui se produit pendant que la syntaxe du programme est exacte; Cependant, il y a un peu de problème pendant que le code s'exécute. Habituellement, l'accès à la réminiscence invalide des boucles illimitées tombe en dessous des erreurs d'exécution.

Cet article parlera de problèmes communs confrontés aux novices et aux programmeurs qualifiés en outre. Nous exécutons souvent dans la prudence indiquant la prudence: «Le contrôle atteint la fin de la fonction non-vide». Habituellement, nous négligeons cette erreur en raison du maximum du temps car le programme exécute néanmoins la même chose, même en supposant que cette prudence arrive.

Obtenez le message d'avertissement:

La compilation de ce code s'exécute, mais une erreur se produit, ce qui montre que le "contrôle d'avertissement atteint la fin de la fonction non-vOID '. Chaque fonction contient un type de retour qui montre le type de valeur que la fonction peut être renvoyée. Si la méthode ne renvoie aucune valeur, c'est loin d'être un type de retour vide. Nous obtenons l'erreur ci-dessus, tandis que la fonction non-vide ne renvoie pas la valeur.

#inclure
Utilisation de Namespace Std;
int f ()
si (faux)
retour 0;

int main()
F();
retour 0;

Dans ce cas, nous intégrons d'abord le fichier d'en-tête et utilisons la norme de l'espace de noms. De plus, nous appliquons la déclaration IF. Parfois, cela peut être la situation que nous avons de nombreuses instructions IF IF et toutes les instructions contiennent la valeur de retour; Cependant, s'il n'y a aucune affirmation d'autre, nous pouvons néanmoins obtenir l'erreur en raison du fait que le compilateur n'a pas pu comprendre que chaque situation est couverte.

Ici, nous n'obtenons rien en sortie, donc cela signifie que le code est exécuté avec succès, mais la fonction ne renvoie aucune valeur.

Utiliser la déclaration if:

Dans ce cas, si la condition n'est généralement pas vraie et, par conséquent, elle arrêtera la fonction «f» privée de renvoyer une valeur. Et c'est la raison de la réception du message d'attention. Le contrôle dans le message d'attention montre le flux de ce code. Vérinons maintenant s'il s'agit d'une erreur d'exécution ou d'une erreur de temps de compilation. L'avertissement que nous obtenons ici est détecté au moment de l'assemblage, l'utilisation simplement de la syntaxe de ce code et le code n'est pas toujours définitivement exécuté pour tester si elle réalise de loin la fin de toute méthode non vide.

#inclure
Utilisation de Namespace Std;
int f (int a)
si un < 8)
retour 0;

int main()
f (3);
retour 0;

Nous sommes toujours assurés que si nous exécutons le code, il renvoie la valeur 0; Cependant, néanmoins, nous pouvons obtenir le même message de mise en garde en raison du fait que le compilateur ne fonctionne pas assez intelligemment pour reconnaître au moment de la compilation qu'une fois ce code exécuté, il va renvoyer la valeur à chaque fois. Le compilateur vérifie simplement la syntaxe du code, et il traduit que pour la fonction «f» si la condition définie n'est pas vraie, le flux de ce code atteindra la ligne huit, et il n'a pas pu retourner la valeur, et donc nous obtenir l'erreur.

Après avoir compilé le programme, en sortie, nous n'obtenons rien en raison de l'erreur que «le contrôle atteint la fin de la fonction non-vide».

Utilisez les instructions de retour:

Lorsque les instructions conditionnelles ne doivent pas inclure de déclarations de retour, le contrôle passe à la fin d'une fonction non-VOID d'une autre manière. Par conséquent, si la mise en œuvre dans la méthode non-VOID est séparée et que si les instructions ne pouvaient pas exécuter chaque chemin, alors à la fin, nous devons appeler explicitement «retour» pour la fonction.

L'instance suivante valide la fonction de traitement des chaînes ayant des chemins conditionnels. Ici, nous incluons trois bibliothèques à des fins différentes, et après cela, nous déclarons une fonction. D'un autre côté, quelques instances ne sont plus évaluées maintenant pour la condition définie, ce qui signifie que le flux de contrôle peut atteindre le cesseur de la fonction et produire des erreurs.

Ici, nous avons défini la fonction «reverser». Nous passons la chaîne et la condition sous forme de paramètres à cette fonction. Le corps de fonction ne contient aucune instruction de retour. Cependant, il ne contient aucun argument pour appeler la fonction. Donc le compilateur affiche juste le message de prudence. Si nous appelons la fonction, alors nous n'obtenons pas l'erreur.

Conclusion:

Dans cet article, nous obtenons des informations sur l'erreur: «Le contrôle atteint la fin de la fonction non-vide» et voyons comment nous obtenons cette erreur. La méthode non-vide contient le type de retour. Ainsi, la méthode veut avoir une déclaration qui renvoie les éléments du type résultant. Si des normes de compilateur définies sont acceptées, cette erreur peut être complètement réprimée, conduisant à des erreurs d'exécution si la méthode spécifiée appelle dans le code.