Historiquement, la fonction main() était de type void et ne recevait aucun paramètre. Plus récemment, une évolution de l'usage de main a consisté à l'introduction des arguments int argc et char *argv[]. Ces arguments sont complémentaires : char *argv[] représente un tableau de pointeurs dont la taille est définie par int argc. Typiquement, argv[0] contient le nom du fichier de l'exécutable, avec son chemin complet, tandis que les paramètres suivants, optionnels, peuvent contenir une liste de noms de fichiers à traiter par le programme et/ou des options à prendre en compte, auquel cas argc > 1.

Il est possible de récupérer les arguments à l'aide de la fonction QCoreApplication::arguments, qui contiendra par exemple le nom de fichier passé en paramètre au lancement du programme. Si un fichier est ouvert par notre application (par le biais d'un "ouvrir avec", ou par une association de fichier), c'est le nom de ce fichier qui sera passé en paramètre. Le code suivant permet d'attribuer à la variable nom_fichier le paramètre passé à l'application, s'il existe, ou une chaîne vide dans le cas contraire.

QStringList args = QCoreApplication::arguments();
// Toujours tester si le paramètre existe, avant de l'utiliser
QString nom_fichier = (argc > 1 ? args[1] : "";

Note : la déclaration de la fonction main() doit contenir les arguments mentionnés :

int main (int argc, char *argv[])
{
    QApplication app(argc,argv)
    // Suite du code
}

Remarque : en règle générale, le premier élément correspond au nom de l'exécutable. Suivant la plateforme et le mode d'exécution, cet élément peut aussi contenir le chemin relatif ou le chemin absolu de l'exécutable concaténé avec son nom.

L'exemple suivant illustre une manière de traiter le premier argument passé à l'application.

const QStringList args = QCoreApplication::arguments();
// Si le programme a été ouvert par le biais d'un fichier
if(args.count() > 1)
{
    // On récupère le chemin du fichier...
    QString nom_fichier = args[1];
    // ... et on appelle une éventuelle fonction de lecture
    lireFichier(nom_fichier, this);
}
// ...

Attention : sous macOS, le double-clic sur un fichier ne sera pas renseigné dans les arguments, contrairement à Windows et Linux. Pour cela il faut utiliser QFileOpenEvent.

Qt fournit, à partir sa version 4.4, la classe QSharedMemory. Celle-ci permet la création de zones de mémoire partagées entre plusieurs applications. C'est en créant une zone mémoire partagée unique à notre application et en vérifiant au début du programme si celle-ci existe déjà que nous allons savoir si notre application est déjà lancée.

#include <QSharedMemory>
#include <QPushButton>
#include <QMessageBox>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    /* Création de la zone de mémoire partagée identifiée par une chaîne de caractères.
    *  On utilisera un GUID pour avoir un identifiant unique pour qu'il n'y ait pas de conflit
    *  possible avec d'autres applications    */
    QSharedMemory sharedMemory("{69B55631-A712-4d8c-8852-A8ED297EF439}");

    // On vérifie à la création de cette zone mémoire si celle-ci existe
    if(sharedMemory.create(sizeof(int))==false)
    {
        // Utilisation d'une QMessageBox pour prévenir l'utilisateur que le programme est déjà lancé
        QMessageBox msgBox;
        msgBox.setText("L'application est déjà lancée");
        msgBox.exec();
        return 1; // On ferme l'application
    }

    QPushButton button("Hello Qt");
    button.show();
    return a.exec();
}

Les classes QtSingleApplication et QtSingleCoreApplication permettent également d'effectuer cette vérification. Elles sont présentes dans les Qt Solutions sous licence LGPL.

La combinaison Alt+F4 est gérée par Windows et Qt n'a aucun contrôle dessus. Vous pouvez essayer de contourner ceci en utilisant un QTimer pour calculer le temps entre l'appui sur la touche Alt et le moment où vous recevez l'événement closeEvent(), déclenché par Windows après un Alt+F4. Si closeEvent() est reçu avant, disons, 300 millisecondes vous pouvez ignorer l'événement et supposer que Alt+F4 a été utilisé. Voici un exemple :

#include <QtGui>
 
class MainWindow : public QMainWindow
{
  Q_OBJECT
public:
  MainWindow() : QMainWindow()
  {
    altPressed = false;
    installEventFilter(this);
  }
   bool eventFilter(QObject *o, QEvent *e)
   {
    if (e->type() == QEvent::ShortcutOverride) {
      QKeyEvent *event = (QKeyEvent *)e;
             
      if(event->modifiers() == Qt::AltModifier) {
        altPressed = true;
        QTimer::singleShot(300, this, SLOT(testSlot()));
        e->accept();
        return true;
      }
    }
    return QMainWindow::event(e);
   }
public slots:
     void testSlot()
     {
       qDebug() << "Alt + f4 a été enclenché";
       altPressed = false;
     }
private:
  bool altPressed;
 
};
 
#include "main.moc"
int main(int argc, char **argv)
{
  QApplication app(argc, argv);
  MainWindow main;
  main.show();
  return app.exec();
}