De commencer la programmation en C ++ pour les nuls

En C ++, un aiguille est une variable qui contient l'adresse d'un objet dans la mémoire interne de l'ordinateur. Suivez ces étapes pour éviter les problèmes avec des pointeurs en C ++:

1. Initialiser pointeurs lorsqu'ils sont déclarés.

   Ne laissez jamais des variables de pointeur non initialisé - les choses ne seraient pas trop mal si pointeurs non initialisées contiennent toujours des valeurs aléatoires - la grande majorité des valeurs aléatoires sont des valeurs de pointeur illégale, elle provoquera un plantage du programme dès qu'ils sont utilisés. Le problème est que les variables non initialisées ont tendance à prendre de la valeur des autres variables de pointeur, utilisés précédemment. Ces problèmes sont très difficiles à déboguer.

   Si vous ne savez pas quoi initialiser un pointeur vers, initialiser à nullptr. nullptr est garanti d'être une adresse illégale.

2. Zéro sur pointeurs après que vous les utilisez.

   De même, toujours zéro une variable pointeur une fois que le pointeur est plus valable en lui attribuant la valeur nullptr. Ceci est particulièrement le cas lorsque vous revenez d'un bloc de mémoire sur le tas en utilisant Delete- zéro toujours le pointeur après le retour mémoire de tas.

3. Allouer de la mémoire à partir du tas et de le retourner au tas au même "niveau" pour éviter les fuites de mémoire.

   Toujours essayer de revenir un bloc de mémoire sur le tas au même niveau d'abstraction que vous lui étaient allouées. Cela signifie généralement que d'essayer de supprimer la mémoire au même niveau d'appels de fonction.

4. Attrapez une exception à supprimer la mémoire si nécessaire.

   Ne pas oublier qu'une exception peut se produire à presque tout moment. Si vous avez l'intention d'attraper l'exception et continuera exploitation (plutôt que de laisser le plantage du programme), assurez-vous que vous attrapez l'exception et retourner tous les blocs de mémoire sur le tas avant les pointeurs qui pointent vers eux sortent de la portée et de la mémoire est perdu.

5. Assurez-vous que les types correspondent exactement.

   Assurez-vous toujours que les types de pointeurs correspondent au type requis. Ne pas remanier un pointeur sans raison spécifique. Considérez ce qui suit:

fn (int * p) -annuler myFunc () {A'-char * pC char c = '= c-fn ((int *) PC) -}

La fonction ci-dessus compile sans plainte depuis le PC pointeur de caractère a été remanié à un int * pour correspondre à la déclaration de fn (int *) - cependant, ce programme sera presque sûrement pas travailler. La fonction fn () attend un pointeur vers une pleine entier de 32 bits et non pas quelque pacotille 8 bits omble. Ces types de problèmes sont très difficiles à démêler.

Les classes qui attribuent des ressources de leur constructeur devraient normalement inclure un constructeur de copie pour créer des copies de ces ressources. L'attribution d'un nouveau bloc de mémoire et copier le contenu de l'original dans ce nouveau bloc est connu comme la création d'un copie en profondeur (par opposition à la copie superficielle par défaut). Utilisez les étapes suivantes pour déterminer quand et comment faire des copies profondes en C ++:

1. Toujours faire une copie en profondeur si le constructeur alloue les ressources.

   Par défaut, C ++ fait soi-disant copies "peu profondes" Membre par membre d'objets lors de leur passage à des fonctions ou à la suite d'une cession. Vous devez remplacer les opérateurs de copie superficielle par défaut avec leur équivalent copie en profondeur pour toute classe qui alloue des ressources dans le constructeur. La ressource la plus commune qui obtient alloué est mémoire de tas qui est renvoyée par le nouvel exploitant.

2. Toujours inclure un destructeur pour une classe qui alloue les ressources.

   Si vous créez un constructeur qui alloue les ressources, vous devez créer un destructeur qui les restaure. Aucune exception.

3. Toujours déclarer le destructeur virtuel.

   Une erreur débutant commune est d'oublier de déclarer votre destructeur virtuel. Le programme se déroulera bien jusqu'à un programmeur méfiance arrive et hérite de votre classe. Le programme semble toujours travailler, mais parce que le destructeur de la classe de base ne peut être invoqué correctement, des fuites de mémoire de votre programme comme une passoire jusqu'à ce qu'il se bloque finalement. Ce problème est difficile à trouver.

4. Toujours inclure un constructeur de copie pour une classe qui alloue les ressources.

   Le constructeur de copie crée une copie correcte de l'objet courant par l'allocation de mémoire hors du tas et copier le contenu de l'objet source.

5. Toujours remplacer l'opérateur d'affectation pour une classe qui alloue les ressources.

   Les programmeurs devraient être dissuadés de les opérateurs primordiales, mais l'opérateur d'affectation est une exception. Vous devez remplacer l'opérateur d'affectation pour toute classe qui alloue des ressources dans le constructeur.

   L'opérateur d'affectation devrait faire trois choses:

1. Assurez-vous que l'objet de la main gauche et à droite ne sont pas le même objet. En d'autres termes, être sûr que le programmeur d'application n'a pas écrit quelque chose comme (A = A). Si elles sont, ne rien faire.

2. Appelez le même code que le destructeur de l'objet de la main gauche pour revenir ses ressources.

3. Appelez le même code comme un constructeur de copie pour faire une copie profonde de l'objet de la main droite dans l'objet de la main gauche.