c++ - séquence - tag génétique




Comportement non défini et points de séquence (3)

Quels sont les "points de séquence"?

Quelle est la relation entre un comportement indéfini et des points de séquence?

J'utilise souvent des expressions drôles et alambiquées comme a[++i] = i; , pour me sentir mieux. Pourquoi devrais-je arrêter de les utiliser?

Si vous avez lu ceci, assurez-vous de visiter la question de suivi Comportement indéterminé et points de séquence rechargés .

(Note: Ceci est censé être une entrée pour la FAQ C ++ de Stack Overflow .) Si vous voulez critiquer l'idée de fournir une FAQ dans ce formulaire, alors l'affichage sur meta qui a commencé tout ceci serait l'endroit pour le faire. cette question est surveillée dans le salon de discussion C ++ , où l'idée de FAQ a commencé en premier lieu, ainsi votre réponse est très susceptible d'être lue par ceux qui ont eu l'idée.)


C ++ 98 et C ++ 03

Cette réponse est pour les anciennes versions de la norme C ++. Les versions C ++ 11 et C ++ 14 de la norme ne contiennent pas formellement de «points de séquence»; les opérations sont «séquencées avant» ou «non séquencées» ou «séquentiellement indéterminée». L'effet net est essentiellement le même, mais la terminologie est différente.

Disclaimer : D'accord. Cette réponse est un peu longue. Ayez donc de la patience en le lisant. Si vous connaissez déjà ces choses, les relire ne vous rendra pas fou.

Pré-requis : Une connaissance élémentaire de la norme C ++

Quels sont les points de séquence?

La norme dit

À certains points spécifiés de la séquence d'exécution appelée points de séquence , tous les effets secondaires des évaluations précédentes doivent être complets et aucun effet secondaire des évaluations ultérieures ne doit avoir eu lieu. (§1.9 / 7)

Effets secondaires? Quels sont les effets secondaires?

L'évaluation d'une expression produit quelque chose et si de plus il y a un changement dans l'état de l'environnement d'exécution, on dit que l'expression (son évaluation) a un ou plusieurs effets secondaires.

Par exemple:

int x = y++; //where y is also an int

En plus de l'opération d'initialisation, la valeur de y est modifiée en raison de l'effet secondaire de l'opérateur ++ .

Jusqu'ici tout va bien. Passons aux points de séquence. Une définition d'alternance de seq-points donnée par l'auteur de comp.lang.c Steve Summit :

Le point de séquence est un moment où la poussière est retombée et tous les effets secondaires observés jusqu'ici sont garantis.

Quels sont les points de séquence communs répertoriés dans la norme C ++?

Ce sont:

  • à la fin de l'évaluation de l'expression complète ( §1.9/16 ) (Une expression complète est une expression qui n'est pas une sous-expression d'une autre expression.) 1

Exemple :

int a = 5; // ; is a sequence point here
  • dans l'évaluation de chacune des expressions suivantes après l'évaluation de la première expression ( §1.9/18 ) 2

    • a && b (§5.14)
    • a || b (§5.15)
    • a ? b : c (§5.16)
    • a , b (§5.18) (ici a, b est un opérateur de virgule, dans func(a,a++) , n'est pas un opérateur de virgule, c'est simplement un séparateur entre les arguments a et a++ Ainsi le comportement est indéfini dans ce cas (si a est considéré comme un type primitif))
  • lors d'un appel de fonction (que la fonction soit ou non en ligne), après l'évaluation de tous les arguments de fonction (le cas échéant) qui a lieu avant l'exécution de toute expression ou instruction dans le corps de la fonction ( §1.9/17 ).

1: Note: l'évaluation d'une expression complète peut inclure l'évaluation de sous-expressions qui ne font pas partie lexicalement de l'expression complète. Par exemple, les sous-expressions impliquées dans l'évaluation des expressions d'argument par défaut (8.3.6) sont considérées comme créées dans l'expression qui appelle la fonction, et non l'expression qui définit l'argument par défaut.

2: Les opérateurs indiqués sont les opérateurs intégrés, comme décrit à l'article 5. Lorsqu'un de ces opérateurs est surchargé (article 13) dans un contexte valide, désignant ainsi une fonction d'opérateur définie par l'utilisateur, l'expression désigne une invocation de fonction et les opérandes forment une liste d'arguments, sans point de séquence implicite entre eux.

Qu'est-ce qu'un comportement indéterminé?

La norme définit le comportement §1.3.12 dans la section §1.3.12

comportement, tel qu'il pourrait résulter de l'utilisation d'une construction de programme erronée ou de données erronées, pour lesquelles la présente Norme internationale n'impose aucune exigence 3 .

Un comportement indéfini peut également être attendu lorsque la présente Norme internationale omet la description de toute définition explicite du comportement.

3: le comportement indéfini autorisé va de l'ignorance complète de la situation avec des résultats imprévisibles, à l'exécution de la traduction ou de l'exécution du programme d'une manière documentée caractéristique de l'environnement (avec ou sans émission d'un message de diagnostic) (avec l'émission d'un message de diagnostic).

En bref, un comportement indéfini signifie que tout ce qui peut arriver des démons qui sortent de votre nez à votre petite amie tomber enceinte.

Quelle est la relation entre un comportement indéterminé et des points de séquence?

Avant de commencer, vous devez connaître la différence entre un comportement indéterminé, un comportement non spécifié et un comportement défini par l'implémentation .

Vous devez également savoir que the order of evaluation of operands of individual operators and subexpressions of individual expressions, and the order in which side effects take place, is unspecified .

Par exemple:

int x = 5, y = 6;

int z = x++ + y++; //it is unspecified whether x++ or y++ will be evaluated first.

Un autre exemple here .

Maintenant, la norme dans §5/4 dit

  • 1) Entre le point de séquence précédent et suivant, un objet scalaire doit avoir sa valeur stockée modifiée au plus une fois par l'évaluation d'une expression.

Qu'est-ce que ça veut dire?

Informellement, cela signifie qu'entre deux points de séquence, une variable ne doit pas être modifiée plus d'une fois. Dans une déclaration d'expression, le next sequence point trouve généralement au point-virgule de terminaison et le previous sequence point trouve à la fin de l'instruction précédente. Une expression peut également contenir des sequence points intermédiaires.

À partir de la phrase ci-dessus, les expressions suivantes invoquent un comportement indéterminé:

i++ * ++i;   // UB, i is modified more than once btw two SPs
i = ++i;     // UB, same as above
++i = 2;     // UB, same as above
i = ++i + 1; // UB, same as above
++++++i;     // UB, parsed as (++(++(++i)))

i = (i, ++i, ++i); // UB, there's no SP between `++i` (right most) and assignment to `i` (`i` is modified more than once btw two SPs)

Mais les expressions suivantes sont bien:

i = (i, ++i, 1) + 1; // well defined (AFAIK)
i = (++i, i++, i);   // well defined 
int j = i;
j = (++i, i++, j*i); // well defined
  • 2) En outre, la valeur précédente doit être accessible uniquement pour déterminer la valeur à stocker.

Qu'est-ce que ça veut dire? Cela signifie que si un objet est écrit dans une expression complète, tous les accès à la même expression doivent être directement impliqués dans le calcul de la valeur à écrire .

Par exemple dans i = i + 1 tous les accès de i (dans LHS et dans RHS) sont directement impliqués dans le calcul de la valeur à écrire. Donc c'est bien.

Cette règle contraint effectivement les expressions juridiques à celles dans lesquelles les accès précèdent la modification.

Exemple 1:

std::printf("%d %d", i,++i); // invokes Undefined Behaviour because of Rule no 2

Exemple 2:

a[i] = i++ // or a[++i] = i or a[i++] = ++i etc

est interdit parce que l'un des accès de i (celui d' a[i] ) n'a rien à voir avec la valeur qui finit par être stockée dans i (ce qui arrive dans i++ ), et donc il n'y a pas de bonne façon de définir-- soit pour notre compréhension soit pour celle du compilateur - si l'accès doit avoir lieu avant ou après le stockage de la valeur incrémentée. Donc, le comportement est indéfini.

Exemple 3:

int x = i + i++ ;// Similar to above

Suivez la réponse here .


Je suppose qu'il y a une raison fondamentale au changement, il n'est pas simplement superficiel de clarifier l'ancienne interprétation: cette raison est la concurrence. L'ordre d'élaboration non spécifié est simplement la sélection de plusieurs ordres possibles en série, ce qui est assez différent des ordres avant et après, parce que s'il n'y a pas d'ordre spécifié, l'évaluation simultanée est possible: pas avec les anciennes règles. Par exemple dans:

f (a,b)

auparavant soit a puis b, soit, b alors a. Maintenant, a et b peuvent être évalués avec des instructions entrelacées ou même sur des cœurs différents.


Ceci est un suivi de ma réponse précédente et contient du matériel lié à C ++ 11. .

Pré-requis : Une connaissance élémentaire des Relations (Mathématiques).

Est-il vrai qu'il n'y a pas de points de séquence dans C ++ 11?

Oui! C'est très vrai.

Les points de séquence ont été remplacés par des relations séquentielles avant et séquentielles après (et non séquencées et indéterminées ) en C ++ 11.

Qu'est-ce que c'est exactement cette chose 'Sequenced before'?

Séquencé avant (§1.9 / 13) est une relation qui est:

entre les évaluations exécutées par un seul thread et induit un ordre partiel strict 1

Formellement, cela signifie deux évaluations quelconques (voir ci-dessous) A et B , si A est séquencé avant B , alors l'exécution de A précédera l'exécution de B Si A n'est pas séquencé avant que B et B ne soient pas séquencés avant A , alors A et B sont non séquencés 2 .

Les évaluations A et B sont séquencées de façon indéterminée lorsque A est séquencé avant que B ou B soit séquencé avant A , mais il n'est pas spécifié lequel 3 .

[REMARQUES]
1: Un ordre partiel strict est une relation binaire "<" sur un ensemble P qui est Asymmetric , et Transitive , c'est-à-dire, pour tout a , b , et c dans P , on a ceci:
........(je). si a <b alors ¬ (b <a) ( asymmetry );
........ (ii). si a <b et b <c alors a <c ( transitivity ).
2: L'exécution d' évaluations non séquencées peut se chevaucher .
3: Les évaluations séquentiellement indéterminées ne peuvent pas se chevaucher , mais elles peuvent être exécutées en premier.

Quelle est la signification du mot 'évaluation' dans le contexte de C ++ 11?

En C ++ 11, l'évaluation d'une expression (ou d'une sous-expression) comprend généralement:

Maintenant (§1.9 / 14) dit:

Chaque calcul de valeur et effet secondaire associé à une expression complète est séquencé avant chaque calcul de valeur et effet secondaire associé à la prochaine expression complète à évaluer .

  • Exemple trivial:

    int x; x = 10; ++x;

    Le calcul de valeur et l'effet de bord associé à ++x sont séquencés après le calcul de la valeur et l'effet de bord de x = 10;

Donc, il doit y avoir une certaine relation entre Undefined Behavior et les choses mentionnées ci-dessus, non?

Oui! Droite.

Dans (§1.9 / 15), il a été mentionné que

Sauf indication contraire, les évaluations des opérandes des opérateurs individuels et des sous-expressions des expressions individuelles ne sont pas séquentielles 4 .

Par exemple :

int main()
{
     int num = 19 ;
     num = (num << 3) + (num >> 3);
} 
  1. L'évaluation des opérandes de l'opérateur + n'est pas séquentielle l'une par rapport à l'autre.
  2. L'évaluation des opérandes des opérateurs << et >> n'est pas séquentielle l'une par rapport à l'autre.

4: Dans une expression qui est évaluée plus d'une fois pendant l'exécution d'un programme, les évaluations non séquencées et séquentiellement indéterminées de ses sous-expressions n'ont pas besoin d'être effectuées de manière cohérente dans différentes évaluations.

(§1.9 / 15) Les calculs de valeur des opérandes d'un opérateur sont séquencés avant le calcul de la valeur du résultat de l'opérateur.

Cela signifie que dans x + y les calculs de valeur de x et y sont séquencés avant le calcul de la valeur de (x + y) .

Plus important

(§1.9 / 15) Si un effet secondaire sur un objet scalaire est non séquencé par rapport à

(a) un autre effet secondaire sur le même objet scalaire

ou

(b) un calcul de valeur utilisant la valeur du même objet scalaire.

le comportement est indéfini .

Exemples:

int i = 5, v[10] = { };
void  f(int,  int);
  1. i = i++ * ++i; // Undefined Behaviour
  2. i = ++i + i++; // Undefined Behaviour
  3. i = ++i + ++i; // Undefined Behaviour
  4. i = v[i++]; // Undefined Behaviour
  5. i = v[++i]: // Well-defined Behavior
  6. i = i++ + 1; // Undefined Behaviour
  7. i = ++i + 1; // Well-defined Behaviour
  8. ++++i; // Well-defined Behaviour
  9. f(i = -1, i = -1); // Undefined Behaviour (see below)

Lors de l'appel d'une fonction (que la fonction soit en ligne ou non), chaque calcul de valeur et effet secondaire associé à une expression d'argument ou à l'expression postfix désignant la fonction appelée est séquencé avant l'exécution de chaque expression ou instruction dans le corps du appelée fonction. [ Note: Les calculs de valeur et les effets secondaires associés aux différentes expressions d'argument ne sont pas séquencés . - note de fin ]

Les expressions (5) , (7) et (8) n'invoquent pas de comportement indéfini. Consultez les réponses suivantes pour une explication plus détaillée.

Note finale :

Si vous trouvez un défaut dans le message s'il vous plaît laissez un commentaire. Power-users (Avec rep> 20000), n'hésitez pas à modifier le post pour corriger les fautes de frappe et autres erreurs.





sequence-points