   
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
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
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 )
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 )
void Q_ASSERT ( bool test )
void Q_ASSERT_X ( bool test, const char * where, const char * what )
void Q_CHECK_PTR ( void * pointer )
Q_DECLARE_TYPEINFO ( Type, Flags )
Q_FOREACH ( variable, container )
const char * Q_FUNC_INFO ()
qint64 Q_INT64_C ( literal )
quint64 Q_UINT64_C ( literal )
Q_UNUSED ( name )
foreach ( variable, container )
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.
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 *).
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.
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.
C'est un typedef pour un pointeur de fonction ayant la signature suivante :
void myMsgHandler(QtMsgType, const char *);
Voir aussi QtMsgType et qInstallMsgHandler().
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 pour signed char. Ce type sera toujours de taille 8 bits pour les plates-formes supportées par Qt.
Typedef pour signed short. Ce type sera toujours de taille 16 bits pour les plates-formes supportées par Qt.
Typedef pour signed int. Ce type sera toujours de taille 32 bits pour les plates-formes supportées par Qt.
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 pour long long int (__int64 sous Windows). Ceci est identique à qint64.
Voir aussi qulonglong et qint64.
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 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 pour unsigned char. Ce type sera toujours de taille 8 bits pour les plates-formes supportées par Qt.
Typedef pour unsigned short. Ce type sera toujours de taille 16 bits pour les plates-formes supportées par Qt.
Typedef pour unsigned int. Ce type sera toujours de taille 32 bits pour les plates-formes supportées par Qt.
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.
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 pour unsigned long long int (unsigned __int64 sous Windows). Identique à quint64.
Voir aussi quint64 et qlonglong.
Typedef de commodité pour unsigned char.
Typedef de commodité pour unsigned int.
Typedef de commodité pour unsigned long.
Typedef de commodité pour unsigned short.
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
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
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.
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.
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.
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.
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.
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.
Utilisez QSysInfo::MacintoshVersion à la place.
Voir aussi QSysInfo.
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().
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().
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
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
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.
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.
Utilise Q_CHECK_PTR sur pointer, puis retourne pointer.
Cette fonction peut être utilisée comme une version inline de Q_CHECK_PTR.
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().
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().
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().
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().
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.
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.
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().
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().
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().
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.
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(); }
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.
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.
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().
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.
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().
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().
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.
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().
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.
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.
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.
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.
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.
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.
Est définie si l'application est compilée avec Borland/Turbo C++.
Est définie si l'application est compilée avec Reliant C++.
Est définie si l'application est compilée avec Comeau C++.
Est définie si l'application est compilée avec DEC C++.
Est définie si l'application est compilée avec Edison Design Group C++.
Est définie si l'application est compilée avec Green Hills Optimizing C++ Compilers.
Est définie si l'application est compilée avec GNU C++.
Est définie si l'application est compilée avec MetaWare High C/C++.
Est définie si l'application est compilée avec HP aC++.
Est définie si l'application est compilée avec Intel C++ for Linux, Intel C++ for Windows.
Est définie si l'application est compilée avec KAI C++.
Est définie si l'application est compilée avec MIPSpro C++.
Est définie si l'application est compilée avec Microsoft Visual C/C++, Intel C++ for Windows.
Est définie si l'application est compilée avec Metrowerks CodeWarrior.
Est définie si l'application est compilée avec CenterLine C++.
Est définie si l'application est compilée avec Portland Group C++.
Est définie si l'application est compilée avec Forte Developer or Sun Studio C++.
Est définie si l'application est compilée avec Digital Mars C/C++ (used to be Symantec C++).
Est définie si l'application est compilée avec SCO OUDK and UDK.
Est définie si l'application est compilée avec Watcom C++.
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.
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 :
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);
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.
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.
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().
Identique à forever.
Cette macro est disponible même si no_keywords est spécifié dans la variable CONFIG du fichier .pro.
Voir aussi foreach().
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.
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().
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.
Définie sur AIX.
Définie sur n'importe quel système BSD 4.4.
Définie sur BSD/OS.
Définie sur Cygwin.
Définie sur Darwin OS (synonyme de Q_OS_MAC).
Définie sur DG/UX.
Définie sur DYNIX/ptx.
Définie sur FreeBSD.
Définie sur HP-UX.
Définie sur GNU Hurd.
Définie sur SGI Irix.
Définie sur Linux.
Définie sur LynxOS.
Définie sur MAC OS (synonyme de Darwin).
Définie sur MS-DOS et Windows.
Définie sur NetBSD.
Définie sur OS/2.
Définie sur OpenBSD.
Définie sur XFree86 sur OS/2 (et non PM).
Définie sur HP Tru64 UNIX.
Définie sur QNX Neutrino.
Définie sur Reliant UNIX.
Définie sur SCO OpenServer 5.
Définie sur Sun Solaris.
Définie sur Symbian.
Définie sur DEC Ultrix.
Définie sur tout système UNIX BSD/SYSV.
Définie sur UnixWare 7, Open UNIX 8.
Définie pour toutes les versions supportées de Windows.
Définie sur Windows CE.
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().
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.
Définie sur S60 avec le framework Avkon UI.
Voir aussi Q_WS_MAC, Q_WS_WIN, Q_WS_X11 et Q_WS_QWS.
Définie sur X11.
Voir aussi Q_WS_MAC, Q_WS_WIN, Q_WS_QWS et Q_WS_S60.
Définie sur Mac OS X.
Voir aussi Q_WS_WIN, Q_WS_X11, Q_WS_QWS et Q_WS_S60.
Définie sur Qt pour Linux embarqué.
Voir aussi Q_WS_MAC, Q_WS_WIN, Q_WS_X11 et Q_WS_S60.
Définie sur Windows.
Voir aussi Q_WS_MAC, Q_WS_X11, Q_WS_QWS et Q_WS_S60.
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_keywordsVoir aussi Q_FOREACH().
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_keywordsVoir aussi Q_FOREVER.
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().
Merci à Alexandre Laurent pour la traduction, ainsi qu'à Ilya Diallo et Claude Leloup pour la relecture !
| 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 © 2024 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 ? Un bug ? 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 ! | ||