signal:
     void monSignal();

   emit monSignal();

   public slots:
     void monSlot();

   connect(this, SIGNAL(monSignal(), somethingElse, SLOT(monSlot()));;

monSignal(QString,int) //signature d'un signal
monSlot(QString,int) //signature d'un slot
connect(objet1,SIGNAL(monSignal(QString,int)),objet2,SLOT(monSlot(QString,int)))

connect(this,SIGNAL(monSignal(QString,int)),somethingElse,SLOT(monSlot(const QString&,int)));

connect(this,SIGNAL(monSignal(QString,int)),somethingElse,SLOT(monSlot(QString)))

class myClass : public xxx
{
    Q_OBJECT
    ...
signals:
    void monSignal(type1,type2)
public slots:
    void monSlot(type1,type2);
    ...
}

void fonction()
{
    nom_type t;
    emit monSignal(t);
}

QMetaObject::connectSlotsByName(QObject *object);

class MainWindows : public QWidget
{
    Q_OBJECT
public :
    MainWindows(QWidget * parent = 0);
 
public slots :
    //slot qui sera connecté au signal clicked de l'objet myButton
    //par l'autoconnect
    void on_myButton_clicked();
 
};

MainWindows::MainWindows(QWidget * parent):QWidget(parent)
{
    ...
    QPushButton * pButton = new QPushButton("essai auto connect");
    //nom du bouton pour être retrouvé par l'autoconnect
    pButton->setObjectName("myButton");
    ...
    //auto connection des signaux/slots
    QMetaObject::connectSlotsByName(this);
}

mapper = new QSignalMapper();
 
// Bouton 1
connect(bouton1, SIGNAL(clicked()), mapper, SLOT(map()));
mapper->setMapping(bouton1, "http://url1");
 
// Bouton 2
connect(bouton2, SIGNAL(clicked()), mapper, SLOT(map()));
mapper->setMapping(bouton2, "http://url2");
 
// Autres boutons ?

connect(mapper, SIGNAL(mapped(const QString &)), this, SLOT(openUrl(const QString &)));

#include <QtGui>

class MyQPushButton : public QPushButton
{
    public :
    //createur.
    //text : text du bouton
    //exe  : commande à exécuter lors de l'appui.
    MyQPushButton(const QString & text,const QString & exe, QWidget * parent = 0)
    : QPushButton (text,parent),
    m_exe(exe)
    {
        resize(75, 30);
        setFont(QFont("Times", 18, QFont::Bold));
    };
    virtual void mouseReleaseEvent ( QMouseEvent * event )
    {
        //lance la commande dans un process indépendant
        QProcess::startDetached (m_exe);
    }

    private :
        QString m_exe;

};

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    QWidget w;
    QVBoxLayout vl(&w);
    //boutton : ouvre grâce au CMD la page vers DVP/Qt
    MyQPushButton bouton1("Ouvrir DVP / Qt","cmd /c start http://qt.developpez.com/",&w);

    //boutton : lance notepad
    MyQPushButton bouton2("Ouvrir notepad","notepad",&w);

     //boutton : lance invite de commande
    MyQPushButton bouton3("Ouvrir invite de commande","cmd" ,&w);
    vl.addWidget(&bouton1);
    vl.addWidget(&bouton2);
    vl.addWidget(&bouton3);
    w.show();
    return app.exec();
}

#include <QtGui>

class MyQPushButton : public QPushButton
{
public :
    //createur.
    //text : texte du boutton
    //exe  : commande à executer lors de l'appui.
    MyQPushButton(const QString & text,const QString & url, QWidget * parent = 0)
    :  QPushButton (text,parent) , m_url(url)
    {
        resize(75, 30);
        setFont(QFont("Times", 18, QFont::Bold));
    };
    virtual void mouseReleaseEvent ( QMouseEvent * event )
    {
        QDesktopServices::openUrl(m_url);
    }

private :
    QString m_url;

};

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    QWidget w;
   
    //Action : ouvre l'url ver DVP /Qt
    MyQPushButton bouton1(" Ouvrir DVP / Qt","http://qt.developpez.com",&w);
    //Action : ouvre le fichier texte. /!\ ce fichier doit exister
    MyQPushButton bouton2("Ouvrir fichier txt","c:/test.txt",&w);
    //Action : ouvre l'edition d'un mail avec l'adresse et le sujet remplis
    MyQPushButton bouton3("Envoyer mail","mailto:qt@dvp.com?subject=test envoie mail" ,&w);
   
    QVBoxLayout vl(&w);
    vl.addWidget(&bouton1);
    vl.addWidget(&bouton2);
    vl.addWidget(&bouton3);
    w.show();
    return app.exec();
}

// définition du type de fonction
typedef int (*StringLength)(char*); 
// création d'un objet QLibrary lié à string_util (.dll, .so ou autre)
QLibrary lib("string_util"); 
// récupération d'un pointeur sur notre fonction partagée
StringLength strLength = (StringLength)lib.resolve("strlen"); 
if(strLength)
// devrait renvoyer 9... si tout va bien  ;) 
    strLength("QLibrary"); 

#include <QApplication>
#include <QLCDNumber>
#include <QPushButton>
#include <QTimer>
#include <QGridLayout>
 
class TimerChrono : public QWidget
{
    Q_OBJECT
 
private :
    //Bouton servant de "Start" "Stop"
    QPushButton* m_Bouton_StartStop;
    //Bouton "Reset"
    QPushButton* m_Bouton_Reset;
    //Afficheur de type LCD
    QLCDNumber* m_LCD;
    //Variable représentant le nombre de secondes écoulées depuis le lancement du timer
    int m_Timer_value;
    //Timer servant de base à notre Chronomètre
    QTimer* m_timer;
    //Permet de savoir si l'utilisateur a cliqué sur "Start" ou "Stop"
    bool validStart;
 
public :
    TimerChrono()
    {
        //Creation d'un afficheur LCD de 5 digits maximum
        this->m_LCD = new QLCDNumber(5, this);
        //Creation des contrôles de types boutons
        this->m_Bouton_StartStop = new QPushButton("Start",this);
        this->m_Bouton_Reset = new QPushButton("Reset",this);
        
        //Gestion du layout pour le placement des boutons
        QGridLayout *layout = new QGridLayout();
        layout->addWidget(m_LCD, 0, 0);
        layout->addWidget(m_Bouton_StartStop, 2,0);
        layout->addWidget(m_Bouton_Reset, 2,1);
        this->setLayout(layout);
         
        //On met à zeros le compteur représentant le nombre de seconde
        this->m_Timer_value=0;
        //Création du timer
        this->m_timer = new QTimer(this);
        //A chaque fin d'interval execution de la fonction update()
        connect(this->m_timer, SIGNAL(timeout()), this, SLOT(update()));
        //On applique un interval d'une seconde (1000 ms) entre chaque timeout du timer
        this->m_timer->setInterval(1000);
        //Sert pour la gestion du bouton "Start" "Stop"
        this->validStart=true;
        
        //On connecte les differents signaux et slots
        connect(this->m_Bouton_StartStop, SIGNAL(clicked(bool)), this, SLOT(click_StartStop(bool)));
        connect(this->m_Bouton_Reset, SIGNAL(clicked(bool)), this, SLOT(click_Reset(bool)));
         
         //Gestion de la taille de la fenêtre
        resize(200, 150); 
    }
 
private slots:
    //Fonction appellée toute les secondes par le QTimer
    void update()
    {
        //On incremente notre compteur de secondes
        m_Timer_value++;
        //On affiche le nombre de seconde ecoulé dans le contrôle QLCDNumber
        m_LCD->display(m_Timer_value);
    }
 
    //Bouton reset
    void click_Reset(bool valid)
    {
        // On arrete le timer
        this->m_timer->stop();
        //On met notre compteur à zero
        m_Timer_value=0;
        // On affiche Zero dans le controle LCD
        m_LCD->display(m_Timer_value);
        //Gestion du bouton "Start" "Stop"
        this->validStart=true;
        m_Bouton_StartStop->setText("Start");
    }

    //Bouton "Start" "Stop"
    void click_StartStop(bool valid)
    {
        //Si on click sur "Start"
        if(validStart == true)
        {
            //Affiche "Stop" sur le bouton
            m_Bouton_StartStop->setText("Stop");
            //Permet de savoir que le bouton est en mode "Strop"
            validStart = false;
            //On declanche le départ du Timer
            this->m_timer->start();
        }
        else//Si on click sur "Stop"
        {
            //Affiche "Sart" sur le bouton
            m_Bouton_StartStop->setText("Start");
            //Permet de savoir que le bouton est en mode "Start"
            validStart = true;
            //On arrete le compteur
            this->m_timer->stop();
        }
    }
}; 
 
#include "main.moc"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    TimerChrono w;
    w.show();
    return a.exec();
}

//L'objet time est initialisé à l'heure courante
QTime time = QTime::currentTime();

QTime time;
time.start();
ma_fonction();
//millisecondes contient le nombre de millisecondes entre l'appel à la fonction start() 
//et l'appel a la fonction elapsed().
int millisecondes = time.elapsed();

QStringList args = QCoreApplication::arguments();
QString nom_fichier = args[1];

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

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); 
}
// ...