Qt GUI aplicación: advertencia si QObject :: connect () falló?

Question

Recientemente he migrado mi proyecto Qt desde Linux a Vista, y ahora estoy depuración señales ciegas.

En Linux, si QObject :: connect () falla en una versión de depuración, aparece un mensaje de advertencia en stderr. En Windows, no hay salida de la consola para aplicaciones de interfaz gráfica de usuario, solamente una llamada OutputDebugString.

Ya instalado DebugView , y me llama la propia qDebug () de salida muy bien, pero todavía no hay señales de advertencia en fallidos.

Una posible solución sería utilizar autocompletar de QtCreator para señales, pero me gusta Eclipse, y el uso de ambos es un PITA. Cualquier ideas sobre cómo obtener información de señal / ranura en tiempo de ejecución?

Edit: Me acabo de dar cuenta de conexión () devuelve bool, que resuelve el problema inmediato, feo, ya que puede ser. Sin embargo, esto no resuelve los casos en los que QMetaObject :: connectSlotsByName () falla, y éste se ejecuta automáticamente con widgets.

Answer 1

Llama a la función estática QErrorMessage :: qtHandler ().

De acuerdo con la documentación, esta 'instala un controlador de mensajes usando qInstallMsgHandler () y crea una QErrorMessage que muestra qDebug (), qWarning () y qFatal () mensajes'.

Alternativamente, instalar un controlador de mensajes con qInstallMsgHandler ().

Otra alternativa (que se describe en un post-interés qt) es algo como esto:

#ifdef _DEBUG
#define connect( connectStmt ) Q_ASSERT( connect( connectStmt ) ) 
#endif

... y por lo que vale la pena, aquí hay algunas señales y ranuras de depuración sugerencias I recopilados: http://samdutton.wordpress.com/2008/10/03/debugging-signals-and-slots-in-qt/

Answer 2

La solución me gusta de esto es ajustar

QT_FATAL_WARNINGS=1

en el entorno del programa cuando se depura. Eso hace que la caída del programa, que le da una buena traza, especialmente si se ejecuta el código en un depurador. Si no desea que el accidente, véase la respuesta anterior.

Answer 3

Mi enfoque es volver a enlazar el motor de registro con Qt qInstallMsgHandler y hacer mi propio registro tanto a presentar y la consola.

De esta manera, sé que todos los mensajes de error / advertencia se registran y puedo analizarlas, incluso después de que el programa ha dejado de ejecutar.

P.S: QtCreator intercepta los mensajes y los muestra en el panel de salida de la aplicación

.

Answer 4

Si su uso de Visual Studio se puede añadir una consola para cualquier aplicación QT.
Ir a las propiedades del proyecto, bajo Linker-> Cambiar la configuración del "subsistema" decir "consola"

Ahora volver a compilar el código y te aparecerá la consola cuando se activa la aplicación. Si desea deshacerse de él, basta con cambiar el subsistema de nuevo a "Windows"

No estoy seguro si esto es posible con QtCreator.

Otra opción es utilizar las llamadas Win32 nativas como AttachConsole() la creación manual de la consola y adjuntarlo a stdout y stderr. ver aquí para más detalles sobre esto.

Answer 5

La mayoría de las veces sólo quiero un poco de atención de vez en cuando: Sólo hay que poner un punto de interrupción en la línea "int dummyPutBreakpointHere = 23;"

in main.C:

static QtMessageHandler defaultMessageHandler;
void myRazorsharpMessageHandler(QtMsgType type, const QMessageLogContext& context, const QString& msg) 
{
    if ( type > QtDebugMsg ) {
        int dummyPutBreakpointHere= 23;
    }
    defaultMessageHandler(type, context, msg);
}
...
later in main(): defaultMessageHandler= qInstallMessageHandler(0);

Answer 6

Puede utilizar el Qt IDE oficial: QtCreator . Contiene una consola de salida, donde verá ningún problema con las señales. error de la señal de salida son de depuración y liberación de ejecución.

Answer 7

puede redirigir stdout / stderr con bastante facilidad: hacer una clase que deriva de std :: basic_streambuf y sobrecarga xsputn () y desbordamiento (), a continuación, utilizar por ejemplo std :: cerr.rdbuf (instanceOfYourRedirectClass) para redirigir todo el ouptut stderr una función de devolución de llamada que usted provee.

Aquí hay una versión simplificada de lo que yo uso; en función de sus necesidades puede que tenga que agregar lógica adicional para jugar con el manejo de los caracteres de fin de línea, etc.

template< class Elem = char, class Tr = std::char_traits<Elem> >
class Redirector : public std::basic_streambuf<Elem, Tr>
{
  typedef void (*pfncb) ( const Elem*, std::streamsize );

public:
  Redirector( std::ostream& a_Stream, pfncb a_Cb ) :
    m_Stream( a_Stream ),
    m_pCbFunc( a_Cb ),
  {
      //redirect stream
    m_pBuf = m_Stream.rdbuf( this );
  };

  ~Redirector()
  {
      //restore stream
    m_Stream.rdbuf( m_pBuf );
  }

  std::streamsize xsputn( const Elem* _Ptr, std::streamsize _Count )
  {
    m_pCbFunc( _Ptr, _Count );
    return _Count;
  }

  typename Tr::int_type overflow( typename Tr::int_type v )
  {
    Elem ch = Tr::to_char_type( v );
    m_pCbFunc( &ch, 1 );
    return Tr::not_eof( v );
  }

 protected:
  std::basic_ostream<Elem, Tr>& m_Stream;
  std::streambuf*               m_pBuf;
  pfncb                         m_pCbFunc;
};

Uso:

  void outcallback( const char *ptr, std::streamsize count )
  {
    if( *ptr != gc_cEOL )  //ignore eof
      OutputDebugString( ptr );
  }

  Redirector<> redirect( std::cout, mycallback );