La meilleure façon d'expliquer erreur déclarative en C ++?

StackOverflow https://stackoverflow.com/questions/1360880

  •  20-09-2019
  •  | 
  •  

Question

Comment peut-on concevoir une bonne explication des raisons pour lesquelles le code suivant est incorrect, en ce que l'auteur tente d'écrire le code C ++ déclarative plutôt que la procédure? 

const double NEWTONS_PER_POUND = 4.448;

int main()
{
   double pounds, newtons;
   pounds = newtons/NEWTONS_PER_POUND; /* pounds equals 'unassigned variable'/4.448 */
   newtons = 10.0;
   cout << pounds << endl;             /* a big number, not 10.0/4.448 */
   return 0;
}

L'auteur devrait cout pour afficher un calcul correct, mais obtient plutôt un « nombre fou. »

J'expliquer cela comme « C ++ est d'ordre procédural, et donc au moment de la déclaration 

pounds = newtons/NEWTONS_PER_POUND;

newtons n'a pas été attribué une valeur.

Les meilleures suggestions? Ou expliquer pourquoi C ++ ne suffit pas « intelligent » pour mener à bien le comportement de l'utilisateur par erreur attendu?

Était-ce utile?

La solution

Dites à l'auteur que 

pounds = newtons/NEWTONS_PER_POUND;

commandes de la CPU

  • prendre la valeur à l'adresse appelée « newtons »
  • prendre la valeur à l'adresse appelée « NEWTONS_PER_POUND »
  • les diviser
  • stocker le résultat à l'adresse appelée « livres »

ce qu'il cherche est très probablement une fonction en termes impératifs: 

double newtons_to_pounds(double newtons) {
  return newtons/NEWTONS_PER_POUND;
}

...

newtons = 10.0;
cout << newtons_to_pounds(newtons) << endl;    /* a big number, not 10.0/4.448 */
return 0;

Autres conseils

C ++ est un langage de programmation impératif et non une résolution d'équations.

C ++ exécute des instructions dans l'ordre que vous les écrivez. C ++ n'initialise pas les variables à moins qu'il soit dit. C ++ vous permet d'utiliser une variable dont la valeur n'a pas été initialisé, mais quand vous faites cela le résultat est non spécifié . un moyen non précisé que tout peut arriver, y compris les mauvaises choses comme la production de « chiffres fous ».

Voici l'explication détaillée: 

double pounds, newtons;
pounds = newtons/NEWTONS_PER_POUND;
newtons = 10.0;

La première instruction déclare deux variables sans les initialiser. A ce stade, leurs valeurs ne sont pas spécifiées.

La deuxième instruction lit la valeur de newtons (qui pourrait être quelque chose) et le divise par NEWTONS_PER_POUND. Le résultat (qui pourrait être quelque chose) est affecté à pounds.

La troisième déclaration newtons initialise, mais il est trop tard pour influer sur le calcul nous vient de réaliser.

Eh bien qui ne devrait pas être trop difficile à expliquer, quelles que soient les antécédents des élèves: il suffit de les Thell que C ++ évalue des programmes d'une étape à la fois, déclaration après déclaration (nonobstant les artefacts du compilateur tels que réordonnancement ...)

Il n'y a absolument rien de façon particulière à C ++ de manipulation cela, ni même limité à la programmation informatique -. Au contraire, il est un moyen de traiter tous les jours avec une liste ordonnée des instructions

Il est pas paresseux newtons évaluation

En tant que tel le calcul est effectué au moment de la déclaration, non pas au moment de la demande. Il est après le code fonctionnel, pas ce que C ++ fera.

Si la personne n'est pas trop technique, vous pouvez essayer:

« Les déclarations contenues dans ce programme C ++ sont comme les étapes nécessaires pour faire un gâteau. Vous devez effectuer les étapes une par une et ils doivent être à effectuer dans un certain ordre pour qu'il soit un succès. »

Expliquez que livres est attribué une valeur sur la ligne avec l'opérateur d'affectation: 

pounds = newtons/NEWTONS_PER_POUND;

Si tel était le cas contraire, mais livres a été évaluée quand il a été utilisé (comme la déclaration de Cout), puis, si la valeur de newtons changé, la valeur des livres changerait aussi. Puisque livres ne sont pas tout type de pointeur, mais est un simple entier, cela est impossible.

Qu'en est-il parcourant le code dans un débogueur?

il n'y a rien EMR comme celui-ci pour comprendre l'exécution d'un programme écrit dans un langage procédural (à savoir, calqué sur la façon dont la CPU exécute en fait le code).

Vous essayez d'obtenir l'auditeur de se soumettre à un changement de paradigme -. De changer / son approche entière pour comprendre ce code

  

« livres » est juste un nombre. Il n'y a pas eu   concept de la façon dont sa création. vous dites   « Livres » comment il est créé, il ne sera pas   rappelles toi. Il suffit de se rappeler ce que   il est, comment il est créé.

Il peut sembler un peu étrange de anthropomorphiser un bloc de mémoire. : -)

Prenons un exemple un peu plus complexe où une variable comme newtons est réutilisée et les valeurs affectées plus d'une fois. Par exemple: 

double pounds, newtons;

newtons = 10.0;
pounds = newtons/NEWTONS_PER_POUND;
cout << pounds << endl;

newtons = 15.0;
pounds = newtons/NEWTONS_PER_POUND;
cout << pounds << endl;

return 0;

Montrez-lui le code et la sortie. Ensuite, demandez-lui d'expliquer comment et pourquoi le programme produit un numéro différent pour chaque ligne. Je pense que cela devrait l'aider à pousser dans le sens de l'affichage du programme comme une procédure qui va de haut en bas.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top