Quels sont tous les comportements non définis communs qu'un programmeur C ++ devrait connaître? [fermé]

Quels sont tous les comportements non définis communs qu'un programmeur C ++ devrait connaître?

Dites, comme:

a[i] = i++;

Aiguille

• Déréférencer un NULLpointeur
• Déréférencer un pointeur renvoyé par une "nouvelle" allocation de taille zéro
• Utilisation de pointeurs vers des objets dont la durée de vie est terminée (par exemple, empiler des objets alloués ou des objets supprimés)
• Déréférencer un pointeur qui n'a pas encore été définitivement initialisé
• Exécution d'une arithmétique de pointeur qui donne un résultat en dehors des limites (au-dessus ou en dessous) d'un tableau.
• Déréférencer le pointeur à un emplacement au-delà de la fin d'un tableau.
• Conversion de pointeurs en objets de types incompatibles
• Utilisation memcpypour copier des tampons qui se chevauchent .

Débordements de tampon

• Lecture ou écriture sur un objet ou un tableau avec un décalage négatif ou supérieur à la taille de cet objet (débordement de pile / tas)

Débordements entiers

• Débordement d'entier signé
• Évaluation d'une expression qui n'est pas définie mathématiquement
• Décalage à gauche des valeurs par un montant négatif (les décalages à droite par des montants négatifs sont définis par l'implémentation)
• Décaler les valeurs d'une quantité supérieure ou égale au nombre de bits du nombre (par exemple, int64_t i = 1; i <<= 72n'est pas défini)

Types, distribution et const

• Transformer une valeur numérique en une valeur qui ne peut pas être représentée par le type cible (directement ou via static_cast)
• Utiliser une variable automatique avant qu'elle ne soit définitivement attribuée (par exemple, int i; i++; cout << i;)
• Utilisation de la valeur de tout objet de type autre que volatileousig_atomic_t à la réception d'un signal
• Tentative de modification d'un littéral de chaîne ou de tout autre objet const au cours de sa durée de vie
• Concaténation d'un littéral de chaîne étroite avec une chaîne large pendant le prétraitement

Fonction et modèle

• Ne pas retourner une valeur à partir d'une fonction de retour de valeur (directement ou en sortant d'un bloc try)
• Plusieurs définitions différentes pour la même entité (classe, modèle, énumération, fonction inline, fonction membre statique, etc.)
• Récursion infinie dans l'instanciation de modèles
• Appel d'une fonction à l'aide de différents paramètres ou liaison aux paramètres et liaison que la fonction est définie comme utilisant.

OOP

• Destructions en cascade d'objets avec une durée de stockage statique
• Résultat de l'affectation à des objets se chevauchant partiellement
• Rentrée récursive d'une fonction lors de l'initialisation de ses objets statiques
• Faire des appels de fonctions virtuelles aux fonctions virtuelles pures d'un objet à partir de son constructeur ou destructeur
• Se référant à des éléments non statiques d'objets qui n'ont pas été construits ou qui ont déjà été détruits

Fichier source et prétraitement

• Un fichier source non vide qui ne se termine pas par une nouvelle ligne ou se termine par une barre oblique inverse (avant C ++ 11)
• Une barre oblique inverse suivie d'un caractère qui ne fait pas partie des codes d'échappement spécifiés dans une constante de caractère ou de chaîne (ceci est défini par l'implémentation en C ++ 11).
• Dépassement des limites d'implémentation (nombre de blocs imbriqués, nombre de fonctions dans un programme, espace de pile disponible ...)
• Valeurs numériques du préprocesseur qui ne peuvent pas être représentées par un long int
• Directive de prétraitement sur le côté gauche d'une définition de macro de type fonction
• Génération dynamique du jeton défini dans une #ifexpression

Être classé

• Appel de exit lors de la destruction d'un programme avec une durée de stockage statique

L'ordre dans lequel les paramètres de fonction sont évalués est un comportement non spécifié . (Cela ne fera pas planter votre programme, exploser ou commander une pizza ... contrairement au comportement non défini .)

La seule exigence est que tous les paramètres doivent être entièrement évalués avant l'appel de la fonction.

Ce:

// The simple obvious one.
callFunc(getA(),getB());

Peut être équivalent à ceci:

int a = getA();
int b = getB();
callFunc(a,b);

Ou ca:

int b = getB();
int a = getA();
callFunc(a,b);

Cela peut être soit; c'est au compilateur. Le résultat peut être important, selon les effets secondaires.

Le compilateur est libre de réorganiser les parties d'évaluation d'une expression (en supposant que la signification est inchangée).

De la question d'origine:

a[i] = i++;

// This expression has three parts:
(a) a[i]
(b) i++
(c) Assign (b) to (a)

// (c) is guaranteed to happen after (a) and (b)
// But (a) and (b) can be done in either order.
// See n2521 Section 5.17
// (b) increments i but returns the original value.
// See n2521 Section 5.2.6
// Thus this expression can be written as:

int rhs  = i++;
int lhs& = a[i];
lhs = rhs;

// or
int lhs& = a[i];
int rhs  = i++;
lhs = rhs;

Verrouillage à double contrôle. Et une simple erreur à commettre.

A* a = new A("plop");

// Looks simple enough.
// But this can be split into three parts.
(a) allocate Memory
(b) Call constructor
(c) Assign value to 'a'

// No problem here:
// The compiler is allowed to do this:
(a) allocate Memory
(c) Assign value to 'a'
(b) Call constructor.
// This is because the whole thing is between two sequence points.

// So what is the big deal.
// Simple Double checked lock. (I know there are many other problems with this).
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        a = new A("Plop");  // (Point A).
    }
}
a->doStuff();

// Think of this situation.
// Thread 1: Reaches point A. Executes (a)(c)
// Thread 1: Is about to do (b) and gets unscheduled.
// Thread 2: Reaches point B. It can now skip the if block
//           Remember (c) has been done thus 'a' is not NULL.
//           But the memory has not been initialized.
//           Thread 2 now executes doStuff() on an uninitialized variable.

// The solution to this problem is to move the assignment of 'a'
// To the other side of the sequence point.
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        A* tmp = new A("Plop");  // (Point A).
        a = tmp;
    }
}
a->doStuff();

// Of course there are still other problems because of C++ support for
// threads. But hopefully these are addresses in the next standard.

Mon préféré est "Récursion infinie dans l'instanciation des modèles" car je crois que c'est le seul où le comportement indéfini se produit au moment de la compilation.

Affectation à une constante après dénudage en constutilisant const_cast<>:

const int i = 10; 
int *p =  const_cast<int*>( &i );
*p = 1234; //Undefined

Outre le comportement non défini , il existe également un comportement défini par l' implémentation tout aussi désagréable .

Un comportement non défini se produit lorsqu'un programme fait quelque chose dont le résultat n'est pas spécifié par la norme.

Le comportement défini par l'implémentation est une action d'un programme dont le résultat n'est pas défini par la norme, mais que l'implémentation doit documenter. Un exemple est "Littéraux de caractères multi-octets", de la question Stack Overflow Y a-t-il un compilateur C qui ne parvient pas à le compiler? .

Le comportement défini par l'implémentation ne vous mord que lorsque vous démarrez le portage (mais la mise à niveau vers une nouvelle version du compilateur est également un portage!)

Les variables ne peuvent être mises à jour qu'une seule fois dans une expression (techniquement une fois entre des points de séquence).

int i =1;
i = ++i;

// Undefined. Assignment to 'i' twice in the same expression.

Une compréhension de base des différentes limites environnementales. La liste complète se trouve à la section 5.2.4.1 de la spécification C. Voici quelques-uns;

• 127 paramètres dans une dé fi nition de fonction
• 127 arguments dans un appel de fonction
• 127 paramètres dans une définition de macro
• 127 arguments en une seule invocation de macro
• 4095 caractères dans une ligne source logique
• 4095 caractères dans un littéral de chaîne de caractères ou un littéral de chaîne large (après concaténation)
• 65535 octets dans un objet (dans un environnement hébergé uniquement)
• 15 niveaux de nidification pour les fichiers #inclus
• 1023 étiquettes de cas pour une instruction switch (à l'exclusion de celles des instructions switch imbriquées)

J'étais en fait un peu surpris de la limite de 1023 étiquettes de cas pour une instruction switch, je peux prévoir que le dépassement pour le code / lex / analyseurs généré assez facilement.

Si ces limites sont dépassées, vous avez un comportement indéfini (plantages, failles de sécurité, etc ...).

Bon, je sais que cela vient de la spécification C, mais C ++ partage ces supports de base.

Permet memcpyde copier entre des régions de mémoire qui se chevauchent. Par exemple:

char a[256] = {};
memcpy(a, a, sizeof(a));

Le comportement n'est pas défini selon la norme C, qui est subsumée par la norme C ++ 03.

7.21.2.1 La fonction memcpy

Synopsis

1 / #include void * memcpy (void * restreindre s1, const void * restreindre s2, size_t n);

La description

2 / La fonction memcpy copie n caractères de l'objet pointé par s2 dans l'objet pointé par s1. Si la copie a lieu entre des objets qui se chevauchent, le comportement n'est pas défini. Renvoie 3 La fonction memcpy renvoie la valeur de s1.

7.21.2.2 La fonction memmove

Synopsis

1 #include void * memmove (void * s1, const void * s2, size_t n);

La description

2 La fonction memmove copie n caractères de l'objet pointé par s2 dans l'objet pointé par s1. La copie se déroule comme si les n caractères de l'objet pointé par s2 sont d'abord copiés dans un tableau temporaire de n caractères qui ne chevauchent pas les objets pointés par s1 et s2, puis les n caractères du tableau temporaire sont copiés dans l'objet pointé par s1. Retour

3 La fonction memmove renvoie la valeur de s1.

Le seul type pour lequel C ++ garantit une taille est char. Et la taille est 1. La taille de tous les autres types dépend de la plate-forme.

Les objets de niveau espace de noms dans des unités de compilation différentes ne doivent jamais dépendre les uns des autres pour l'initialisation, car leur ordre d'initialisation n'est pas défini.