funciones - Advertencias o errores para la conversión implícita de primitivas en C++

funciones en c++

Question

He hecho un poco de refactorización de algunos códigos C ++ y descubrí numerosos errores que surgen de conversiones implícitas de las que no tengo conocimiento.

Ejemplo

struct A *a();
bool b() {
return a();
}
void c() {
int64_t const d(b());
}

Cuestiones

1. En b , el tipo de retorno de a se convierte silenciosamente a bool .
2. En c , el valor devuelto desde b se promueve silenciosamente a int64_t .

Pregunta

¿Cómo puedo recibir advertencias o errores para la conversión implícita entre tipos primitivos ?

Nota

1. El uso de -Wconversion parece recoger solo varias conversiones arbitrarias no relacionadas con el ejemplo anterior.
2. BOOST_STRONG_TYPEDEF no es una opción (mis tipos deben ser POD, ya que se usan en estructuras de disco).
3. C también es de interés, sin embargo, este problema se refiere a una base de código C ++.

Answer 1

En el lenguaje de programación C ++, tercera edición , apéndice C.6, llamado "Conversión de tipo implícita", Bjarne Stroustrup clasifica las conversiones como promociones y conversiones : los primeros "conservan los valores" (ese es su caso 2), los segundos no. (caso 1).

Acerca de las conversiones , dice que "los tipos fundamentales se pueden convertir unos en otros de una manera desconcertante. En mi opinión, se permiten demasiadas conversiones". y "Un compilador puede advertir sobre muchas conversiones cuestionables. Afortunadamente, muchos compiladores sí lo hacen".

Las promociones en el otro lado son seguras, y parece que un compilador no debe dar una advertencia por ellas.

Las advertencias del compilador generalmente no son obligatorias. Por lo general, en los borradores de C ++ y en los documentos ANSI finales , se informa que "los implementadores deben emitir una advertencia" donde se sugiere: puede verificarlo usted mismo para obtener más información si es necesario.

EDITADO: añadido C ++ 11 nota:

En el lenguaje de programación The C ++, 4ª edición , el apéndice de la 3ª edición se informó y se extendió a la sección 10.5, "Conversión de tipo implícita" nuevamente.

Como las consideraciones anteriores son las mismas, C ++ 11 define con mayor precisión las "conversiones de reducción" y agrega la notación inicializadora {} (6.3.5), con la cual los truncamientos conducen a un error de compilación.

Answer 2

Escribe un complemento personalizado para diagnosticar tus problemas. Hacemos mucho de esto en el código de LibreOffice. Visite nuestra fuente si desea inspiración en http://cgit.freedesktop.org/libreoffice/core/tree/compilerplugins/clang

Answer 3

Microsoft Visual C ++ daría una advertencia sobre la conversión de reducción de A* a bool .

Ver el Compilador de Advertencia C4800

Por otro lado, la promoción no es una conversión "peligrosa", porque es imposible perder datos.

EDITAR: Demostración

C:/Users/Ben>copy con test.cpp
bool f( void ) { return new int(); }
^Z
1 file(s) copied.
C:/Users/Ben>cl /c /W4 test.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.30319.01 for 80x86
Copyright (C) Microsoft Corporation. All rights reserved.
test.cpp
test.cpp(1) : warning C4800: ''int *'' : forcing value to bool ''true'' or ''false'' (
performance warning)

Answer 4

Puede usar una de las herramientas de análisis estático disponibles, programas como clint o equivalentes de C ++, o una de las herramientas disponibles comercialmente. Muchas de estas herramientas pueden detectar conversiones implícitas problemáticas.

Answer 5

Según tengo entendido, no puede controlar la conversión implícita entre tipos primitivos: es obligatorio por el estándar y cualquier compilador compatible solo lo ejecutará en silencio.

¿Estás seguro de que un enfoque como BOOST_STRONG_TYPEDEF no funcionará en tu problema? Una clase sin funciones de miembro virtual y solo un miembro de datos primitivos es básicamente nada más que un tipo de datos POD. Simplemente puede seguir el mismo enfoque y solo permitir la conversión al tipo primitivo básico; ejemplo:

#include <iostream>
#include <stdexcept>
struct controlled_int {
// allow creation from int
controlled_int(int x) : value_(x) { };
controlled_int& operator=(int x) { value_ = x; return *this; };
// disallow assignment from bool; you might want to use BOOST_STATIC_ASSERT instead
controlled_int& operator=(bool b) { throw std::logic_error("Invalid assignment of bool to controlled_int"); return *this; };
// creation from bool shouldn''t happen silently
explicit controlled_int(bool b) : value_(b) { };
// conversion to int is allowed
operator int() { return value_; };
// conversion to bool errors out; you might want to use BOOST_STATIC_ASSERT instead
operator bool() { throw std::logic_error("Invalid conversion of controlled_int to bool"); };
private:
int value_;
};
int main()
{
controlled_int a(42);
// This errors out:
// bool b = a;
// This gives an error as well:
//a = true;
std::cout << "Size of controlled_int: " << sizeof(a) << std::endl;
std::cout << "Size of int: " << sizeof(int) << std::endl;
return 0;
}

Answer 6

Si está utilizando gcc, ha intentado -Wall -Wextra, básicamente, consulte esta página
http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html

Si no es GCC por favor publique los detalles del compilador.