Seite 1 von 1

[gelöst]Programm riesig nach kompilieren - QHttp schuld?

Verfasst: 11. April 2006 20:20
von oberschlingel
Habe gerade ein winziges Programm aus der c't getestet, dass eine Datei aus dem Internet herunterlädt:

pro-File (httpdownload.pro)

Code: Alles auswählen

HEADERS= receiver.h
SOURCES= httpdownload.cpp
QT += network

unix {
  MOC_DIR = .moc
  OBJECTS_DIR = .obj
  UI_DIR = .ui
}
!unix {
  MOC_DIR = _moc
  OBJECTS_DIR = _obj
  UI_DIR = _ui
}
main.cpp

Code: Alles auswählen

#include <QApplication>
#include <QFile>
#include <QHttp>
#include <QMessageBox>
#include "receiver.h"

int main( int argc, char** argv ) {
    QApplication app( argc, argv );

    if( argc != 2 ) {
        QMessageBox::warning( 0, "Fehler", "Aufruf: httpdownload <dateiname>" );
        return -1;
    }

    QHttp http;
    Receiver receiver( &http );

    QFile targetFile( argv[1] );
    if( targetFile.open( QIODevice::WriteOnly ) ) {
        QObject::connect( &http, SIGNAL( done( bool ) ), &receiver, SLOT( slotDone( bool ) ) );
        http.setHost( "www.ecb.int" );
        http.get( "/stats/eurofxref/eurofxref-hist.xml", &targetFile );
    } else {
        QMessageBox::warning( 0, "Fehler", QString( "Konnte Ausgabedatei %1 nicht öffnen" ).arg( argv[1] ) );
        return -2;
    }

    int ret = app.exec();
    targetFile.close();
    return ret;
}
receiver.h

Code: Alles auswählen

#ifndef RECEIVER_H
#define RECEIVER_H

#include <QApplication>
#include <QHttp>
#include <QMessageBox>

class Receiver : public QObject
{
    Q_OBJECT

public:
    Receiver( QHttp* http ) : mHttp( http ) {}

public slots:
    void slotDone( bool error )
        {
            if( error )
                QMessageBox::warning( 0, "Fehler", QString( "Beim Herunterladen ist der Fehler %1 aufgetreten." ).arg( mHttp->errorString() ) );
            QApplication::instance()->quit();
        }

private:
    QHttp* mHttp;
};

#endif /* RECEIVER_H */
Nach dem Kompilieren unter Windows ist die exe-Datei 46 MB gross! Woran liegt das?

Danke für eure Antworten!

Verfasst: 11. April 2006 20:28
von ChMaster
servus,

füg das mal in die pro datei hinzu:
CONFIG += release warn_on qt thread

wurden die qt sourcen statisch gebaut?

Verfasst: 11. April 2006 20:32
von patrik08
bei mir ist diese apps 31 KB leicht

habe aber noch CONFIG += qt warn_on release in die pro datei zugefuegt...

und braucht die libs

depends.exe sagt....

c:\mingw\bin\MINGWM10.DLL
d:\qt\qt4\bin\QTCORE4.DLL
d:\qt\qt4\bin\QTGUI4.DLL
d:\qt\qt4\bin\QTNETWORK4.DLL

etwa 5-7 MB

ich gehe in der annhame das du static qt gebaut hast....

Verfasst: 11. April 2006 21:29
von BartSimpson
oder die debug oder schlimmer statisch und debug.

Verfasst: 11. April 2006 21:54
von oberschlingel
DANKE für eure Antworten, ich prüf das ganze jetzt mal. Gebe dann nochmal ein Feedback.

Verfasst: 11. April 2006 22:05
von oberschlingel
Super, jetzt hat die Datei 5,9 MB.

Sehe ich das richtig, und

Code: Alles auswählen

CONFIG += release warn_on qt thread
sorgt dafür, das 1. (release) das ganze veröffentlicht und nicht gedebugged wird, 2. Warnungen angeschaltet werden und 3. (qt thread) Threads benutzt werden (wozu?)?

Und kann mir jemand kurz sagen, wozu das hier nötig ist:

Code: Alles auswählen

unix {
  MOC_DIR = .moc
  OBJECTS_DIR = .obj
  UI_DIR = .ui
}
!unix {
  MOC_DIR = _moc
  OBJECTS_DIR = _obj
  UI_DIR = _ui
}
Und zu guter letzt noch eine letzte (vermutlich sehr doofe) Frage: Was ist der Unterschied, ob ich in meiner Header-Datei #include <QMessageBox> schreibe, oder class QMessageBox; ?

Vielen Dank!

Verfasst: 11. April 2006 23:16
von BartSimpson
das 2. ist schneller, da die header Datei nicht lesen werden muss. Das kannste aber nur machen, wenn du als Datentpen ein Zeiger nutzen willst.
das mit dem unix diet zur angabe, wo er under Unix und nicht Unix Systemen die temporären Datein ablegen soll.

Verfasst: 12. April 2006 06:58
von Christian81
BartSimpson hat geschrieben:das 2. ist schneller, da die header Datei nicht lesen werden muss.
Sobald aber mehr als nur der Zeiger benutzt wird (z.B. eine Funktion der Klasse aufgerufen), ists vorbei.
Und soo viel schneller ists nun auch nicht. Meistens wird diese Art der Vorwärtsdeklaration in Headern benutzt um unnötige Dependencies zu vermeiden.