que - programación orientada a objetos con c++

¿Por qué el compilador no emite una advertencia cuando se declara un objeto std:: vector pero nunca se usa?

Question

Esta pregunta ya tiene una respuesta aquí:

• Una variable no detectada como no utilizada 3 respuestas

#include <vector>

class Object
{
};

int main()
{
    Object myObject;
    std::vector<int> myVector;
}

El compilador emite:

warning: unused variable ''myObject'' [-Wunused-variable]

No hay advertencia para myVector . ¿Por qué? ¿Hay alguna manera de habilitar esto?

Answer 1

Además de las respuestas anteriores, también revise la documentación de su compilador. Algunos compiladores pueden configurarse para que no muestren la misma advertencia varias veces. Si comenta la declaración de "myObject", puede obtener la misma advertencia para "myVector". Con "mObject" produciendo esa advertencia primero, no recibiría una advertencia para "myVector".

El comportamiento del compilador en el caso de las advertencias es muy específico del compilador, así que no asuma que todos los compiladores funcionan de la misma manera. :)

Answer 2

Esta advertencia se genera solo para tipos triviales. El compilador no puede determinar si la construcción llamará a alguna función externa. Si agrega un constructor a su clase de Object , el compilador también emitirá una advertencia. Gcc permite etiquetar los tipos que deberían generar esta advertencia, puede hacerlo usando __attribute__((warn_unused)) :

http://coliru.stacked-crooked.com/a/0130c8ef29c121a1

ejemplo:

class __attribute__((warn_unused)) Object
{
    public:
    Object(){}
    void use() {}
};

int main()
{
    Object myObject;  // will give : warning: unused variable ''myObject'' [-Wunused-variable]
    //myObject.use(); // uncomment to hide this warning
}

[editar]

de la página de atributos de gcc: https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html :

warn_unused Para los tipos C ++ con constructores y / o destructores no triviales, es imposible para el compilador determinar si una variable de este tipo realmente no se usa si no se hace referencia. Este atributo de tipo informa al compilador que debe advertirse a las variables de este tipo si parecen no ser utilizadas, al igual que las variables de tipos fundamentales. Este atributo es apropiado para los tipos que solo representan un valor, como std :: string; no es apropiado para los tipos que controlan un recurso, como std :: lock_guard.

Este atributo también se acepta en C, pero no es necesario porque C no tiene constructores ni destructores.

Answer 3

No se puede determinar en general si declarar (y, por lo tanto, inicializar y, en algún momento, destruir) un objeto arbitrario tiene efectos secundarios visibles. El constructor puede estar llamando a funciones cuya definición no es conocida para el compilador o puede depender del estado externo o de cualquier otro aspecto que haga que el problema sea indecidible.

En su primer caso, el constructor es trivial (ni siquiera declarado), lo mismo para el destructor. Como Object no tiene miembros, es claro y fácilmente detectable que Object foo no hace nada.

std::vector tiene un constructor no trivial que puede estar asignando memoria (función externa de estado + cuya definición puede no ser conocida ( new ... )) junto con un destructor no trivial (también función externa de estado + cuya definición no puede ser conocido ( delete ... )). En este caso, no es posible razonar si es seguro eliminar la declaración (por lo tanto, emitir una advertencia que sugiere que tal vez debería), por lo que el compilador debe dejar la declaración en el código (y debe asumir que la declaración está ahí para razón).

Un ejemplo principal es std::lock_guard que se usa para bloquear un mutex cuando se construye y desbloquearlo automáticamente cuando se destruye. El mutex se mantiene así mientras el objeto esté en el alcance; en general, no std::lock_guard objeto std::lock_guard en absoluto, sin embargo, es útil tenerlo declarado. Este es el principio RAII en el trabajo.

En tales casos, emitir una advertencia sería una molestia, lo que provocaría que las personas desactivaran la advertencia, lo que a su vez haría que la advertencia fuera inútil. (El compilador puede incluso diseñarse de tal manera que solo emita la advertencia si ha eliminado la declaración durante la optimización, lo cual es también la razón por la que algunas advertencias solo se muestran si ciertas optimizaciones están habilitadas).