Developpez.com

Qt

Choisissez la catégorie, puis la rubrique :

Viadeo Twitter Facebook Share on Google+   
Logo Documentation Qt ·  Page d'accueil  ·  Toutes les classes  ·  Toutes les fonctions  ·  Vues d'ensemble  · 

- Déclarations globales de Qt

Le fichier d'en-tête <QtGlobal> inclut les déclarations globales fondamentales de Qt. Il est inclus par la plupart des autres fichiers d'en-tête de Qt. Plus d'informations...

Types

typedef QtMsgHandler

enum QtMsgType { QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg }

typedef qint8

typedef qint16

typedef qint32

typedef qint64

typedef qlonglong

typedef qptrdiff

typedef qreal

typedef quint8

typedef quint16

typedef quint32

typedef quint64

typedef quintptr

typedef qulonglong

typedef uchar

typedef uint

typedef ulong

typedef ushort

Fonctions

T qAbs ( const T & value )

const T & qBound ( const T & min, const T & value, const T & max )

void qCritical ( const char * msg, ... )

void qDebug ( const char * msg, ... )

void qFatal ( const char * msg, ... )

bool qFuzzyCompare ( double p1, double p2 )

bool qFuzzyCompare ( float p1, float p2 )

QtMsgHandler qInstallMsgHandler ( QtMsgHandler handler )

int qMacVersion ()

const T & qMax ( const T & value1, const T & value2 )

const T & qMin ( const T & value1, const T & value2 )

qint64 qRound64 ( qreal value )

int qRound ( qreal value )

const char * qVersion ()

void qWarning ( const char * msg, ... )

T * q_check_ptr ( T * pointer )

QByteArray qgetenv ( const char * varName )

bool qputenv ( const char * varName, const QByteArray & value )

int qrand ()

void qsrand ( uint seed )

QString qtTrId ( const char * id, int n = -1 )

void qt_set_sequence_auto_mnemonic ( bool on )

int qt_symbian_exception2Error ( const std::exception & aThrow )

void qt_symbian_exception2LeaveL ( const std::exception & aThrow )

void qt_symbian_throwIfError ( int error )

Macros

QT_POINTER_SIZE

QT_REQUIRE_VERSION ( int argc, char ** argv, const char * version )

QT_TRANSLATE_NOOP3 ( context, sourceText, comment )

QT_TRANSLATE_NOOP ( context, sourceText )

QT_TRAP_THROWING ( function )

QT_TRID_NOOP ( id )

QT_TRYCATCH_ERROR ( error, function )

QT_TRYCATCH_LEAVING ( function )

QT_TR_NOOP ( sourceText )

QT_VERSION

QT_VERSION_CHECK

QT_VERSION_STR

void Q_ASSERT ( bool test )

void Q_ASSERT_X ( bool test, const char * where, const char * what )

Q_BIG_ENDIAN

Q_BYTE_ORDER

Q_CC_BOR

Q_CC_CDS

Q_CC_COMEAU

Q_CC_DEC

Q_CC_EDG

Q_CC_GHS

Q_CC_GNU

Q_CC_HIGHC

Q_CC_HPACC

Q_CC_INTEL

Q_CC_KAI

Q_CC_MIPS

Q_CC_MSVC

Q_CC_MWERKS

Q_CC_OC

Q_CC_PGI

Q_CC_SUN

Q_CC_SYM

Q_CC_USLC

Q_CC_WAT

void Q_CHECK_PTR ( void * pointer )

Q_DECLARE_TYPEINFO ( Type, Flags )

Q_DECL_EXPORT

Q_DECL_IMPORT

Q_FOREACH ( variable, container )

Q_FOREVER

const char * Q_FUNC_INFO ()

qint64 Q_INT64_C ( literal )

Q_LITTLE_ENDIAN

Q_OS_AIX

Q_OS_BSD4

Q_OS_BSDI

Q_OS_CYGWIN

Q_OS_DARWIN

Q_OS_DGUX

Q_OS_DYNIX

Q_OS_FREEBSD

Q_OS_HPUX

Q_OS_HURD

Q_OS_IRIX

Q_OS_LINUX

Q_OS_LYNX

Q_OS_MAC

Q_OS_MSDOS

Q_OS_NETBSD

Q_OS_OS2

Q_OS_OPENBSD

Q_OS_OS2EMX

Q_OS_OSF

Q_OS_QNX

Q_OS_RELIANT

Q_OS_SCO

Q_OS_SOLARIS

Q_OS_SYMBIAN

Q_OS_ULTRIX

Q_OS_UNIX

Q_OS_UNIXWARE

Q_OS_WIN32

Q_OS_WINCE

quint64 Q_UINT64_C ( literal )

Q_UNUSED ( name )

Q_WS_S60

Q_WS_X11

Q_WS_MAC

Q_WS_QWS

Q_WS_WIN

foreach ( variable, container )

forever

const char * qPrintable ( const QString & str )

Les déclarations globales incluent des types, des fonctions et des macros.

Les définitions des types sont en partie des redéfinitions de types de base (certains garantissent une taille fixe pour toutes les plates-formes sur lesquelles Qt fonctionne) et en partie des types liés à la gestion des messages Qt. Les fonctions sont liées à la gestion des messages, à la gestion des versions de Qt et à la comparaison et l'ajustement des valeurs des objets. Enfin, certaines macros permettent aux programmeurs d'ajouter du code spécifique à la plate-forme dans leurs applications, alors que d'autres macros facilitent des opérations lourdes.

Types

Le fichier d'en-tête déclare plusieurs définitions de types qui garantissent une certaine taille pour toutes les plates-formes pour différents types de base, par exemple qint8 est un caractère signé qui aura toujours une taille de 8 bits sur toutes les plates-formes. Le fichier d'en-tête déclare aussi le type qlonglong pour long long int (__int64 sous Windows).

Plusieurs définitions de type sont des déclarations de commodité : qreal pour double, uchar pour unsigned char, uint pour unsigned int, ulong pour unsigned long et ushort pour unsigned short.

Pour finir, la définition QtMsgType identifie les divers messages qui peuvent être générés et envoyés à un gestionnaire de messages Qt ; QtMsgHandler est une définition de type pour un pointeur vers une fonction ayant la signature void myMsgHandler(QtMsgType, const char *).

Fonctions

Le fichier d'en-tête <QtGlobal> contient plusieurs fonctions comparant et ajustant les valeurs des objets. Ces fonctions prennent un type template comme argument : vous pouvez récupérer la valeur absolue d'un objet avec la fonction qAbs() et vous pouvez borner la valeur d'un objet en donnant un minimum et un maximum à la fonction qBound(). Vous pouvez récupérer le minimum et le maximum de deux objets donnés avec les fonctions qMin() et qMax() respectivement. Toutes ces fonctions retournent le type template correspondant ; les types template peuvent être remplacés par n'importe quel autre type.

Exemple :

 int myValeur = 10;
 
 int minValeur = 2;
 
 int maxValeur = 6;
 
 
 
 int boundedValeur = qBound(minValeur, myValeur, maxValeur);
 
 // boundedValeur == 6

<QtGlobal> contient aussi des fonctions pour générer des messages à partir de la chaîne de caractères passée en argument : qCritical(), qDebug(), qFatal() et qWarning(). Ces fonctions appellent le gestionnaire de messages avec le message donné.

Exemple :

 if (!driver()->isOpen() || driver()->isOpenError()) {
 
     qWarning("QSqlQuery::exec: database not open");
 
     return false;
 
 }

Les fonctions restantes sont qRound() et qRound64(), qui acceptent une valeur qreal comme argument et retournent respectivement la valeur arrondie à l'entier ou à l'entier 64 bits supérieur. La fonction qInstallMsgHandler() installe le QtMsgHandler donné et la fonction qVersion() retourne à l'exécution le numéro de version de Qt dans une chaîne de caractères.

Macros

Le fichier d'en-tête <QtGlobal> fournit une série de macros (Q_CC_*) qui sont définies si l'application est compilée sur certaines plates-formes spécifiques. Par exemple, la macro Q_CC_SUN est définie si l?application est compilée avec Forte Developer ou Sun Studio C++. Le fichier d'en-tête déclare aussi un ensemble de macros (Q_OS_*) qui sont définies pour les plates-formes spécifiées. Par exemple, Q_OS_X11 est définie pour le système de fenêtres X.

Le but de ces macros est de permettre aux programmeurs d'ajouter du code spécifique aux plates-formes ou aux compilateurs dans l'application.

Les macros restantes sont des macros simplifiant des opérations plus lourdes : les macros QT_TRANSLATE_NOOP() et QT_TR_NOOP() permettent de marquer le texte pour une traduction dynamique, c'est-à-dire sans devoir changer le texte source. Les macros Q_ASSERT() et Q_ASSERT_X() activent des messages d'avertissement de divers niveaux d'importance. Les macros Q_FOREACH() et foreach() implémentent une boucle « pour chaque » dans Qt.

Les macros Q_INT64_C() et Q_UINT64_C() fournissent une représentation sur 64 bits d'un entier signé ou non signé indépendante de la plate-forme. La macro Q_CHECK_PTR() affiche un message d'avertissement contenant le nom de fichier du code source et le numéro de la ligne, disant que le programme n'a plus de mémoire, si le pointeur est nul. La macro qPrintable() fournit une méthode simple pour afficher du texte.

Pour finir, la macro QT_POINTER_SIZE donne la taille d'un pointeur en octets et les macros QT_VERSION et QT_VERSION_STR donnent dans une valeur numérique ou une chaîne de caractères, respectivement, le numéro de version de Qt, c'est-à-dire la version avec laquelle l'application est compilée.

Voir aussi <QtAlgorithms> et QSysInfo.

Documentation des types

typedef QtMsgHandler

C'est un typedef pour un pointeur de fonction ayant la signature suivante :

 void myMsgHandler(QtMsgType, const char *);

Voir aussi QtMsgType et qInstallMsgHandler().

enum QtMsgType

Cette énumération décrit les messages pouvant être envoyés au gestionnaire de messages (QtMsgHandler). Vous pouvez utiliser l'énumération pour identifier et associer les différents types de messages aux actions appropriées.

Constante Valeur Description
QtDebugMsg   Un message généré par la fonction qDebug().
QtWarningMsg 1 Un message généré par la fonction qWarning().
QtCriticalMsg 2 Un message généré par la fonction qCritical().
QtFatalMsg 3 Un message généré par la fonction qFatal().
QtSystemMsg QtCriticalMsg

Voir aussi QtMsgHandler et qInstallMsgHandler().

typedef qint8

Typedef pour signed char. Ce type sera toujours de taille 8 bits pour les plates-formes supportées par Qt.

typedef qint16

Typedef pour signed short. Ce type sera toujours de taille 16 bits pour les plates-formes supportées par Qt.

typedef qint32

Typedef pour signed int. Ce type sera toujours de taille 32 bits pour les plates-formes supportées par Qt.

typedef qint64

Typedef pour long long int (__int64 sous Windows). Ce type sera toujours de taille 64 bits pour les plates-formes supportées par Qt.

Des valeurs de ce type peuvent être créées avec la macro Q_INT64_C():

 qint64 value = Q_INT64_C(932838457459459);

Voir aussi Q_INT64_C(), quint64 et qlonglong.

typedef qlonglong

Typedef pour long long int (__int64 sous Windows). Ceci est identique à qint64.

Voir aussi qulonglong et qint64.

typedef qptrdiff

Type entier pour représenter les différences de pointeurs.

Typedef pour les qint32 ou qint64. Ce type sera toujours de la même taille que les pointeurs sur toutes les plates-formes supportés par Qt. Sur un système utilisant des pointeurs 32 bits, qptrdiff est un typedef pour quint32 ; sur un systèmes utilisant des pointeurs 64 bits, qptrdiff est un typedef pour quint64.

Notez que qtrdiff est signé. Utilisez quintptr pour des valeurs non signées.

Voir aussi quintptr, qint32 et qint64.

typedef qreal

Typedef pour double sur toutes les plates-formes sauf les CPU utilisant les architectures ARM. Sur les plates-formes basées sur ARM, qreal est un typedef pour float pour des raisons de performances.

typedef quint8

Typedef pour unsigned char. Ce type sera toujours de taille 8 bits pour les plates-formes supportées par Qt.

typedef quint16

Typedef pour unsigned short. Ce type sera toujours de taille 16 bits pour les plates-formes supportées par Qt.

typedef quint32

Typedef pour unsigned int. Ce type sera toujours de taille 32 bits pour les plates-formes supportées par Qt.

typedef quint64

Typedef pour unsigned long long int (unsigned __int64 sous Windows). Ce type sera toujours de taille 64 bits pour les plates-formes supportées par Qt.

Des valeurs de ce type peuvent être créées avec la macro Q_UINT64_C():

 quint64 value = Q_UINT64_C(932838457459459);

Voir aussi Q_UINT64_C(), qint64 et qulonglong.

typedef quintptr

Type entier représentant un pointeur (utile pour le hachage, etc.).

Typedef pour les quint32 ou quint64. Ce type sera toujours de la même taille que les pointeurs sur toutes les plates-formes supportées par Qt. Sur un système utilisant des pointeurs 32 bits, quintptr est un typedef pour quint32 ; sur un système utilisant des pointeurs 64 bits, quintptr est un typedef pour quint64.

Notez que quintptr est non signé. Utilisez qptrdiff pour des valeurs signées.

Voir aussi qptrdiff, quint32 et quint64.

typedef qulonglong

Typedef pour unsigned long long int (unsigned __int64 sous Windows). Identique à quint64.

Voir aussi quint64 et qlonglong.

typedef uchar

Typedef de commodité pour unsigned char.

typedef uint

Typedef de commodité pour unsigned int.

typedef ulong

Typedef de commodité pour unsigned long.

typedef ushort

Typedef de commodité pour unsigned short.

Documentation des fonctions

T qAbs ( const T & value )

Compare value au 0 du type T et retourne une valeur absolue. Donc si T est un double, value est comparé à (double) 0.

Exemple:

 int absoluteValue
 
 int myValue = -4;
 
 
 
 absoluteValue = qAbs(myValue);
 
 // absoluteValue == 4

const T & qBound ( const T & min, const T & value, const T & max )

Retourne la valeur value bornée par min et max. Cette fonction équivaut à qMax(min, qMin(value, max)).

Exemple:

 int myValue = 10;
 
 int minValue = 2;
 
 int maxValue = 6;
 
 
 
 int boundedValue = qBound(minValue, myValue, maxValue);
 
 // boundedValue == 6

Voir aussi qMin() et qMax().

void qCritical ( const char * msg, ... )

Appelle le gestionnaire de messages avec le message critique msg. Si aucun gestionnaire de messages n'est défini, le message est affiché sur stderr. Sous Windows, le message est envoyé au débogueur.

Cette fonction accepte une chaîne de caractères et une liste d'arguments, similaire à la fonction printf() du C. Le format doit être une chaîne de caractères Latin-1.

Exemple :

 void load(const QString &fileName)
 
 {
 
     QFile file(fileName);
 
     if (!file.exists())
 
         qCritical("File '%s' does not exist!", qPrintable(fileName));
 
 }

Si vous incluez <QtDebug>, une syntaxe plus pratique est disponible:

 qCritical() << "Brush:" << myQBrush << "Other
 
 value:" << i;

Un espace est ajouté entre les éléments et un saut de ligne est ajouté à la fin.

Pour supprimer les messages à l'exécution, installez votre propre gestionnaire de messages avec qInstallMsgHandler().

Voir aussi qDebug(), qWarning(), qFatal(), qInstallMsgHandler() et Techniques de débogage.

void qDebug ( const char * msg, ... )

Appelle le gestionnaire de messages avec le message de débogage msg. Si aucun gestionnaire de messages n'est défini, le message est affiché sur stderr. Sous Windows, le message est envoyé à la console, si c'est une application console ; sinon, le message est envoyé au débogueur. Cette fonction ne fait rien si QT_NO_DEBUG_OUTPUT a été défini durant la compilation.

Cette fonction accepte une chaîne de caractères et une liste d'arguments, similaire à la fonction printf() du C. Le format doit être une chaîne de caractères Latin-1.

Exemple :

 qDebug("Items in list: %d", myList.size());

Si vous incluez <QtDebug>, une syntaxe plus pratique est disponible:

 qDebug() << "Brush:" << myQBrush << "Other value:" << i;

Avec cette syntaxe, la fonction retourne un objet QDebug qui est configuré pour utiliser le type de message QtDebugMsg. Elle ajoute automatiquement un espace entre chaque élément et ajoute un saut de ligne à la fin. Elle accepte de nombreux types C++ et Qt.

Pour supprimer les messages à l'exécution, installez votre propre gestionnaire de messages avec qInstallMsgHandler().

Voir aussi qWarning(), qCritical(), qFatal(), qInstallMsgHandler() et Techniques de débogage.

void qFatal ( const char * msg, ... )

Appelle le gestionnaire de messages avec le message fatal msg. Si aucun gestionnaire de messages n'a été défini, le message est affiché sur la sortie d'erreur. Sous Windows, le message est envoyé au débogueur.

Si vous utilisez le gestionnaire de messages par défaut cette fonction, sur les systèmes Unix, arrêtera le programme pour créer un fichier dump du programme. Sous Windows, pour les compilations en debug, cette fonction produira une _CRT_ERROR vous permettant de vous connecter un débogueur à l'application.

Cette fonction accepte une chaîne de caractères et une liste d'arguments, de façon similaire à la fonction printf() du C.

Exemple :

 int divide(int a, int b)
 
 {
 
     if (b == 0)                                // erreur
 
         qFatal("divide: cannot divide by zero");
 
     return a / b;
 
 }

Pour supprimer les messages durant l'exécution, installez votre propre gestionnaire de messages avec qInstallMsgHandler().

Voir aussi qDebug(), qCritical(), qWarning(), qInstallMsgHandler() et Techniques de débogage.

bool qFuzzyCompare ( double p1, double p2 ) [static]

Compare les valeurs flottantes p1 et p2 et retourne true si elles sont considérées comme égales, sinon false.

Notez que si p1 ou p2 est 0.0, la comparaison ne fonctionnera pas. La solution est de comparer des valeurs plus grandes ou égales à 1.0.

         // Au lieu de comparer avec 0
 
                 qFuzzyCompare(0.0,1.0e-200); // Cela retournera faux
 
         // Compare en ajoutant 1 aux deux valeurs pour corriger le problème
 
                 qFuzzyCompare(1 + 0.0, 1 + 1.0e-200); // Cela retournera vrai

Les deux nombres sont comparés d'une façon relative, et plus les nombres sont petits, plus l'exactitude est forte.

Note : cette fonction est thread-safe.

Cette fonction a été introduite dans Qt 4.4.

bool qFuzzyCompare ( float p1, float p2 ) [static]

Compare deux valeurs flottantes p1 et p2 et retourne true si elles sont considérées égales, sinon false.

Les deux nombres sont comparés d'une façon relative, et plus les nombres sont petits, plus l'exactitude est forte.

Note : cette fonction est thread-safe.

Cette fonction a été introduite dans Qt 4.4.

QtMsgHandler qInstallMsgHandler ( QtMsgHandler handler )

Installe un gestionnaire de messages Qt qui a été défini précédemment. Retourne un pointeur sur le gestionnaire de messages précédent (qui peut être 0).

Le gestionnaire de messages est une fonction qui affiche les messages de débogage, d'avertissement, et les messages pour les erreurs critiques et fatales. La bibliothèque Qt (en compilation de débogage) contient des centaines de messages d'avertissement qui sont affichés lorsque des erreurs internes (souvent pour signaler des arguments invalides) sont envoyées. Lorsque Qt est compilé en release, il contient aussi des messages d'avertissements sauf si QT_NO_WARNING_OUTPUT et/ou QT_NO_DEBUG_OUTPUT ont été définis à la compilation. Si vous implémentez votre propre gestionnaire de messages, vous pouvez contrôler totalement ces messages.

Le gestionnaire de messages par défaut affiche les messages sur la sortie standard pour X11 ou dans le débogueur pour Windows. Si les messages sont fatals, l'application s'arrête immédiatement.

Un seul gestionnaire de messages peut être défini, car cela est généralement fait pour contrôler les messages de débogage pour toute l'application.

Pour restaurer le gestionnaire de messages, appelez qInstallMsgHandler(0).

Exemple :

 #include <qapplication.h>
 
 #include <stdio.h>
 
 #include <stdlib.h>
 
 
 
 void myMessageOutput(QtMsgType type, const char *msg)
 
 {
 
     switch (type) {
 
     case QtDebugMsg:
 
         fprintf(stderr, "Debug: %s\n", msg);
 
         break;
 
     case QtWarningMsg:
 
         fprintf(stderr, "Warning : %s\n", msg);
 
         break;
 
     case QtCriticalMsg:
 
         fprintf(stderr, "Critical: %s\n", msg);
 
         break;
 
     case QtFatalMsg:
 
         fprintf(stderr, "Fatal: %s\n", msg);
 
         abort();
 
     }
 
 }
 
 
 
 int main(int argc, char <nowiki>**</nowiki>argv)
 
 {
 
     qInstallMsgHandler(myMessageOutput);
 
     QApplication app(argc, argv);
 
     ...
 
     return app.exec();
 
 }

Voir aussi qDebug(), qWarning(), qCritical(), qFatal(), QtMsgType et Techniques de débogage.

int qMacVersion ()

Utilisez QSysInfo::MacintoshVersion à la place.

Voir aussi QSysInfo.

const T & qMax ( const T & value1, const T & value2 )

Retourne le maximum entre value1 et value2.

Exemple :

 int myValeur = 6;
 
 int yourValue = 4;
 
 
 
 int maxValue = qMax(myValue, yourValue);
 
 // maxValue == myValue

Voir aussi qMin() et qBound().

const T & qMin ( const T & value1, const T & value2 )

Retourne le minimum entre value1 et value2.

Exemple :

 int myValeur = 6;
 
 int yourValue = 4;
 
 
 
 int minValeur = qMin(myValue, yourValue);
 
 // minValue == yourValue

Voir aussi qMax() et qBound().

qint64 qRound64 ( qreal value )

Arrondit value à l'entier 64 bits le plus proche.

Exemple :

 qreal valueA = 42949672960.3;
 
 qreal valueB = 42949672960.7;
 
 
 
 int roundedValueA = qRound(valueA);
 
 // roundedValueA = 42949672960
 
 int roundedValueB = qRound(valueB);
 
 // roundedValueB = 42949672961

int qRound ( qreal value )

Arrondit value à l'entier le plus proche.

Exemple:

 qreal valueA = 2.3;
 
 qreal valueB = 2.7;
 
 
 
 int roundedValueA = qRound(valueA);
 
 // roundedValueA = 2
 
 int roundedValueB = qRound(valueB);
 
 // roundedValueB = 3

const char * qVersion ()

Retourne le numéro de version de Qt à l'exécution dans une chaîne de caractères (par exemple, « 4.1.2 »). Il s'agit d'une version différente de la version avec laquelle l'application a été compilée.

Voir aussi QT_VERSION_STR.

void qWarning ( const char * msg, ... )

Appelle le gestionnaire de messages avec le message d'avertissement msg. Si aucun gestionnaire de messages n'a été installé, le message est affiché sur la sortie d'erreur. Sous Windows, le message est envoyé au débogueur. Cette fonction ne fait rien si QT_NO_WARNING_OUTPUT a été défini durant la compilation ; la fonction termine le programme si la variable d'environnement QT_FATAL_WARNINGS est définie.

Cette fonction accepte une chaîne de caractères et une liste d'arguments, de façon similaire à la fonction printf() du C. Le format doit être une chaîne de caractères Latin-1.

Exemple:

 void f(int c)
 
 {
 
     if (c > 200)
 
         qWarning("f: bad argument, c == %d", c);
 
 }

Si vous incluez <QtDebug>, une syntaxe plus commode est disponible :

 qWarning() << "Brush:" << myQBrush << "Other value:"
 
 << i;

Un espace est ajouté entre les éléments et un saut de ligne est ajouté à la fin.

Pour supprimer la sortie pendant l'exécution, installez votre propre gestionnaire de messages avec qInstallMsgHandler().

Voir aussi qDebug(), qCritical(), qFatal(), qInstallMsgHandler() et Techniques de débogage.

T * q_check_ptr ( T * pointer )

Utilise Q_CHECK_PTR sur pointer, puis retourne pointer.

Cette fonction peut être utilisée comme une version inline de Q_CHECK_PTR.

QByteArray qgetenv ( const char * varName )

Retourne la valeur de la variable d'environnement varName. Pour la récupérer sous forme de chaîne de caractères, utilisez QByteArray::constData().

Note : qgetenv() a été implémenté car la fonction getenv() de la bibliothèque du standard C a été dépréciée dans VC2005 (ainsi que dans les versions suivantes). qgetenv() utilise la fonction de remplacement dans VC et appelle la fonction du standard pour les autres plates-formes.

Voir aussi qputenv().

bool qputenv ( const char * varName, const QByteArray & value )

Cette fonction donne la valeur value à la variable d'environnement nommée varName. Si la variable n'existe pas, elle sera créée. La fonction retourne 0 si la variable ne peut être modifiée.

Note : qputenv() a été introduit car la fonction putenv() de la bibliothèque standard du C a été dépréciée dans VC2005 (ainsi que dans les versions suivantes). qputenv() utilise la fonction de remplacement dans VS et appelle la fonction du standard pour les autres plates-formes.

Voir aussi qgetenv().

int qrand ()

Version Thread-safe de la fonction rand() du standard C++.

Retourne une valeur comprise entre 0 et RAND_MAX (définie dans <cstdlib> et <stdlib.h>), le nombre suivant de la séquence pseudoaléatoire de nombres entiers.

Utilisez qsrand() pour initialiser le générateur de nombres pseudoaléatoires avec une valeur source.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi qsrand().

void qsrand ( uint seed )

Version thread-safe de la fonction srand() du standard C++.

Utilise seed pour générer une nouvelle séquence de nombres entiers pseudoaléatoires pouvant être retournés par qrand().

La séquence de nombre aléatoires générée est déterministe par thread. Par exemple, si deux threads appellent qsrand(1) puis qrand(), les threads obtiendront la même séquence de nombres aléatoires.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi qrand().

QString qtTrId ( const char * id, int n = -1 )

La fonction qtTrId trouve et retourne une traduction de la chaîne de caractères.

Retourne la traduction d'une chaîne de caractères identifiée par id. Si aucune chaîne de caractères correspondante n'est trouvée, id est retournée. Cela ne devrait pas arriver dans des conditions normales.

Si n >= 0, toutes les occurrences de %n dans la chaîne de caractères résultante sont remplacées par la représentation décimale de n. De plus, selon la valeur de n›, la traduction du texte peut varier.

Les métadonnées et les commentaires peuvent être passés suivant la documentation de QObject::tr(). De plus, il est possible de fournir une chaîne de caractères template source comme suit :

//% <C string>

ou

/* % <C string> */

Exemple :

     //% "%n bar(s) trouvé(s).\n"
 
     //% "Voulez-vous continuer ?"
 
     QString text = qtTrId("qtn_foo_bar", n);

Pour créer des fichiers QM compatible avec cet usage, vous devez passer l'argument -idbased à l'outil lrelease.

Attention : cette méthode est réentrante seulement si tous les traducteurs sont installés avant l'appel à cette méthode. L'installation ou la suppression des traducteurs n'est pas supporté pendant la traduction. Le faire provoquera sûrement un crash ou un comportement indéterminé.

Note : cette fonction est réentrante.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi QObject::tr(), QCoreApplication::translate() et Internationalization with Qt.

void qt_set_sequence_auto_mnemonic ( bool on )

Active les mnémotechniques automatiques sur Mac si on est vrai ; sinon cette fonctionnalité est désactivée.

Notez que cette fonction n'est disponible que sur Mac, où les mnémotechniques sont désactivées par défaut.

Pour accéder à cette fonction, utilisez une déclaration externe : extern void qt_set_sequence_auto_mnemonic(bool b);

Voir aussi QShortcut.

int qt_symbian_exception2Error ( const std::exception & aThrow )

Convertit une l'exception standard du C++ aThrow en un code d'erreur Symbian.

Attention : cette fonction n'est disponible que sur Symbian.

Voir aussi qt_symbian_throwIfError() et qt_symbian_exception2LeaveL().

void qt_symbian_exception2LeaveL ( const std::exception & aThrow )

Convertit une exception standard C++ aThrow en une exception Symbian.

Attention : cette fonction n'est disponible que pour Symbian.

Voir aussi qt_symbian_throwIfError() et qt_symbian_exception2Error().

void qt_symbian_throwIfError ( int error )

Lance une exception si le paramètre error est un code d'erreur Symbian. C'est l'équivalent utilisant une exception de Symbian: User::LeaveIfError.

Attention : cette fonction n'est disponible que pour Symbian.

Voir aussi qt_symbian_exception2LeaveL() et qt_symbian_exception2Error().

Macro Documentation

QT_POINTER_SIZE

Donne la taille d'un pointeur en octets (4 ou 8). C'est équivalent à sizeof(void *) mais peut être utilisé comme une directive de préprocesseur.

QT_REQUIRE_VERSION ( int argc, char ** argv, const char * version )

Cette macro peut être utilisée pour s'assurer que l'application s'exécute avec une version suffisamment récente de Qt. C'est particulièrement utile si votre application dépend d'une correction de bogue (par exemple, 4.0.2).

Les paramètres argc et argv sont les paramètres argc et argv de la fonction main(). Le paramètre version est une chaîne de caractères qui indique la version de Qt dont l'application a besoin (par exemple, « 4.0.2 »).

Exemple:

 #include <QApplication>
 
 #include <QMessageBox>
 
 
 
 int main(int argc, char *argv[])
 
 {
 
     QT_REQUIRE_VERSION(argc, argv, "4.0.2")
 
 
 
     QApplication app(argc, argv);
 
     ...
 
     return app.exec();
 
 }

QT_TRANSLATE_NOOP3 ( context, sourceText, comment )

Marque la chaîne de caractères sourceText pour la traduction dynamique dans le contexte context donné et avec le commentaire comment, c'est-à-dire que le texte source sourceText stocké ne sera pas altéré. Le contexte context est normalement une classe et doit aussi être spécifié comme une chaîne de caractères. La chaîne de caractères de commentaire comment sera disponible pour les traducteurs utilisant par exemple Qt Linguist.

La macro retourne une structure anonyme contenant les deux chaînes de caractères sourceText et comment.

Exemple:

 static { const char *source; const char *comment; } greeting_strings[] =
 
 {
 
     QT_TRANSLATE_NOOP3("FriendlyConversation", "Hello",
 
                        "A really friendly hello"),
 
     QT_TRANSLATE_NOOP3("FriendlyConversation", "Goodbye",
 
                        "A really friendly goodbye")
 
 };
 
 
 
 QString FriendlyConversation::greeting(int type)
 
 {
 
     return tr(greeting_strings[type].source,
 
               greeting_strings[type].comment);
 
 }
 
 
 
 QString global_greeting(int type)
 
 {
 
     return qApp->translate("FriendlyConversation",
 
            greeting_strings[type].source,
 
            greeting_strings[type].comment);
 
 }

Cette fonction a été introduite dans Qt 4.4.

Voir aussi QT_TR_NOOP(), QT_TRANSLATE_NOOP() et Internationalisation avec Qt.

QT_TRANSLATE_NOOP ( context, sourceText )

Marque la chaîne de caractères sourceText pour la traduction dynamique, dans le contexte context donné ; c'est-à-dire que le texte source sourceText ne sera pas altéré. Le contexte context est normalement une classe et doit aussi être spécifié comme une chaîne de caractères.

La macro retourne sourceText.

Exemple:

 static const char *greeting_strings[] = {
 
     QT_TRANSLATE_NOOP("FriendlyConversation", "Hello"),
 
     QT_TRANSLATE_NOOP("FriendlyConversation", "Goodbye")
 
 };
 
 
 
 QString FriendlyConversation::greeting(int type)
 
 {
 
     return tr(greeting_strings[type]);
 
 }
 
 
 
 QString global_greeting(int type)
 
 {
 
     return qApp->translate("FriendlyConversation",
 
            greeting_strings[type]);
 
 }

Voir aussi QT_TR_NOOP(), QT_TRANSLATE_NOOP3() et Internationalisation avec Qt.

QT_TRAP_THROWING ( function )

TRAP quitte la fonction Symbian function et lance une exception standard C++ appropriée à la place. Cela doit être utilisé lors de l'appel aux fonctions sortantes du système Symbian dans Qt ou du code C++ standard, afin que le code puisse répondre correctement à l'exception.

Attention : cette macro n'est disponible que sur Symbian.

Exemple:

 // Une fonction sortante Symbian va être appelée dans une fonction Qt.
 
 // Toute sortie doit être convertie en une exception
 
 CAknTitlePane* titlePane = S60->titlePane();
 
 if (titlePane) {
 
     TPtrC captionPtr(qt_QString2TPtrC(caption));
 
     QT_TRAP_THROWING(titlePane->SetTextL(captionPtr));
 
 }

Voir aussi QT_TRYCATCH_ERROR() et QT_TRYCATCH_LEAVING().

QT_TRID_NOOP ( id )

La macro QT_TRID_NOOP marque un identifiant pour la traduction dynamique.

Le seul but de cette macro est de fournir une ancre pour l'attachement de métadonnées comme la fonction qtTrId().

La macro retourne id.

Exemple:

 static const char * const ids[] = {
 
     //% "This is the first text."
 
     QT_TRID_NOOP("qtn_1st_text"),
 
     //% "This is the second text."
 
     QT_TRID_NOOP("qtn_2nd_text"),
 
     0
 
 };
 
 
 
 void TheClass::addLabels()
 
 {
 
     for (int i = 0; ids[i]; ++i)
 
         new QLabel(qtTrId(ids[i]), this);
 
 }

Cette fonction a été introduite dans Qt 4.6.

Voir aussi qtTrId() et Internationalization with Qt.

QT_TRYCATCH_ERROR ( error, function )

Attrape les exceptions C++ standard de la fonction function et les convertit en un code d'erreur error Symbian OS error ou KErrNone s'il n'y a pas d'exception. Cette macro doit être utilisée dans Qt ou dans du code C++ standard lorsque le code peut lancer des exceptions (pratiquement tout code) et retourne un code d'erreur à Symbian OS.

Attention : cette macro n'est disponible que sous Symbian.

Exemple:

 // Une exception peut être lancée dans cette fonction retournant un code d'erreur Symbian TInt.
 
 // Elle est attrapée est traduite en un code d'erreur
 
 TInt QServerApp::Connect(const QString &serverName)
 
 {
 
     TPtrC name;
 
     TInt err;
 
     QT_TRYCATCH_ERROR(err, name.Set(qt_QString2TPtrC(serverName)));
 
     if (err != KErrNone)
 
         return err;
 
     return iServer.Connect(name);
 
 }

}

Voir aussi QT_TRYCATCH_LEAVING() et QT_TRAP_THROWING().

QT_TRYCATCH_LEAVING ( function )

Attrape les exceptions standard C++ de la fonction function et les convertit en sorties de système Symbian. Cette fonction doit être utilisée dans du code Qt ou du code standard C++ lorsqu'il peut lancer des exceptions (pratiquement tout code) et retourne une fonction sortante Symbian. Par exemple, dans une implémentation avec du code Qt de la fonction RunL d'un objet actif Symbian.

Attention : cette macro n'est disponible que pour Symbian.

Exemple:

 // Cet objet actif utilise du code Qt
 
 // Les exceptions venant du code Qt doivent être converties en sorties Symbian pour l'ordonnanceur actif
 
 void QWakeUpActiveObject::RunL()
 
 {
 
     iStatus = KRequestPending;
 
     SetActive();
 
     QT_TRYCATCH_LEAVING(m_dispatcher->wakeUpWasCalled());
 
 }

Voir aussi QT_TRAP_THROWING() et QT_TRYCATCH_ERROR().

QT_TR_NOOP ( sourceText )

Marque la chaîne de caractères sourceText pour la traduction dynamique dans le contexte courant (classe), c'est-à-dire que le texte source sourceText stocké ne sera pas altéré.

Cette macro donne sourceText.

Exemple :

 QString FriendlyConversation::greeting(int type)
 
 {
 
 static const char *greeting_strings[] = {
 
     QT_TR_NOOP("Hello"),
 
     QT_TR_NOOP("Goodbye")
 
 };
 
 return tr(greeting_strings[type]);
 
 }

La macro QT_TR_NOOP_UTF8() est identique à part qu'elle indique à lupdate que la chaîne de caractères source est encodée en UTF-8. Les variantes correspondantes existent dans la famille de macro QT_TRANSLATE_NOOP(). Notez que l'utilisation de ces macros n'est pas requise si CODECFORTR est déjà défini à UTF-8 dans le fichier de projet qmake.

Voir aussi QT_TRANSLATE_NOOP() et Internationalization with Qt.

QT_VERSION

Cette macro donne une valeur numérique de la forme 0xMMNNPP (MM = majeure, NN = mineure, PP = patch) qui spécifie le numéro de version Qt. Par exemple, si vous compilez votre application avec Qt 4.1.2, la macro QT_VERSION sera 0x040102.

Vous pouvez utiliser QT_VERSION pour utiliser les dernières fonctionnalités de Qt si elles sont disponibles.

Exemple :

 #if QT_VERSION >= 0x040100
 
     QIcon icon = style()->standardIcon(QStyle::SP_TrashIcon);
 
 #else
 
     QPixmap pixmap = style()->standardPixmap(QStyle::SP_TrashIcon);
 
     QIcon icon(pixmap);
 
 #endif

Voir aussi QT_VERSION_STR et qVersion().

QT_VERSION_CHECK

Transforme les numéros de versions en un entier, 0xMMNNPP (MM = majeure, NN = mineure, PP = patch). Celui-ci peut être comparé avec n'importe quel identifiant de version transformé de la même façon.

Voir aussi QT_VERSION.

QT_VERSION_STR

Cette macro donne une chaîne de caractères qui spécifie le numéro de version de Qt (par exemple, « 4.1.2 »). Cette version est la version avec laquelle l'application est compilée.

Voir aussi qVersion() et QT_VERSION.

void Q_ASSERT ( bool test )

Affiche un message d?avertissement contenant le nom du fichier source et le numéro de ligne si test est faux.

Q_ASSERT() est utile pour les tests de pré et postconditions durant le développement. Elle ne fait rien si QT_NO_DEBUG a été définie durant la compilation.

Exemple:

 // File: div.cpp
 
 
 
 #include <QtGlobal>
 
 
 
 int divide(int a, int b)
 
 {
 
     Q_ASSERT(b != 0);
 
     return a / b;
 
 }

Si b est zéro, la ligne Q_ASSERT affichera le message suivant en utilisant la fonction qFatal() :

 ASSERT: "b == 0" in file div.cpp, line 7

Voir aussi Q_ASSERT_X(), qFatal() et Techniques de débogage.

void Q_ASSERT_X ( bool test, const char * where, const char * what )

Affiche le message what avec la localisation where, le nom de fichier source et le numéro de ligne si test est faux.

Q_ASSERT_X est utile pour les tests des pré et postconditions durant le développement. Si QT_NO_DEBUG a été défini durant la compilation, Q_ASSERT_X ne fait rien.

Exemple:

 // File: div.cpp
 
 
 
 #include <QtGlobal>
 
 
 
 int divide(int a, int b)
 
 {
 
     Q_ASSERT_X(b != 0, "divide", "division by zero");
 
     return a / b;
 
 }

Si b est zéro, la ligne Q_ASSERT_X affichera le message suivant en utilisant la fonction qFatal() :

 ASSERT failure in divide: "division by zero", file div.cpp, line 7

Voir aussi Q_ASSERT(), qFatal() et Techniques de débogage.

Q_BIG_ENDIAN

Cette macro représente une valeur que vous pouvez comparer avec la macro Q_BYTE_ORDER pour déterminer le boutisme de votre système. Dans un système grand boutiste, l'octet significatif est stocké à l'adresse la plus basse. Les autres octets suivront dans l'ordre décroissant d'importance.

 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
 
 ...
 
 #endif

Voir aussi Q_BYTE_ORDER et Q_LITTLE_ENDIAN.

Q_BYTE_ORDER

Cette macro peut être utilisée pour déterminer l'ordre des octets que votre système utilise pour le stockage des données en mémoire, c'est-à-dire si votre système est petit boutiste ou grand boutiste. Il est définit par Qt à la valeur d'une des macros Q_LITTLE_ENDIAN ou Q_BIG_ENDIAN. Normalement, vous n'avez pas besoin de vous soucier du boutisme sauf si, par exemple, vous avez besoin de savoir quel octet d'un entier ou d'un caractère UTF-16 se trouve à l'adresse basse. Le boutisme est important pour le réseau, où les ordinateurs avec des valeurs de Q_BYTE_ORDER différentes peuvent échanger des données.

Utilisez cette macro comme dans l'exemple suivant.

 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
 
 ...
 
 #endif
 
 
 
 ou
 
 
 
 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
 
 ...
 
 #endif

Voir aussi Q_BIG_ENDIAN et Q_LITTLE_ENDIAN.

Q_CC_BOR

Est définie si l'application est compilée avec Borland/Turbo C++.

Q_CC_CDS

Est définie si l'application est compilée avec Reliant C++.

Q_CC_COMEAU

Est définie si l'application est compilée avec Comeau C++.

Q_CC_DEC

Est définie si l'application est compilée avec DEC C++.

Q_CC_EDG

Est définie si l'application est compilée avec Edison Design Group C++.

Q_CC_GHS

Est définie si l'application est compilée avec Green Hills Optimizing C++ Compilers.

Q_CC_GNU

Est définie si l'application est compilée avec GNU C++.

Q_CC_HIGHC

Est définie si l'application est compilée avec MetaWare High C/C++.

Q_CC_HPACC

Est définie si l'application est compilée avec HP aC++.

Q_CC_INTEL

Est définie si l'application est compilée avec Intel C++ for Linux, Intel C++ for Windows.

Q_CC_KAI

Est définie si l'application est compilée avec KAI C++.

Q_CC_MIPS

Est définie si l'application est compilée avec MIPSpro C++.

Q_CC_MSVC

Est définie si l'application est compilée avec Microsoft Visual C/C++, Intel C++ for Windows.

Q_CC_MWERKS

Est définie si l'application est compilée avec Metrowerks CodeWarrior.

Q_CC_OC

Est définie si l'application est compilée avec CenterLine C++.

Q_CC_PGI

Est définie si l'application est compilée avec Portland Group C++.

Q_CC_SUN

Est définie si l'application est compilée avec Forte Developer or Sun Studio C++.

Q_CC_SYM

Est définie si l'application est compilée avec Digital Mars C/C++ (used to be Symantec C++).

Q_CC_USLC

Est définie si l'application est compilée avec SCO OUDK and UDK.

Q_CC_WAT

Est définie si l'application est compilée avec Watcom C++.

void Q_CHECK_PTR ( void * pointer )

Si le pointeur pointer est 0, affiche un message d?avertissement contenant le nom du fichier source et le numéro de ligne, disant que le programme n'a plus de mémoire.

Q_CHECK_PTR ne fait rien si QT_NO_DEBUG a été définie durant la compilation.

Exemple :

 int *a;
 
 
 
 Q_CHECK_PTR(a = new int[80]);   // FAUX!
 
 
 
 a = new (nothrow) int[80];      // Correct
 
 Q_CHECK_PTR(a);

Voir aussi qWarning() et Techniques de débogage.

Q_DECLARE_TYPEINFO ( Type, Flags )

Vous pouvez utiliser cette macro pour spécifier des informations à propos d'un type Type personnalisé. Avec des informations de type précises, les conteneurs génériques de Qt peuvent choisir les algorithmes et méthodes de stockage appropriés.

L'indicateur Flags peut être l'un des suivants :

  • Q_PRIMITIVE_TYPE spécifie que Type représente des données brutes sans constructeur ni destructeur ;
  • Q_MOVABLE_TYPE spécifie que Type a un constructeur et/ou un destructeur mais qu'il peut être déplacé dans la mémoire avec memcpy() ;
  • Q_COMPLEX_TYPE (par défaut) spécifie que Type a des constructeurs et/ou un destructeur et qu'il ne peut pas être déplacé en mémoire.

Exemple d'un type « primitive » :

 struct Point2D
 
 {
 
     int x;
 
     int y;
 
 };
 
 
 
 Q_DECLARE_TYPEINFO(Point2D, Q_PRIMITIVE_TYPE);

Exemple d'un type déplaçable :

 class Point2D
 
 {
 
 public:
 
     Point2D() { data = new int[2]; }
 
     Point2D(const Point2D &other) { ... }
 
     ~Point2D() { delete[] data; }
 
 
 
     Point2D &operator=(const Point2D &other) { ... }
 
 
 
     int x() const { return data[0]; }
 
     int y() const { return data[1]; }
 
 
 
 private:
 
     int *data;
 
 };
 
 
 
 Q_DECLARE_TYPEINFO(Point2D, Q_MOVABLE_TYPE);

Q_DECL_EXPORT

Cette macro marque un symbole pour l'exportation dans une bibliothèque partagée (voir Création de bibliothèques partagées).

Voir aussi Q_DECL_IMPORT.

Q_DECL_IMPORT

Cette macro marque un symbole comme étant importé à partir d'une bibliothèque partagée (voir Création de bibliothèques partagées).

Voir aussi Q_DECL_EXPORT.

Q_FOREACH ( variable, container )

Identique à foreach(variable, container).

Cette macro est disponible même si no_keywords est spécifié dans la variable CONFIG du fichier .pro.

Voir aussi foreach().

Q_FOREVER

Identique à forever.

Cette macro est disponible même si no_keywords est spécifié dans la variable CONFIG du fichier .pro.

Voir aussi foreach().

const char * Q_FUNC_INFO ()

Fournit une chaîne de caractères qui décrit la fonction dans laquelle la macro se trouve. Le contenu exact de cette chaîne dépend du compilateur. Avec GNU GCC, c'est généralement la signature de la fonction, alors qu'avec d'autres compilateurs cela peut être le numéro de ligne et de colonne.

Il peut être commode d'utiliser qDebug() avec Q_FUNC_INFO. Par exemple, cette fonction :

 template<typename TInputType>
 
 const TInputType &myMin(const TInputType &value1, const TInputType &value2)
 
 {
 
     qDebug() << Q_FUNC_INFO << "was called with value1:" << value1 << "value2:" << value2;
 
 
 
     if(value1 < value2)
 
         return value1;
 
     else
 
         return value2;
 
 }

au moment de l'instanciation avec un type entier, elle produira avec le compilateur GCC :

const TInputType& myMin(const TInputType&, const TInputType&) [with TInputType = int] was called with value1: 3 value2: 4

Si cette macro est utilisée en dehors d'une fonction, le comportement est non défini.

qint64 Q_INT64_C ( literal )

Encapsule l'entier literal 64 bit signé d'une manière indépendante de la plate-forme.

Exemple :

 qint64 value = Q_INT64_C(932838457459459);

Voir aussi qint64 et Q_UINT64_C().

Q_LITTLE_ENDIAN

Cette macro représente une valeur que vous pouvez comparer avec la macro Q_BYTE_ORDER pour déterminer le boutisme de votre système. Dans un système petit boutiste, l'octet de poids faible est stocké à l'adresse de poids faible. Les autres octets suivent dans l'ordre de poids croissant.

 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
 
 ...
 
 #endif

Voir aussi Q_BYTE_ORDER et Q_BIG_ENDIAN.

Q_OS_AIX

Définie sur AIX.

Q_OS_BSD4

Définie sur n'importe quel système BSD 4.4.

Q_OS_BSDI

Définie sur BSD/OS.

Q_OS_CYGWIN

Définie sur Cygwin.

Q_OS_DARWIN

Définie sur Darwin OS (synonyme de Q_OS_MAC).

Q_OS_DGUX

Définie sur DG/UX.

Q_OS_DYNIX

Définie sur DYNIX/ptx.

Q_OS_FREEBSD

Définie sur FreeBSD.

Q_OS_HPUX

Définie sur HP-UX.

Q_OS_HURD

Définie sur GNU Hurd.

Q_OS_IRIX

Définie sur SGI Irix.

Q_OS_LINUX

Définie sur Linux.

Q_OS_LYNX

Définie sur LynxOS.

Q_OS_MAC

Définie sur MAC OS (synonyme de Darwin).

Q_OS_MSDOS

Définie sur MS-DOS et Windows.

Q_OS_NETBSD

Définie sur NetBSD.

Q_OS_OS2

Définie sur OS/2.

Q_OS_OPENBSD

Définie sur OpenBSD.

Q_OS_OS2EMX

Définie sur XFree86 sur OS/2 (et non PM).

Q_OS_OSF

Définie sur HP Tru64 UNIX.

Q_OS_QNX

Définie sur QNX Neutrino.

Q_OS_RELIANT

Définie sur Reliant UNIX.

Q_OS_SCO

Définie sur SCO OpenServer 5.

Q_OS_SOLARIS

Définie sur Sun Solaris.

Q_OS_SYMBIAN

Définie sur Symbian.

Q_OS_ULTRIX

Définie sur DEC Ultrix.

Q_OS_UNIX

Définie sur tout système UNIX BSD/SYSV.

Q_OS_UNIXWARE

Définie sur UnixWare 7, Open UNIX 8.

Q_OS_WIN32

Définie pour toutes les versions supportées de Windows.

Q_OS_WINCE

Définie sur Windows CE.

quint64 Q_UINT64_C ( literal )

Encapsule l'entier 64 bits non signé literal d'une façon indépendante de la plate-forme.

Exemple :

 quint64 value = Q_UINT64_C(932838457459459);

Voir aussi quint64 et Q_INT64_C().

Q_UNUSED ( name )

Indique au compilateur que le paramètre spécifié par name n'est pas utilisé dans le corps de cette fonction. Cela est utile pour supprimer les avertissements du compilateur tout en permettant aux fonctions d'être définies avec des noms de paramètres explicites dans leurs signatures.

Q_WS_S60

Définie sur S60 avec le framework Avkon UI.

Voir aussi Q_WS_MAC, Q_WS_WIN, Q_WS_X11 et Q_WS_QWS.

Q_WS_X11

Définie sur X11.

Voir aussi Q_WS_MAC, Q_WS_WIN, Q_WS_QWS et Q_WS_S60.

Q_WS_MAC

Définie sur Mac OS X.

Voir aussi Q_WS_WIN, Q_WS_X11, Q_WS_QWS et Q_WS_S60.

Q_WS_QWS

Définie sur Qt pour Linux embarqué.

Voir aussi Q_WS_MAC, Q_WS_WIN, Q_WS_X11 et Q_WS_S60.

Q_WS_WIN

Définie sur Windows.

Voir aussi Q_WS_MAC, Q_WS_X11, Q_WS_QWS et Q_WS_S60.

foreach ( variable, container )

Cette macro est utilisée pour implémenter la boucle foreach de Qt. Le paramètre variable est un nom de variable ou une définition de variable ; le paramètre container est un conteneur Qt contenant des variables du même type que variable. Voir The foreach Keyword pour plus de détails.

Si vous vous souciez de la pollution de l'espace de noms, vous pouvez désactiver cette macro en ajoutant la ligne suivante dans votre fichier .pro :

 CONFIG += no_keywords

Voir aussi Q_FOREACH().

forever

Cette macro est fournie par commodité pour l'écriture de boucles infinies.

Exemple :

 forever {
 
     ...
 
 }

C'est l'équivalent de for (;;).

Si vous vous souciez de la pollution de l'espace de noms, vous pouvez désactiver cette macro en ajoutant la ligne suivante dans votre fichier .pro :

 CONFIG += no_keywords

Voir aussi Q_FOREVER.

const char * qPrintable ( const QString & str )

Retourne str tel un const char *. C'est l'équivalent de str.toLocal8Bit().constData().

Le pointeur sur char sera invalide après la ligne où qPrintable() est utilisée. Ceci dû au fait que le tableau retourné par toLocal8Bit() sortira de la portée.

Exemple :

 qWarning("%s: %s", qPrintable(key), qPrintable(value));

Voir aussi qDebug(), qWarning(), qCritical() et qFatal().

Remerciements

Merci à Alexandre Laurent pour la traduction, ainsi qu'à Ilya Diallo et Claude Leloup pour la relecture !

Warning: include(): https:// wrapper is disabled in the server configuration by allow_url_include=0 in /home/developpez/www/developpez-com/upload/qt/doc/bs.php on line 4 Warning: include(https://qt.developpez.com/index/rightColumn): failed to open stream: no suitable wrapper could be found in /home/developpez/www/developpez-com/upload/qt/doc/bs.php on line 4 Warning: include(): Failed opening 'https://qt.developpez.com/index/rightColumn' for inclusion (include_path='.:/usr/php53/lib/php') in /home/developpez/www/developpez-com/upload/qt/doc/bs.php on line 4
Cette page est une traduction d'une page de la documentation de Qt, écrite par Nokia Corporation and/or its subsidiary(-ies). Les éventuels problèmes résultant d'une mauvaise traduction ne sont pas imputables à Nokia. Qt 4.7
Copyright © 2018 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon, vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
Vous avez déniché une erreur, une redirection cassée ou tout autre problème, quel qu'il soit ? Ou bien vous désirez participer à ce projet de traduction ? N'hésitez pas à nous contacter ou par MP !
Responsable bénévole de la rubrique Qt : Thibaut Cuvelier -