¿Cuál es el fundamento para "no requerido de diagnóstico"? -- ++ campo con c++11 campo con language-lawyer camp Relacionados El problema

What is the rationale to “no diagnostic required”?


18
vote

problema

Español

La mayoría de las personas están familiarizadas con las Notas de comportamiento "indefinidas" y "no especificadas" en C ++, pero ¿qué pasa con "No se requiere diagnóstico"?

I Nota esta pregunta y respuesta , que trata con programas mal formados, pero no mucho detalles sobre la raíz de "no Diagnóstico requerido "Declaraciones.

¿Cuál es el enfoque general aplicado por el Comité al clasificar algo como "sin diagnóstico requerido"?

  • ¿Qué tan malo necesita ser el error para que el Comité de Normas lo especifique como tal?
  • ¿Son estos errores de tal naturaleza que sería casi imposible de detectar, por lo tanto, diagnosticar?

Ejemplos de comportamiento "indefinido" y "no especificado" no están en breve suministro; A falta de la ODR, ¿qué ejemplo (s) práctico (s) están ahí para los errores de tipo "sin diagnóstico requerido"?

Original en ingles

Most people are familiar with the "undefined" and "unspecified" behaviour notes in C++, but what about "no diagnostic required"?

I note this question and answer, dealing with ill formed programs, but not much detail on the root of "no diagnostic required" statements.

What is the general approach applied by the committee when classifying something as "no diagnostic required"?

  • How bad does the error need to be for the standards committee to specify it as such?
  • Are these errors of such a nature that it would be near impossible to detect, hence diagnose?

Examples of "undefined" and "unspecified" behaviour are not in short supply; short of the ODR, what practical example(s) are there for the "no diagnostic required" type errors?

        

Lista de respuestas

15
 
vote
vote
La mejor respuesta
 

Hubo una discusión aquí: https://groups.google .com / a / isocpp.org / foro / #! Topic / STD-Discusión / LK1qavciviy con declaraciones por parte de varios miembros del comité.

El consenso general parece ser

  • no hay diferencia normativa
  • mal formado; Ningún diagnóstico requerido se usa solo para violaciones de reglas de tiempo de compilación, nunca para violaciones de la regla de tiempo de ejecución.

Como dije en ese hilo, una vez escuché en una discusión (no puedo recordar más en la que uno, pero estoy seguro de que había miembros de los comités perspicaces involucrados)

  • mal formado; Ningún diagnóstico requerido para los casos que claramente son violaciones de las reglas malas y que, en principio, se puede diagnosticar en el tiempo de compilación, pero requeriría enormes esfuerzos de una implementación.
  • Comportamiento indefinido Para las cosas que las implementaciones podrían encontrar significados útiles para, por lo que no necesariamente son malvados puros, y para cualquier violación de tiempo de ejecución que resulte en consecuencias arbitrarias.

La guía aproximada para mí es; Si está en tiempo de compilación, tiende a ser "malhechado; no se requiere diagnóstico" y, si está en tiempo de ejecución, siempre es "comportamiento indefinido".

 

There was a discussion here: https://groups.google.com/a/isocpp.org/forum/#!topic/std-discussion/lk1qAvCiviY with utterances by various committee members.

The general consensus appears to be

  • there is no normative difference
  • ill-formed; no diagnostic required is used only for compile-time rule violations, never for runtime rule violations.

As I said in that thread, I did once hear in a discussion (I can't remember anymore in which one, but I'm certain there were insightful committee members involved)

  • ill-formed; no diagnostic required for cases that clearly are bad rule violations and that can in principle be diagnosed at compile time, but would require huge efforts from an implementation.
  • undefined behavior for things that implementations could find useful meanings for, so don't neccessarily are pure evil, and for any runtime violations that results in arbitrary consequences.

The rough guide for me is; if it is at compile time, it tends to be "ill-formed; no diagnostic required" and if it is at runtime, it always is "undefined behavior".

 
 
     
     
13
 
vote

Intentaría explicarlo "No se requiere diagnóstico" para comportamientos categorizados como Comportamiento indefinido (UB) .

El estándar diciendo "UB no requiere diagnóstico" 1 , le da a los compiladores la libertad total para optimizar el código, ya que el compilador puede eliminar muchos gastos generales solo por asumiendo Su programa está completamente bien definido (lo que significa que su programa no tiene UBS), que es un supuesto de de , después de todo, si esa suposición es incorrecta, entonces todo lo que el compilador se basa en esto (incorrecto) El supuesto se comportará en una forma indefinida (es decir, impredecible) que es completamente consistente porque su programa tiene comportamientos indefinidos de todos modos!

Tenga en cuenta que un programa que contiene UBS tiene la libertad de comportarse como cualquier cosa. Nota de nuevo que dije "consistente" porque es consistente con la postura de la norma: "Ni la especificación del idioma ni los compiladores dan ninguna garantía del comportamiento de su programa si contiene UB (s)" .

1. lo contrario es "Diagnóstico requerido", lo que significa que el compilador es requerido para proporcionar diagnósticos al programador ya sea emitiendo o error . En otras palabras, es no permitido asumir que el programa está bien definido para optimizar ciertas partes del código .

Aquí hay un artículo (en el blog de LLVM) que explica este ejemplo adicional usando:

  • Ventajas del comportamiento indefinido en C, con ejemplos (parte uno)

A excepción del artículo ( Mina en cursiva ):

Desbordamiento entero firmado: si es aritmético en un tipo 'INT' (por ejemplo) Se desborda, el resultado no está definido. Un ejemplo es que "int_max + 1" es No garantizado ser int_min. este comportamiento permite ciertas clases de Optimizaciones que son importantes para algún código. Por ejemplo, saber que int_max + 1 está indefinido permite optimizar "x + 1 & gt; x" a "verdadero". Sabiendo que la multiplicación "no puede" desbordarse (porque hacerlo lo haría ser indefinido) permite optimizar "x * 2/2" a "x" . Mientras que estos pueden parecer Trivial, estos tipos de cosas se exponen comúnmente al enlinar y Expansión macro. Una optimización más importante que esto permite que es para "& lt; =" bucles como este:

  for (i = 0; i <= N; ++i) { ... }   

En este bucle, el compilador puede asumir que el bucle iterará exactamente N + 1 veces si "I" no está definido en el desbordamiento, lo que permite un amplia gama de optimizaciones de bucle para patear. Por otro lado, si La variable se define para envolver en el desbordamiento, luego el compilador debe asumir que el bucle es posiblemente infinito (lo que sucede si n es Int_max) - que luego deshabilita estas importantes optimizaciones de bucle. Esto afecta especialmente las plataformas de 64 bits, ya que muchos usos de código "INT" como variables de inducción.

Vale la pena señalar que se garantiza el desbordamiento sin firmar A medida que se desbordan el complemento (envoltorio) de 2), para que siempre pueda usarlos. La El costo de hacer que el desbordamiento entero firmado definido es que este tipo de Las optimizaciones simplemente se pierden (por ejemplo, un síntoma común es una tonelada de las extensiones de signos dentro de los bucles en objetivos de 64 bits). Ambos clang y GCC acepta la bandera "-fwrapv" que obliga al compilador para tratar desbordamiento entero firmado como se define (que no sea la división de int_min por -1).

Le recomendaría que lea el artículo completo: tiene tres partes, todas son buenas.

  • parte dos
  • parte tres

espero que ayude.

 

I would try to explain "no diagnostic required" for behaviours categorized as undefined behaviour (UB).

The Standard by saying "UB doesn't require diagnostic"1, gives compilers total freedom to optimize the code, as the compiler can eliminate many overheads only by assuming your program is completely well-defined (which means your program doesn't have UBs) which is a good assumption xe2x80x94 after all if that assumption is wrong, then anything which compiler does based on this (wrong) assumption is going to behave in an undefined (i.e unpredictable) way which is completely consistent because your program has undefined behaviours anyway!

Note that a program which contains UBs has the freedom to behave like anything. Note again that I said "consistent" because it is consistent with Standard's stance : "neither the language specification nor the compilers give any guarantee of your program's behaviour if it contains UB(s)".

1. The opposite is "diagnostic required" which means the compiler is required to provide diagnostics to the programmer either by emitting warning or error messages. In other words, it is not allowed to assume the program is well-defined so as to optimize certain parts of code.

Here is an article (on LLVM blog) which explains this further using example:

  • Advantages of Undefined Behavior in C, with Examples (part one)

An except from the article (italicised mine):

Signed integer overflow: If arithmetic on an 'int' type (for example) overflows, the result is undefined. One example is that "INT_MAX+1" is not guaranteed to be INT_MIN. This behavior enables certain classes of optimizations that are important for some code. For example, knowing that INT_MAX+1 is undefined allows optimizing "X+1 > X" to "true". Knowing the multiplication "cannot" overflow (because doing so would be undefined) allows optimizing "X*2/2" to "X". While these may seem trivial, these sorts of things are commonly exposed by inlining and macro expansion. A more important optimization that this allows is for "<=" loops like this:

for (i = 0; i <= N; ++i) { ... } 

In this loop, the compiler can assume that the loop will iterate exactly N+1 times if "i" is undefined on overflow, which allows a broad range of loop optimizations to kick in. On the other hand, if the variable is defined to wrap around on overflow, then the compiler must assume that the loop is possibly infinite (which happens if N is INT_MAX) - which then disables these important loop optimizations. This particularly affects 64-bit platforms since so much code uses "int" as induction variables.

It is worth noting that unsigned overflow is guaranteed to be defined as 2's complement (wrapping) overflow, so you can always use them. The cost to making signed integer overflow defined is that these sorts of optimizations are simply lost (for example, a common symptom is a ton of sign extensions inside of loops on 64-bit targets). Both Clang and GCC accept the "-fwrapv" flag which forces the compiler to treat signed integer overflow as defined (other than divide of INT_MIN by -1).

I would recommend you to read the entire article xe2x80x94 it has three parts, all are good.

  • part two
  • part three

Hope that helps.

 
 
       
       

Relacionados problema

18  ¿Se han descrito incorrectamente las estructuras y uniones anónimas en C11?  ( Have anonymous structs and unions in c11 been incorrectly described ) 
Dea el estándar C, con respecto a las estructuras y sindicatos anónimos: 6.7.2.1 P13. un Sin nombre Miembro cuyo tipo especificador de tipo es un especif...

13  ¿Cuánto afecta la extensibilidad de la biblioteca estándar de C?  ( How much does the c standard library extensibility affect c programs ) 
Toma este código: int issuecode(int i) { return 2 * i; } int main(int argc, char **argv) { return issuecode(argc); } La forma en que lo entiendo, ...

8  ¿Misra C 2012 dice no usar BOOL  ( Does misra c 2012 say not to use bool ) 
Estoy en las primeras etapas de las cosas enmarcar en un nuevo proyecto. Definimos una función con un tipo de devolución de "BOOL" obtuve esta salida de P...

2  Entendiendo C ++ Reconstruir Sintaxis  ( Understanding c reconstruct syntax ) 
¿Podemos volver a llamar a un constructor de un objeto después de crearlo? Public Function startUnZip() IO.Directory.CreateDirectory(outputFolder) ...

3  Valores faltantes en la propiedad de taquigrafía  ( Missing values in shorthand property ) 
citando css 2.2 especificaciones : Cuando los valores se omiten de una forma de taquigrafía, cada propiedad "Falta" Se le asigna su valor inicial (consu...

4  Haz tipos de clase intercambiables solo a través de la fundición del puntero, sin tener que asignar ningún objeto nuevo?  ( Make interchangeable class types via pointer casting only without having to all ) 
update : Aprecio "No quiero eso, quiere esto en su lugar" sugerencias. Son útiles, especialmente cuando se proporcionan en contexto de la Motivando el escen...

8  ¿Se considera esto válido C ++ 11 o C ++ 14? ¿O es GCC / CLANG que se equivoca?  ( Is this considered valid c11 or c14 or is gcc clang getting it wrong ) 
Mientras intentas resolver ¿Es posible saber si una clase ha ocultado una función base en C ++? , generé esto: #include <type_traits> #include <iostream> ...

26  Es numeric_limits <int> :: is_modulo lógicamente contradictorio?  ( Is numeric limitsintis modulo logically contradictory ) 
en Otra pregunta , el tema de std::numeric_limits<int>::is_modulo surgió. Pero cuanto más lo pienso, más parece que algo está mal con la especificación o c...

4  ¿Es cierto que para todos los tipos `t`,` u` si 't` está coaccionado a `u` entonces` & t` es coaccionado para `& u`?  ( Is it true that for all types t u if t is coerced to u then t is coe ) 
es bien documentado que [T; n] puede coaccionar a [T] . El siguiente código también es Si 99887776611111 está obligado a import re dset = [] text = ...

7  ¿El `Const &&` se une a todos los prvaluces (y xvalores)?  ( Does const bind to all prvalues and xvalues ) 
El estándar C ++ define las siguientes funciones eliminadas; template <class T> void ref(const T&&) = delete; template <class T> void cref(const T&&) = de...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos