Index

$

• {$A}
  • Alignement des champs (Aligner les champs (Object Pascal))
• {$ALIGN}
  • Alignement des champs (Aligner les champs (Object Pascal))
• {$APPTYPE}
  • Type d'application (Type d'application (Object Pascal))
• {$ASSERTIONS}
  • Directives d'assertion (Directives d'assertion (Object Pascal))
• {$B}
  • Evaluation booléenne rapide (Evaluation booléenne rapide (directive de compilation Object Pascal))
• {$BOOLEVAL}
  • Evaluation booléenne rapide (Evaluation booléenne rapide (directive de compilation Object Pascal))
• {$C}
  • Directives d'assertion (Directives d'assertion (Object Pascal))
• {$D}
  • Informations de débogage (Informations de débogage (Object Pascal))
• {$DEBUGINFO}
  • Informations de débogage (Informations de débogage (Object Pascal))
• {$DEFINE}
  • Directive DEFINE (Directive DEFINE (Object Pascal))
• {$DENYPACKAGEUNIT}
  • Directive DENYPACKAGEUNIT (Directive DENYPACKAGEUNIT (Object Pascal))
• {$DESCRIPTION}
  • Description (Description (Object Pascal))
• {$DESIGNONLY}
  • Directive DESIGNONLY (Directive DESIGNONLY (Object Pascal))
• {$E}
  • Extension de l'exécutable (Extension de l'exécutable (Object Pascal))
• {$ELSE}
  • ELSE (ELSE (Object Pascal))
• {$ELSEIF}
  • ELSEIF (ELSEIF (Object Pascal))
• {$ENDIF}
  • Directive ENDIF (Directive ENDIF (Object Pascal))
• {$EXTENDEDSYNTAX}
  • Syntaxe étendue (Syntaxe étendue (Object Pascal))
• {$EXTENSION}
  • Extension de l'exécutable (Extension de l'exécutable (Object Pascal))
• {$EXTERNALSYM}
  • Symboles externes (Symboles externes (Object Pascal))
• {$G}
  • Données importées (Données importées)
• {$HIGHCHARUNICODE}
  • Directive HIGHCHARUNICODE (Directive HIGHCHARUNICODE (Object Pascal))
• {$HINTS}
  • Conseils (Conseils (Object Pascal))
• {$H+} ou {$H-}
  • Chaînes longues (Chaînes longues (Object Pascal))
• {$HPPEMIT}
  • HPPEMIT (HPPEMIT (Object Pascal))
• {$I}
  • Fichier d'inclusion (Fichier d'inclusion (Object Pascal))
• {$IF}
  • Directive IF (Directive IF (Object Pascal))
• {$IFDEF}
  • Directive IFDEF (Directive IFDEF (Object Pascal))
• {$IFEND}
  • Directive IFEND (Directive IFEND (Object Pascal))
• {$IFNDEF}
  • Directive IFNDEF (Directive IFNDEF (Object Pascal))
• {$IFOPT}
  • Directive IFOPT (Directive IFOPT (Object Pascal))
• {$IMAGEBASE}
  • Adresse de base de l'image (Adresse de base de l'image)
• {$IMPLICITBUILD}
  • Compilation implicite (Compilation implicite (Object Pascal))
• {$IMPORTEDDATA}
  • Données importées (Données importées)
• {$INCLUDE}
  • Fichier d'inclusion (Fichier d'inclusion (Object Pascal))
• {$IOCHECKS}
  • Contrôle des entrées et des sorties (Contrôle des entrées et des sorties (Object Pascal))
• {$I+} ou {$I-}
  • Contrôle des entrées et des sorties (Contrôle des entrées et des sorties (Object Pascal))
• {$L}
  • Liaison avec le fichier objet (Liaison avec le fichier objet (Object Pascal))
• {$LIB}
  • Directives de compilation pour les bibliothèques ou les objets partagés (Directives de compilation pour les bibliothèques ou les objets partagés (Object Pascal))
• {$LINK}
  • Liaison avec le fichier objet (Liaison avec le fichier objet (Object Pascal))
• {$LOCALSYMBOLS|
  • Symboles locaux (Symboles locaux (Object Pascal))
• {$LONGSTRINGS}
  • Chaînes longues (Chaînes longues (Object Pascal))
• {$L+} ou {$L-}
  • Symboles locaux (Symboles locaux (Object Pascal))
• {$M}
  • Informations de types à l'exécution (Informations de type à l'exécution (Object Pascal))
  • Tailles d'allocation mémoire (Tailles d'allocation mémoire (Object Pascal))
• {$MESSAGE}
  • Directive MESSAGE (Directive MESSAGE (Object Pascal))
• {$METHODINFO}
  • Directive METHODINFO (Directive METHODINFO (Object Pascal))
• {$MINENUMSIZE}
  • Taille minimum d'énumération (Taille minimum d'énumération (Object Pascal))
• {$MINSTACKSIZE}; {$MAXSTACKSIZE}
  • Tailles d'allocation mémoire (Tailles d'allocation mémoire (Object Pascal))
• {$NODEFINE}
  • NODEFINE (Directive NODEFINE (Object Pascal))
• {$NOINCLUDE}
  • NOINCLUDE (NOINCLUDE (Object Pascal))
• {$O}
  • Optimisation (Optimisation (Object Pascal))
• {$ObjExportAll}
  • Exportation des symboles (Exportation des symboles (Object Pascal))
• {$OPENSTRINGS}
  • Paramètres chaînes ouverts (Paramètres chaînes ouverts (Object Pascal))
• {$OPTIMIZATION}
  • Optimisation (Optimisation (Object Pascal))
• {$OVERFLOWCHECKS}
  • Vérification de débordement (Vérification de débordement (Object Pascal))
• {$P}
  • Paramètres chaînes ouverts (Paramètres chaînes ouverts (Object Pascal))
• {$POINTERMATH}
  • POINTERMATH (POINTERMATH (Object Pascal))
• {$Q}
  • Vérification de débordement (Vérification de débordement (Object Pascal))
• {$R}
  • Fichier ressource (Fichier ressource (Object Pascal))
• {$RANGECHECKS}
  • Vérification des limites (Vérification des intervalles)
• {$REALCOMPATIBILITY}
  • Compatibilité Real48 (Compatibilité Real48 (Object Pascal))
• {$REFERENCEINFO}; {$DEFINITIONINFO}
  • Déclaration de symboles et informations de référence croisée (Déclaration de symboles et informations de référence croisée (Object Pascal))
• {$REGION}; {$ENDREGION}
  • Régions (Régions)
• {$RESOURCE}
  • Fichier ressource (Fichier ressource (Object Pascal))
• {$R+} ou {$R-}
  • Vérification des limites (Vérification des intervalles)
• {$RUNONLY}
  • Directive RUNONLY (Directive RUNONLY (Object Pascal))
• {$SCOPEDENUMS}
  • Enumérations de portée (Enumérations de portée (Object Pascal))
• {$SetPEFlags}
  • PE (Indicateurs d'en-tête PE (Portable Executable) (Object Pascal))
• {$STACKFRAMES}
  • Cadres de pile (Cadres de pile (Object Pascal))
• {$T}
  • Contrôle du type des pointeurs (Contrôle du type des pointeurs (Object Pascal))
• {$TYPEDADDRESS}
  • Contrôle du type des pointeurs (Contrôle du type des pointeurs (Object Pascal))
• {$TYPEINFO}
  • Informations de types à l'exécution (Informations de type à l'exécution (Object Pascal))
• {$U}
  • Opérations FDIV du Pentium sécurisées (Opérations FDIV du Pentium sécurisées (Object Pascal))
• {$UNDEF}
  • Directive UNDEF (Directive UNDEF (Object Pascal))
• {$V}
  • Contrôle des chaînes var (Contrôle des chaînes var (Object Pascal))
• {$VARSTRINGCHECKS}
  • Contrôle des chaînes var (Contrôle des chaînes var (Object Pascal))
• {$W}
  • Cadres de pile (Cadres de pile (Object Pascal))
• {$WARN}
  • Messages d'avertissement (Messages d'avertissement (Object Pascal))
• {$WARNINGS}
  • Avertissements (Avertissements (Object Pascal))
• {$WEAKPACKAGEUNIT}
  • Packaging faible (Packaging faible)
• {$WRITEABLECONST}
  • Constantes typées affectables (Constantes typées affectables (Object Pascal))
• {$X}
  • Syntaxe étendue (Syntaxe étendue (Object Pascal))
• {$Y} ou {$YD}
  • Déclaration de symboles et informations de référence croisée (Déclaration de symboles et informations de référence croisée (Object Pascal))
• {$Z}
  • Taille minimum d'énumération (Taille minimum d'énumération (Object Pascal))

A

• accès
  • espaces de nommage, C++ (Accès aux éléments d'un espace de nommage)
  • espaces de nommage, C++ (Directive using)
  • espaces de nommage, C++ (Qualification d'accès explicite)
  • espaces de nommage, C++ (using)
• Achèvement du code
  • présentation (Achèvement de code)
• affectation
  • opérateurs, C++ (Opérateurs d'affectation)
• alias
  • espaces de nommage, C++ (Alias d'un espace de nommage)
• alignas
  • mots clés, C++ (alignas)
• alignof
  • mots clés, C++ (alignof)
• amies, des classes
  • spécificités du langage C++ (Amies de classes)
• and
  • représentations alternatives des tokens C++ (and, && (C++))
• AnsiStringT et la page de code
  • gestion C++ (Comment gérer la spécification de page de code AnsiString Object Pascal dans C++)
• appel de procédures et de fonctions
  • des procédures et des fonctions (Appel de procédures et de fonctions (Object Pascal))
• appels de fonction (Macros avec paramètres (C++))
  • structure du langage C++ (Appels de fonctions et conversion d'arguments)
• applications
  • compilation (Compilation des applications)
  • conception (Conception d'applications)
  • création (Création de projets)
  • débogage (Débogage des applications)
  • déploiement (Déploiement des applications)
• asm
  • mots clés, C++ (asm, _asm, __asm)
• audit de code
  • audit de code (Utilisation de l'audit de code)
• auto
  • mots clés, C++ (auto)
• __automated
  • mots clés, C++ (__automated)
• __automated
  • mots clés, C++ (__automated)
• axiom
  • mots clés, C++ (axiom)

B

• Barres de modification
  • dans l'éditeur de code (Editeur de code)
• bibliothèques chargées dynamiquement
  • bibliothèques (Ecriture de bibliothèques à chargement dynamique)
• bitand
  • spécificités du langage C++ (bitand, &)
• bitor
  • représentations alternatives des tokens C++ (bitor, |)
• blocs
  • structure du langage C++ (Blocs)
• _Bool
  • mots clés, C++ (_Bool)
• bool
  • mots clés, C++ (bool, false, true (C++))
• _Bool
  • mots clés, C++ (_Bool)
• bool __has_nothrow_assign ( typename T )
  • Fonctions trait de type C++0x (__has_nothrow_assign)
• bool __ has_nothrow_copy_constructor( typename T )
  • Fonctions trait de type C++0x (__has_nothrow_copy_constructor)
• bool __has_nothrow_default_constructor (typename T )
  • Fonctions trait de type C++0x (__has_nothrow_default_constructor)
• bool __has_trivial_assign (typename T )
  • Fonctions trait de type C++0x (__has_trivial_assign)
• bool __has_trivial_default_constructor (typename T )
  • Fonctions trait de type C++0x (__has_trivial_default_constructor)
• bool_has __trivial_default_constructor( typename T )
  • Fonctions trait de type C++0x (__has_trivial_copy_constructor)
• _bool __has_trivial_destructor (typename T )
  • Fonctions trait de type C++0x (__has_trivial_destructor)
• _bool __has_trivial_destructor (typename T )
  • fonctions trait de type C++0x (__has_trivial_destructor)
• bool __has_virtual_destructor (typename T )
  • Fonctions trait de type C++0x (__has_virtual_destructor)
• bool __is_abstract( typename T )
  • Fonctions trait de type C++0x (__is_abstract)
• bool __is_arithmetic(Typename T)
  • Fonctions trait de type C++0x (__is_arithmetic)
• bool __is_array( Typename T )
  • Fonctions trait de type C++0x (__is_array)
• bool __is_base_of ( typename Base, typename Derived )
  • Fonctions trait de type C++0x (__is_base_of)
• bool __is_class(T)
  • Fonctions trait de type C++0x (__is_class)
• bool __is_complete_type(T)
  • Fonctions trait de type C++0x (__is_complete_type (typename T ))
• bool __is_compound( typename T )
  • Fonctions trait de type C++0x (__is_compound)
• bool __is_const(typename T)
  • Fonctions trait de type C++0x (__is_const)
• bool __is_convertible (typename From, typename To )(typename T)
  • Fonctions trait de type C++0x (__is_convertible)
• bool __is_empty( typename T )
  • Fonctions trait de type C++0x (__is_empty)
• bool __is_enum_type( typename T )
  • Fonctions trait de type C++0x (__is_enum)
• bool __is_floating_point(typename T)
  • Fonctions trait de type C++0x (__is_floating_point)
• bool __is_function( typename T )
  • Fonctions trait de type C++0x (__is_function)
• bool __is_fundamental( typename T )
  • Fonctions trait de type C++0x (__is_fundamental)
• bool __is_integral(typename T)
  • Fonctions trait de type C++0x (__is_integral)
• bool __is_lvalue_expr( typename T )
  • Fonctions trait de type C++0x (__is_lvalue_expr)
• bool __is_lvalue_reference( typename T )
  • Fonctions trait de type C++0x (__is_lvalue_reference)
• bool __is_member_function_pointer( typename T )
  • Fonctions trait de type C++0x (__is_member_function_pointer)
• bool __is_member_object_pointer( typename T )
  • Fonctions trait de type C++0x (__is_member_object_pointer)
• bool __is_member_pointer( typename T )
  • Fonctions trait de type C++0x (__is_member_pointer)
• bool __is_object( typename T)
  • Fonctions trait de type C++0x (__is_object)
• bool __is_pod( typename T )
  • Fonctions trait de type C++0x (__is_pod)
• bool __is_pointer(Typename T )
  • Fonctions trait de type C++0x (__is_pointer)
• bool __is_polymorphic( typename T )
  • Fonctions trait de type C++0x (__is_polymorphic)
• bool __is_reference( typename T )
  • Fonctions trait de type C++0x (__is_reference)
• bool __is_rvalue_expr( typename T )
  • Fonctions trait de type C++0x (__is_rvalue_expr)
• bool __is_rvalue_reference( typename T )
  • Fonctions trait de type C++0x (__is_rvalue_reference)
• bool __is_same( typename T, typename U )
  • Fonctions trait de type C++0x (__is_same)
• bool __is_scalar( typename T )
  • Fonctions trait de type C++0x (__is_scalar)
• bool __is_signed( typename T )
  • Fonctions trait de type C++0x (__is_signed)
• bool __is_standard_layout(typename T)
  • Fonctions trait de type C++0x (__is_standard_layout)
• bool __is_trivial( typename T )
  • Fonctions trait de type C++0x (__is_trivial)
• bool __is_union( typename T )
  • Fonctions trait de type C++0x (__is_union)
• bool __is_unsigned( typename T )
  • Fonctions trait de type C++0x (__is_unsigned ( typename T ))
• bool __is_void( typename T )
  • Fonctions trait de type C++0x (__is_void)
• bool __is_volatile( typename T )
  • Fonctions trait de type C++0x (__is_volatile)
• break
  • mots clés, C++ (break)
• bureau de débogage
  • définir le bureau de débogage (Sélectionner le bureau de débogage)

C

• cadre
  • propriétés publiées (Définition des propriétés à la conception)
• caractère inerte (whitespace)
  • éléments lexicaux, C++ (Caractère inerte)
• case
  • mots clés, C++ (case (C++))
• catch
  • mots clés, C++ (catch)
• Catégories de l'API
  • Allocation dynamique (Routines d'allocation mémoire dynamique)
  • Constantes d'attributs de fichiers (Liste des attributs de fichiers)
  • Constantes de mode de fichier (Constantes de mode de fichier)
  • Constantes des opérateurs (Constantes des opérateurs)
  • Constantes des types de variants (Codes touche virtuelle)
  • Constantes des types de variants (Constantes des types de variants)
  • Contrôle de la FPU (Routines de contrôle des nombres à virgule flottante)
  • Flux, concepteurs et lecteurs (Flux, lecteurs et concepteurs)
  • Gestion des threads (Routines de gestion des threads)
  • Informations de niveau application (Informations de niveau application)
  • Manipulation des caractères (Routines de manipulation des caractères)
  • Manipulation des chemins (Routines de manipulation des chemins)
  • Routines de conversion des types (Routines de conversion des types)
  • Routines de gestion (Routines financières et de gestion)
  • Routines intrinsèques (Routines intrinsèques de Object Pascal)
  • Routines mathématiques (Routines de comparaison)
  • Routines mathématiques (Routines mathématiques)
  • Routines mathématiques (Services Web)
  • Support BCD (Routines de support BCD)
  • Support date/heure (Support date et heure)
  • Support de la ligne de commande (Routines de support de la ligne de commande)
  • Support de l'interface et du GUID (Routines de support de l'interface et du GUID)
  • Support des actions (Routines de support des actions)
  • Support des disques et des répertoires (Routines de support des disques et des répertoires)
  • Support des entrées/sorties des fichiers (Support des entrées et des sorties des fichiers)
  • Support des nombres aléatoires (Routines du support des nombres aléatoires)
  • Support des nombres complexes (Routines de support des nombres complexes)
  • Support des variants (Routines de support des variants)
  • Support UCS4 (Routines de conversion UTF-8)
  • Support UTF-8 (Routines de conversion UTF-8)
  • Support XML (Routines du support XML)
• cdecl
  • mots clés, C++ (cdecl, _cdecl, __cdecl (C++))
• chaînes
  • accès à une liste de chaînes (Accès à une chaîne spécifique)
  • déclaration et initialisation (Déclaration et initialisation de chaînes)
  • manipulation (Utilisation des chaînes)
• champs
  • classes et objets (Champs (Object Pascal))
• champs de bits
  • structure du langage C++ (Champs de bits)
• char
  • mots clés, C++ (char)
• char16_t
  • mots clés, C++ (char16_t)
• char32_t
  • mots clés, C++ (char32_t)
• class
  • mots clés, C++ (class (C++))
• classes
  • définition (Définition de nouvelles classes (Object Pascal))
• classes,
  • spécificités du langage C++ (Classes C++)
• classes abstraites
  • spécificités du langage C++ (Classes abstraites)
• classes de base
  • spécificités du langage C++ (Accès aux classes de base et dérivées)
• classes de base virtuelles
  • spécificités du langage C++ (Classes de base virtuelles)
• classes de stockage
  • structure du langage C++ (Types et classes de stockage)
• classes et objets
  • classes et objets (Classes et objets (Object Pascal))
• classes, forward
  • spécificités du langage C++ (Déclarations de classes Object Pascal (__declspec))
• classes, liste de membres
  • spécificités du langage C++ (Liste des membres de classe)
• classes, objets
  • spécificités du langage C++ (Objets de classes)
• classes polymorphes
  • spécificités du langage C++ (Classes polymorphes - Index)
• classes, portée
  • spécificités du langage C++ (Portée de classe)
• classes, types
  • spécificités du langage C++ (Types de classes)
• __classid
  • mots clés, C++ (__classid)
• __classid
  • mots clés, C++ (__classid)
• __classmethod
  • mots clés, C++ (__classmethod)
• __classmethod
  • mots clés, C++ (__classmethod)
• __closure
  • mots clés, C++ (__closure)
• __closure
  • mots clés, C++ (__closure)
• code
  • modification (Modification du code)
• CodeGuard
  • avertissements (Avertissements de comparaison de chaînes)
  • avertissements (Avertissements pour la comparaison de blocs mémoire)
  • avertissements (Avertissements sur la fusion et la scission de noms de chemins)
  • erreurs (Erreurs d'accès)
  • erreurs (Erreurs d'échec de fonction)
  • erreurs (Erreurs de ressources)
  • erreurs (Erreurs d'exceptions)
  • présentation (Présentation de CodeGuard)
  • utilisation (Utilisation de CodeGuard)
• commentaires
  • éléments lexicaux, C++ (Commentaires)
• compatibilité de type
  • types de données (Compatibilité et identité de types (Object Pascal))
• compl
  • représentations alternatives des tokens C++ (compl, ~)
• _Complex
  • mots clés, C++ (_Complex)
• _Complex
  • mots clés, C++ (_Complex)
• concept
  • mots clés, C++ (concept)
• concept_map
  • mots clés, C++ (concept_map)
• const
  • mots clés, C++ (const)
• constantes
  • éléments lexicaux, C++ (Constantes)
  • types de données (Constantes déclarées)
• constantes, caractère
  • éléments lexicaux, C++ (Constantes caractère)
• constantes, caractère large
  • éléments lexicaux, C++ (Constantes à caractères étendus et à caractères multiples)
• constantes, chaîne
  • éléments lexicaux, C++ (Constantes chaîne)
• constantes, entières
  • éléments lexicaux, C++ (Constantes entières)
• constantes, énumération
  • éléments lexicaux, C++ (Constantes énumération)
• constantes, représentation interne
  • éléments lexicaux, C++ (Constantes et représentation interne)
  • éléments lexicaux, C++ (Représentation interne des types numériques)
• constantes, virgule flottante
  • éléments lexicaux, C++ (Constantes à virgule flottante)
• const_cast, opérateur de transtypage
  • transtypage, C++ (const_cast (opérateur de transtypage))
• constexpr
  • mots clés, C++ (constexpr)
• constructeurs
  • spécificités du langage C++ (Constructeurs)
  • spécificités du langage C++ (Introduction aux constructeurs et destructeurs)
• constructeurs, copie
  • spécificités du langage C++ (Constructeur de copie)
• constructeurs, implicites
  • spécificités du langage C++ (Constructeur implicite)
• constructeurs, ordre d'appel
  • spécificités du langage C++ (Ordre d'appel des constructeurs)
• constructeurs, surcharge
  • spécificités du langage C++ (Surcharge des constructeurs)
• continue
  • mots clés, C++ (continue)
• contrôle de source
  • principes (Utilisation du contrôle de source)
• conversions
  • chaîne en PChar (Conversions de chaînes en PChar)
  • types chaîne (Mélange et conversion de types chaîne)

D

• débogage
  • ajouter un point de suivi (Ajout d'un point de suivi)
  • liaison avec un processus (Attachement à un processus en cours d'exécution)
  • modification des expressions (Modification d'expressions variables)
  • points d'arrêt (Définition et modification de points d'arrêt)
  • préparation (Préparation d'un projet pour le débogage)
• déclaration de types
  • types de données (Déclaration de types)
• déclarations
  • structure du langage C++ (Déclarations possibles)
• déclarations, espaces de nommage
  • espaces de nommage, C++ (Déclaration d'un espace de nommage)
• déclarations et instructions
  • directives du compilateur,, delphi (Déclarations et instructions (Object Pascal))
• déclarations, externes
  • structure du langage C++ (Définitions et déclarations externes)
• déclarations, incomplètes
  • structure du langage C++ (Déclarations incomplètes)
• __declslpec(delphireturn)
  • L'extension de mot clé __declspec (L'extension de mot clé __declspec)
• __declspec,
  • mots clés, C++ (__declspec)
• __declspec,
  • mots clés, C++ (__declspec)
• __declspec, dllexport
  • mots clés, C++ (__declspec(dllexport))
• __declspec, dllexport
  • mots clés, C++ (__declspec(dllexport))
• __declspec, dllimport
  • mots clés, C++ (__declspec(dllimport))
• __declspec, dllimport
  • mots clés, C++ (__declspec(dllimport))
• __declspec, naked
  • mots clés, C++ (__declspec(naked))
• __declspec, naked
  • mots clés, C++ (__declspec(naked))
• __declspec, noreturndeclspec, noreturn
  • mots clés, C++ (__declspec(noreturn))
• __declspec, noreturndeclspec, noreturn
  • mots clés, C++ (__declspec(noreturn))
• __declspec, nothrow
  • mots clés, C++ (__declspec(nothrow))
• __declspec, nothrow
  • mots clés, C++ (__declspec(nothrow))
• __declspec, novtable
  • mots clés, C++ (__declspec(novtable))
• __declspec, novtable
  • mots clés, C++ (__declspec(novtable))
• __declspec, property
  • mots clés, C++ (__declspec(property))
• __declspec, property
  • mots clés, C++ (__declspec(property))
• __declspec, selectany
  • mots clés, C++ (__declspec(selectany))
• __declspec, selectany
  • mots clés, C++ (__declspec(selectany))
• __declspec, thread
  • mots clés, C++ (__declspec(thread))
• __declspec, thread
  • mots clés, C++ (__declspec(thread))
• __declspec, uuid
  • mots clés, C++ (__declspec(uuid("ComObjectGUID")))
• __declspec, uuid
  • mots clés, C++ (__declspec(uuid("ComObjectGUID")))
• decltype
  • mots clés, C++ (decltype)
• default
  • mots clés, C++ (default (C++))
• définition
  • espaces de nommage, C++ (Définition d'un espace de nommage)
• définitions
  • structure du langage C++ (Définitions facultatives)
• delete
  • spécificités du langage C++ (delete)
• des procédures et des fonctions
  • des procédures et des fonctions (Procédures et fonctions (Object Pascal))
• destructeurs
  • spécificités du langage C++ (Destructeurs)
• destructeurs, directives et
  • spécificités du langage C++ (Abort et les destructeurs)
  • spécificités du langage C++ (atexit, #pragma exit et les destructeurs)
  • spécificités du langage C++ (Exit et les destructeurs)
• destructeurs, invocation
  • spécificités du langage C++ (Appel des destructeurs)
• destructeurs virtuels
  • spécificités du langage C++ (Destructeurs virtuels)
• directives du compilateur
  • chaînes (Directives de compilation portant sur les chaînes)
• dispid
  • mots clés, C++ (__dispid)
• dispid
  • mots clés, C++ (__dispid)
• Dispositions du bureau
  • enregistrement des dispositions du bureau (Enregistrement des dispositions du bureau)
• division
  • opérateurs, C++ (Opérateurs de multiplication)
• do
  • mots clés, C++ (do)
• double
  • mots clés, C++ (double (C++))
  • mots clés, C++ (long)
• durée
  • structure du langage C++ (Durée)
• dynamic_cast, opérateur de transtypage
  • transtypage, C++ (dynamic_cast (opérateur de transtypage C++))

E

• Editeur de balise HTML
  • modification des balises HTML (Utilisation de l'éditeur de balise HTML)
• Editeur de code
  • personnalisation (Personnalisation de l'éditeur de code)
• éléments lexicaux
  • éléments lexicaux, C++ (Eléments lexicaux - Index)
• enregistrements
  • avancés (Types structurés (Object Pascal))
  • traditionnels (Types structurés (Object Pascal))
• enum
  • mots clés, C++ (enum)
• enum, affectation
  • structure du langage C++ (Affectation aux types enum)
• énumérations
  • structure du langage C++ (Enumérations)
• Eof
  • Eof (C++) (eof)
• erreurs internes
  • résolution (C++) (Résolution des erreurs internes (C++))
  • résolution (Object Pascal) (Résolution des erreurs internes (Object Pascal))
• espaces de nommage
  • programmes et unités (Utilisation des espaces de nommage avec Object Pascal)
• espaces de nommage anonymes
  • espaces de nommage, C++ (Espaces de nommage anonymes)
• espaces de nommage, présentation
  • spécificités du langage C++ (namespace)
• __except
  • mots clés, C++ (__except)
• __except
  • mots clés, C++ (__except)
• exceptions
  • classes et objets (Exceptions)
• explicit
  • mots clés, C++ (explicit)
• _export
  • mots clés, C++ (_export, __export (C++))
• _export
  • mots clés, C++ (_export, __export (C++))
• export,
  • mots clés, C++ (export (C++))
• expressions
  • expressions (Expressions (Object Pascal))
  • structure du langage C++ (Expressions (C++))
  • structure du langage C++ (Expressions et C++)
• expressions assembleur
  • assembleur en ligne (Expressions assembleur)
• expressions constantes
  • éléments lexicaux, C++ (Expressions constantes)
• expressions, erreurs
  • structure du langage C++ (Erreurs et débordements)
• expressions, ordre d'évaluation
  • structure du langage C++ (Ordre d'évaluation)
• extension
  • espaces de nommage, C++ (Extension d'un espace de nommage)
• extern
  • mots clés, C++ (extern)

F

• _fastcall
  • mots clés, C++ (_fastcall, __fastcall)
  • mots clés, C++ (final (C++))
  • mots clés, C++ (noreturn)
• _fastcall
  • mots clés, C++ (_fastcall, __fastcall)
  • mots clés, C++ (final (C++))
  • mots clés, C++ (noreturn)
• Fiches VCL
  • composants (Utilisation de l'expert Nouveau composant)
• fichiers{}
  • renommer (Modification d'un nom de fichier)
• fichiers (Utilisation des fichiers)
  • copie (Copie d'un fichier)
  • lecture et écriture (Approches des E/S fichier)
  • manipulation (Manipulation de fichiers)
  • recherche (Recherche d'un fichier)
  • routines date-heure (Routines date-heure de fichier)
  • suppression (Suppression d'un fichier)
  • TFileStream (Utilisation de flux de fichiers)
• __finally,
  • mots clés, C++ (__finally)
• __finally,
  • mots clés, C++ (__finally)
• float
  • mots clés, C++ (float)
• flux (Utilisation des flux)
  • copie des données (Copier des données entre des flux)
  • lecture et écriture de données (Utilisation des flux pour lire ou écrire des données)
  • position (Spécification de la position et de la taille du flux)
• fonctionnalités C++0x
  • Attributs C++0x (:Category:Attributs C++0x)
  • Deprecated (deprecated)
  • énumérations fortement typées (Enumérations fortement typées (C++0x))
  • Final (C++) (final (C++))
  • fonctions trait de type (Présentation des fonctions trait de type (C++0x))
  • Noreturn (noreturn)
  • opérateur alignof (Assertions statiques (C++0x))
  • opérateur alignof (Déclaration forward des énumérations (C++0x))
  • opérateur alignof (Littéraux et types de caractères Unicode (C++0x))
  • opérateur alignof (Méthodes anonymes dans Object Pascal)
  • opérateur alignof (Opérateur alignof (C++0x))
  • opérateur alignof (Références rvalue (C++0x))
  • opérateur alignof (Spécificateur de type decltype (C++0x))
  • opérateur alignof (Templates extern (C++0x))
  • Opérateurs de conversion explicite (C++0x) (Opérateurs de conversion explicite (C++0x))
• fonctions
  • conversion (Utilisation d'une classe pour gérer les conversions)
  • conversion (Utilisation d'une fonction de conversion)
  • structure du langage C++ (Définitions)
• fonctions, déclarations
  • structure du langage C++ (Déclarations et définitions)
  • structure du langage C++ (Déclarations et prototypes)
• fonctions dynamiques
  • spécificités du langage C++ (Fonctions dynamiques)
• fonctions inline
  • spécificités du langage C++ (Fonctions inline)
• fonctions membres
  • spécificités du langage C++ (Fonctions membres)
• fonctions, paramètres
  • structure du langage C++ (Déclarations de paramètres formels)
• fonctions virtuelles
  • spécificités du langage C++ (Fonctions virtuelles (C++))
• for
  • mots clés, C++ (for)
• friend
  • mots clés, C++ (friend)

G

• Génériques (Génériques - Index)
  • changements apportés à la grammaire et aux fonctions (Changements apportés à la grammaire et aux fonctions standard)
  • contraintes (Contraintes dans les génériques)
  • gestion C++ (Comment gérer les génériques Object Pascal dans C++)
  • terminologie (Terminologie des génériques)
  • types procéduraux (Déclaration des génériques)
  • vue globale (Présentation des génériques)
• GenTLB.exe
  • compilateur de bibliothèque de types (Fenêtre de l'éditeur de bibliothèques de types)
• gestion de la mémoire
  • Object Pascal pour Win32 (Gestion de la mémoire)
• goto
  • mots clés, C++ (goto)

H

• hello world
  • Fiches VCL (Copie de données d'un flux vers un autre)

I

• ide
  • visuels, composants (Concepteur de fiches)
• identificateurs
  • éléments lexicaux, C++ (Identificateurs)
• identification de type à l'exécution
  • spécificités du langage C++ (Identification de type à l'exécution et destructeurs)
• if
  • mots clés, C++ (if, else (C++))
• _Imaginary
  • mots clés, C++ (_Imaginary)
• _Imaginary
  • mots clés, C++ (_Imaginary)
• implémentation des interfaces
  • interfaces (Implémentation des interfaces)
• __import
  • mots clés, C++ (_import, __import)
• __import
  • mots clés, C++ (_import, __import)
• initialisation
  • structure du langage C++ (Initialisation)
• initialisation de classe
  • spécificités du langage C++ (Initialisation de classe)
• inline
  • mots clés, C++ (inline)
• instructions
  • structure du langage C++ (Instructions)
• instructions, branchement
  • structure du langage C++ (Instructions de branchement)
• instructions, étiquette
  • structure du langage C++ (Instructions étiquette)
• instructions, expression
  • structure du langage C++ (Instructions d'itération)
  • structure du langage C++ (Instructions expression)
• instructions, sélection
  • structure du langage C++ (Instructions de sélection)
• int
  • mots clés, C++ (int)
• __int8, __int16, and so forth
  • éléments lexicaux, C++ (Types entiers étendus : __int8, __int16, __int32, __int64)
• __int8, __int16, et ainsi de suite
  • éléments lexicaux, C++ (Types entiers étendus : __int8, __int16, __int32, __int64)
• interfaces d'objets
  • interfaces (Interfaces d'objets (Object Pascal))

J

• jeu de caractères (Object Pascal)
  • mots réservés (Eléments syntaxiques fondamentaux (Object Pascal))

L

• langage C++
  • spécificités du langage C++ (Spécificités du C++)
• late_check
  • mots clés, C++ (late_check)
• liaison
  • structure du langage C++ (Lien)
• listes A faire
  • planification (Utilisation des listes A faire)
• listes de chaînes
  • ajout d'une chaîne (Ajout d'une chaîne à une liste)
  • chargement et enregistrement (Lecture et enregistrement des listes de chaînes)
  • comptage (Comptage des chaînes d'une liste)
  • copie (Copie de la totalité d'une liste de chaînes)
  • création (Création d'une nouvelle liste de chaînes)
  • manipulation (Manipulation des chaînes d'une liste)
  • objets associés (Association d'objets à une liste de chaînes)
  • recherche de chaînes (Recherche d'éléments dans une liste de chaînes)
  • suppression (Suppression d'une chaîne d'une liste)
• listes (Utilisation des listes)
  • chaîne (Utilisation des listes de chaînes)
  • opérations (Opérations de listes courantes)
  • persistante(s) (Listes persistantes)

M

• macro
  • enregistrement (Enregistrement d'une macro de touches)
• macros
  • prédéfinies (C++) (Macros prédéfinies)
• Mappage TCHAR Unicode
  • spécificités du langage C++ (Fonctions flottantes)
• masquage des noms
  • spécificités du langage C++ (Masquage)
• _mbsnbcat
  • strncat
• _mbsncat
  • strncat
• membres, portée
  • spécificités du langage C++ (Portée des membres)
• membres statiques
  • spécificités du langage C++ (Membres statiques)
• mesures
  • ajout d'unités (Ajout de nouveaux types de mesure)
  • ajout d'unités (Création d'une famille de conversion simple et ajout d'unités)
• méthodes anonymes
  • gestion C++ (Comment gérer les méthodes anonymes Object Pascal dans C++)
• méthodes de classe
  • spécificités du langage C++ (Méthodes de classe)
• modificateurs
  • mots clés, C++ (unsigned)
• modificateurs, fonction
  • structure du langage C++ (Modificateurs de fonctions)
• modification du code
  • achèvement de classe (Utilisation de l'achèvement de classe)
• mots-clés
  • structure du langage C++ (Spécificateurs de type)
• mots clés (Mots clés et mots protégés dans les macros)
  • éléments lexicaux, C++ (Extensions des mots clés)
  • éléments lexicaux, C++ (Mots clés)
• __msfastcall
  • mots clés, C++ (__msfastcall)
• __msfastcall
  • mots clés, C++ (__msfastcall)
• __msreturn
  • mots clés, C++ (__msreturn)
• __msreturn
  • mots clés, C++ (__msreturn)
• mutable
  • mots clés, C++ (mutable)

N

• new
  • représentations alternatives des tokens C++ (and_eq, &=)
  • spécificités du langage C++ (new)
• noms de classes
  • spécificités du langage C++ (Noms de classes)
  • spécificités du langage C++ (Portée du nom de classe)
• not
  • représentations alternatives des tokens C++ (not, ! (C++))
• not_eq
  • représentations alternatives des tokens C++ (not_eq, !=)
• nullptr
  • mots clés, C++ (nullptr)

O

• objets
  • Object Pascal (Examen d'un objet Object Pascal)
  • structure du langage C++ (Objets)
• objets automation
  • interfaces (Objets automation (Win32 seulement))
• * opérateur
  • Opérateurs de référencement/déréférencement, C++ (Opérateurs de référencement/déréférencement)
• opérateur
  • opérateurs, C++ (Opérateurs binaires - Index)
  • opérateurs, C++ (Opérateurs d'expressions postfixées - Index)
  • opérateurs, C++ (Opérateurs unaires - Index)
  • opérateurs, C++ (Présentation de la surcharge des fonctions opérateurs - Index)
• opérateur ?:
  • opérateurs, C++ (Opérateurs conditionnels)
• opérateur ?:
  • opérateurs, C++ (Opérateurs conditionnels)
• opérateur .
  • opérateurs, C++ (Sélecteur de membre direct (.))
• opérateur .
  • opérateurs, C++ (Sélecteur de membre direct (.))
• opérateur [ ]
  • opérateurs, C++ (Opérateur d'accès à un tableau)
• opérateur *
  • opérateurs, C++ (Opérateurs de référencement/déréférencement)
• opérateur +
  • opérateurs, C++ (Opérateurs plus et moins)
• opérateur +
  • opérateurs, C++ (Opérateurs plus et moins)
• opérateur ++
  • opérateurs, C++ (Opérateurs d'incrémentation/décrémentation)
• opérateur ++
  • opérateurs, C++ (Opérateurs d'incrémentation/décrémentation)
• opérateur new
  • spécificités du langage C++ (Opérateur new avec les tableaux)
  • spécificités du langage C++ (Opérateur new (C++))
  • spécificités du langage C++ (Syntaxe des arguments de l'opérateur new)
• opérateurs, appels de fonctions
  • opérateurs, C++ (Opérateur d'appel de fonction)
• opérateurs arithmétiques
  • opérateurs, C++ (Opérateurs arithmétiques)
• opérateurs, binaires
  • opérateurs, C++ (Résumé des opérateurs binaires (C++))
• opérateurs bit à bit,
  • opérateurs, C++ (Opérateurs bit à bit)
• opérateurs, C++ présentation
  • opérateurs, C++ (Présentation des opérateurs)
• opérateurs, égalité
  • structure du langage C++ (Opérateurs d'égalité)
• opérateurs, expressions
  • opérateurs, C++ (Opérateurs d'expressions primaires)
• opérateurs logiques
  • opérateurs, C++ (Opérateurs logiques)
• opérateurs relationnels
  • opérateurs, C++ (Opérateurs relationnels (C++))
• opérateurs, surcharge
  • surcharge des opérateurs, C++ (Exemple de surcharge des opérateurs)
  • surcharge des opérateurs, C++ (Opérateurs surchargés et héritage)
  • surcharge des opérateurs, C++ (Surcharge de l'opérateur d'accès [ ])
  • surcharge des opérateurs, C++ (Surcharge de l'opérateur d'accès aux membres de classe ->)
  • surcharge des opérateurs, C++ (Surcharge de l'opérateur d'affectation = (C++))
  • surcharge des opérateurs, C++ (Surcharge de l'opérateur d'appel de fonction ( ))
  • surcharge des opérateurs, C++ (Surcharge des fonctions opérateurs)
  • surcharge des opérateurs, C++ (Surcharge des opérateurs binaires)
  • surcharge des opérateurs, C++ (Surcharge des opérateurs (C++))
  • surcharge des opérateurs, C++ (Surcharge des opérateurs unaires)
• opérateurs, unaires
  • opérateurs, C++ (Opérateurs unaires)
• operator
  • mots clés, C++ (operator)
• [ ] operator
  • opérateurs, C++ (Opérateur d'accès à un tableau)
• or
  • représentations alternatives des tokens C++ (or, ||)
• or_eq
  • représentations alternatives des tokens C++ (or_eq, |=)
• organisation des programmes
  • programmes et unités (Programmes et unités (Object Pascal))

P

• packages
  • compilation (Packages (Object Pascal))
  • déploiement (Déploiement des packages)
  • fichiers (Fichiers de packages créés lors d'une compilation)
  • unités (Construction de packages)
• Palette d'outils
  • composants (Ajout de composants à une fiche)
• paramètres
  • des procédures et des fonctions (Paramètres (Object Pascal))
• pascal
  • mots clés, C++ (pascal, _pascal, __pascal (C++))
• pliage de code
  • réduction du code (Utilisation du pliage de code)
• pointeurs
  • structure du langage C++ (Déclarations de pointeurs)
  • structure du langage C++ (Pointeurs)
  • structure du langage C++ (Pointeurs de fonctions)
  • structure du langage C++ (Pointeurs d'objets)
• pointeurs, constantes
  • structure du langage C++ (Constantes pointeur)
• pointeurs, conversions
  • structure du langage C++ (Conversions de pointeurs)
• pointeurs, objets
  • structure du langage C++ (Opérations arithmétiques et pointeurs)
• portée
  • spécificités du langage C++ (Portée en C++)
  • structure du langage C++ (Portée)
• portée, opérateur de résolution
  • surcharge des opérateurs, C++ (Opérateur de résolution de portée)
• portée, règles
  • spécificités du langage C++ (Résumé des règles de portée en C++)
• priorité
  • opérateurs, C++ (Priorité des opérateurs)
• prise en main
  • ajout de fichiers à un projet (Ajout et suppression de fichiers)
  • ajout de modèles au référentiel (Ajout de modèles au référentiel d'objets)
  • ancrage des fenêtres d'outils (Ancrage de fenêtres d'outils)
  • configuration des options d'un projet (Définition des options de projet)
  • copie de références (Copie de références vers un chemin local)
  • définition des préférences pour les outils (Définition des préférences pour les outils)
  • définition des propriétés et des événements (Définition des propriétés et des événements)
  • écriture de gestionnaires d'événements (Ecriture de gestionnaires d'événement)
  • filtrage des composants recherchés (Recherche d'éléments sur la palette d'outils)
  • personnalisation de la palette d'outils (Personnalisation de la palette d'outils)
  • personnalisation des fiches (Personnalisation de la fiche)
  • renommer des fichiers (Renommage des fichiers à l'aide du gestionnaire de projet)
• private
  • mots clés, C++ (private (C++))
• procédures et fonctions assembleur
  • assembleur en ligne (Procédures et fonctions assembleur)
• Projet
  • Nettoyer (Gestionnaire de projets)
• projets
  • création de projets (Création d'un projet)
  • types de (Démarrage d'un projet - Vue globale)
• property
  • mots clés, C++ (__property)
• propriétés
  • classes et objets (Propriétés (Object Pascal))
  • initialisation (Définition des propriétés à l'exécution)
  • initialisation (Définition des propriétés d'un composant)
• propriétés statiques
  • spécificités du langage C++ (Propriétés statiques)
• protected
  • mots clés, C++ (protected (C++))
• pseudo variables
  • éléments lexicaux, C++ (Tableau des pseudo variables de registre C++ de Embarcadero)
• public
  • mots clés, C++ (public (C++))
• published
  • mots clés, C++ (__published (C++))

R

• Référencement (C++)
  • Références lvalue (C++)
  • Références rvalue (C++0x)
• références de classe
  • classes et objets (Références de classes)
• références d'interfaces
  • interfaces (Références d'interfaces (Object Pascal))
• register
  • mots clés, C++ (register (C++))
• Registre
  • registre système (Utilisation des fichiers ini et du registre système)
• reinterpret_cast (opérateur de transtypage)
  • transtypage, C++ (reinterpret_cast (opérateur de transtypage))
• requires
  • mots clés, C++ (requires (C++))
• restrict
  • mots clés, C++ (restrict)
• return
  • mots clés, C++ (return)
• routines de gestion des chaînes à zéro terminal
  • chaînes (Routines couramment utilisées pour les chaînes à zéro terminal)
• routines de manipulation des chaînes longues
  • chaînes (Routines couramment utilisées pour les AnsiStrings)
• routines globales
  • objets utilitaires (Utilisation de la RTL (bibliothèque d'exécution))
• Routines standard
  • unité System (Routines standard et entrées-sorties)
• __rtti
  • spécificités du langage C++ (__rtti et option -RT)
• RTTI
  • spécificités du langage C++ (Identification de type à l'exécution (RTTI))
• __rtti
  • spécificités du langage C++ (__rtti et option -RT)

S

• séparateurs
  • éléments lexicaux, C++ (Séparateurs)
• séquences d'échappement
  • éléments lexicaux, C++ (Séquences d'échappement)
• set_new_handler
  • spécificités du langage C++ (Gestion des erreurs pour l'opérateur new)
• Sévérité du compilateur C++
  • initialisation et conversion (Compilateur C++ plus strict - Initialisation et conversion)
  • liaison des références et des qualificateurs (Compilateur C++ plus strict - Liaison des références et des qualificateurs)
  • littéraux chaîne (Compilateur C++ plus strict - Les littéraux chaîne sont maintenant des constantes)
  • modifications des templates (Compilateur C++ plus strict - Modifications des templates)
  • résolution des fonctions surchargées (Compilateur C++ plus strict - Résolution des surcharges de fonction)
• short
  • mots clés, C++ (short)
• signed
  • mots clés, C++ (signed)
• sizeof, opérateur
  • mots clés, C++ (sizeof)
• spécificateurs d'accès
  • spécificités du langage C++ (Contrôle d'accès aux membres)
• static
  • mots clés, C++ (static (C++))
• static_assert
  • mots clés, C++ (static_assert)
• static_cast (opérateur de transtypage)
  • transtypage, C++ (static_cast (opérateur de transtypage C++))
• _stdcall
  • mots clés, C++ (_stdcall, __stdcall (C++))
• _stdcall
  • mots clés, C++ (_stdcall, __stdcall (C++))
• struct
  • mots clés, C++ (struct)
• structures
  • structure du langage C++ (Structures)
  • structure du langage C++ (Structures et fonctions)
• structures, accès aux membres
  • structure du langage C++ (Accès aux membres d'une structure)
• structures, déclarations de membres
  • structure du langage C++ (Déclarations des membres d'une structure)
• structures, espaces de nommage
  • structure du langage C++ (Espaces de nommage des structures)
• structures, sans sélecteur
  • structure du langage C++ (Structures sans sélecteur et typedef)
• surcharge des opérateurs
  • spécificités du langage C++ (Surcharge de l'opérateur delete)
  • spécificités du langage C++ (Surcharge de l'opérateur new)
• surcharge d'opérateurs
  • classes et objets (Surcharge d'opérateurs (Object Pascal))
• switch
  • mots clés, C++ (switch)
• syntaxe assembleur
  • assembleur en ligne (Syntaxe assembleur)

T

• tableaux
  • spécificités du langage C++ (Opérateur delete avec les tableaux)
  • structure du langage C++ (Tableaux (C++))
• templates
  • création (Création de templates dynamiques)
  • création (Utilisation des templates dynamiques)
  • spécificités du langage C++ (template)
  • templates, C++ (Fonctions template implicites et explicites)
  • templates, C++ (Suppression des pointeurs dans les templates)
  • templates, C++ (Utilisation des crochets angulaires dans les templates)
  • templates, C++ (Utilisation des listes génériques à type fiable dans les templates)
  • templates, C++ (Utilisation des templates (C++))
• templates, arguments
  • templates, C++ (Arguments des templates)
• templates, classe
  • templates, C++ (Templates de classes)
• templates, dans la version 3.0
  • templates, C++ (Sémantique de génération des templates)
• templates, DLL
  • spécificités du langage C++ (Exportation et importation de templates)
• templates, fonction
  • templates, C++ (Templates de fonctions)
• templates, options du compilateur
  • templates, C++ (Commutateurs du compilateur relatifs aux templates)
• templates, surcharge
  • templates, C++ (Surcharge d'une fonction template)
• templates, vérification de la syntaxe
  • templates, C++ (Analyse du corps de template)
• this
  • mots clés, C++ (this)
• thread_local
  • mots clés, C++ (thread_local)
• threads
  • figement dans le débogueur (Figer et libérer des threads dans le débogueur)
  • libération dans le débogueur (Figer et libérer des threads dans le débogueur)
• throw
  • mots clés, C++ (throw)
• TIniFile
  • utilisation (Utilisation de TIniFile et TMemIniFile)
• tokens (Fusion de tokens avec ##)
  • éléments lexicaux, C++ (Présentation des tokens - Index)
• transtypage, style C++
  • spécificités du langage C++ (Nouveau style de transtypage)
• TRegistry
  • utilisation (Utilisation de TRegistry)
• TRegistryIniFile
  • utilisation (Utilisation de TRegistryIniFile)
• try
  • mots clés, C++ (try (C++))
• __try
  • mots clés, C++ (__try)
• TVarData (type)
  • variants personnalisés (Stockage des données d'un type Variant personnalisé)
• typedef
  • mots clés, C++ (typedef)
• typeid
  • mots clés, C++ (typeid)
• typename
  • mots clés, C++ (typename)
• types caractère
  • éléments lexicaux, C++ (Les trois types char)
• types chaîne
  • conversions (Dépendances de chaînes)
  • types de données (Types chaîne (Object Pascal))
• Types de données
  • scalaire et réel (Types simples)
• types, fondamentaux
  • structure du langage C++ (Types fondamentaux)
• types imbriqués
  • classes et objets (Déclarations de types imbriqués)
  • spécificités du langage C++ (Types imbriqués)
• types pointeurs
  • types de données (Pointeurs et types pointeur (Object Pascal))
• types procédure
  • types de données (Types procéduraux (Object Pascal))
• types structurés
  • types de données (Types structurés (Object Pascal))
• types variants
  • types de données (Types variants (Object Pascal))

U

• Unicode
  • Activation des applications C++ (Activation des applications C++ pour Unicode)
  • Mappage TCHAR pour C++ (Mappage _TCHAR)
• union
  • mots clés, C++ (union)
• unions
  • structure du langage C++ (Unions)
• unions, anonymes
  • structure du langage C++ (Unions anonymes)
• unions, déclarations
  • structure du langage C++ (Déclarations d'union)
• unités de traduction
  • structure du langage C++ (Unités de traduction)
• _unsigned __int_alignment_of( typename T )
  • Fonctions trait de type C++0x (__alignment_of)
• _unsigned __int_alignment_of( typename T )
  • fonctions trait de type C++0x (__alignment_of)
• unsigned int __array_extent( typename T, unsigned intI )
  • Fonctions trait de type C++0x (__array_extent)
• unsigned __int_array_rank( typename T )
  • Fonctions trait de type C++0x (__array_rank)
• utilitaires de conversion
  • mesures (Conversion de mesures)
  • mesures (Exécution des conversions)

V

• variables
  • types de données (Variables)
• variables, multithreads
  • structure du langage C++ (__thread)
• variants
  • personnalisés (Définition de variants personnalisés)
• variants personnalisés
  • activation (Utilisation du descendant de TCustomVariantType)
  • chargement et enregistrement (Chargement et enregistrement des valeurs des variants personnalisés)
  • copie (Copie et effacement des variants personnalisés)
  • définition (Création d'une classe pour le type variant personnalisé)
  • opérations binaires (Implémentation d'opérations binaires)
  • opérations de comparaison (Implémentation d'opérations de comparaison)
  • opérations unaires (Implémentation d'opérations unaires)
  • propriétés (Support des propriétés et des méthodes dans les variants personnalisés)
  • transtypages (Activation du transtypage)
  • utilitaires (Ecriture d'utilitaires fonctionnant avec un type variant personnalisé)
• virtual
  • mots clés, C++ (virtual)
• visibilité
  • structure du langage C++ (Visibilité)
• void
  • mots clés, C++ (void)
• volatile
  • mots clés, C++ (volatile)

W

• _wargv, _argv
  • _argv (_argv, _wargv)
• _wargv, _argv
  • _argv (_argv, _wargv)
• wchar_t
  • mots clés, C++ (wchar_t)
• _wcsmpi
  • strcmpi, _wcscmpi
• while
  • mots clés, C++ (while (C++))
• _wsetlocale
  • setlocale, _wsetlocale
• _wtoi, atoi
  • routine de conversion (atoi, _wtoi)
• _wtoi, atoi
  • routine de conversion (atoi, _wtoi)

X

• xor
  • représentations alternatives des tokens C++ (xor, ^(C++))
• xor_eq
  • représentations alternatives des tokens C++ (xor_eq, ^=)