diff options
| -rw-r--r-- | fr-fr/objective-c-fr.html.markdown | 138 |
1 files changed, 74 insertions, 64 deletions
diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index d0e6f3eb..b14b3a52 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -62,7 +62,7 @@ int main (int argc, const char * argv[]) // Il faut mettre un astérisque devant la déclaration d'objet fortement typé MaClasse *monObject1 = nil; // Typage fort id monObject2 = nil; // Typage faible - // 'description' est une méthode qui permet d'afficher un aperçut de l'objet + // 'description' est une méthode qui permet de retourner un aperçut de l'objet sous forme textuelle // La méthode 'description' est appelée par défaut quand on utilise le paramètre '%@' NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)" @@ -96,11 +96,11 @@ int main (int argc, const char * argv[]) long quaranteDeuxLong = [nombreQuaranteDeuxLong longValue]; // ou 42 NSLog(@"%li", fortyTwoLong); - // Les nombres flottans - NSNumber *nombrePiFlottan = @3.141592654F; - float piFlottan = [nombrePiFlottan floatValue]; // ou 3.141592654f - NSLog(@"%f", piFlottan); // affiche => 3.141592654 - NSLog(@"%5.2f", piFlottan); // affiche => " 3.14" + // Les nombres flottants + NSNumber *nombrePiFlottant = @3.141592654F; + float piFlottant = [nombrePiFlottant floatValue]; // ou 3.141592654f + NSLog(@"%f", piFlottant); // affiche => 3.141592654 + NSLog(@"%5.2f", piFlottant); // affiche => " 3.14" NSNumber *nombrePiDouble = @3.1415926535; double piDouble = [nombrePiDouble doubleValue]; // ou 3.1415926535 @@ -108,11 +108,11 @@ int main (int argc, const char * argv[]) NSLog(@"%4.2f", piDouble); // affiche => "3.14" // NSDecimalNumber est une classe pour avoir plus de précision sur les nombres - // flottans et les doubles + // flottants et les doubles NSDecimalNumber *decNumUn = [NSDecimalNumber decimalNumberWithString:@"10.99"]; NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"]; - // NSDecimalNumber n'est pas capable d'utiliser les opérations standards (+, -, *, /) - // Il faut utiliser les méthodes suivantes : + // NSDecimalNumber ne permet pas d'utiliser les opérations standards (+, -, *, /) + // Il faut utiliser les méthodes suivantes à la place : [decNumUn decimalNumberByAdding:decNumDeux]; [decNumUn decimalNumberBySubtracting:decNumDeux]; [decNumUn decimalNumberByMultiplyingBy:decNumDeux]; @@ -133,7 +133,8 @@ int main (int argc, const char * argv[]) NSNumber *troisiemeNombre = uneListe[2]; NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3" // NSMutableArray est une version mutable de NSArray - // Cela permet de modifier la liste en ajoutant/supprimant/modifiant des objets + // Cela permet de modifier la liste en ajoutant de nouveaux éléments et en supprimant ou + // changeant de place des objets déjà présent // C'est très pratique, mais pas aussi performant que l'utilisation de la classe NSArray NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2]; [listeMutable addObject:@"Bonjour tous le"]; @@ -142,7 +143,7 @@ int main (int argc, const char * argv[]) NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde" // Les dictionnaires - // Un dictionnaire est un ensemble de { clé: valeur } + // Un dictionnaire est un ensemble de clés : valeurs NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" }; NSObject *valeur = unDictionnaire[@"Une clé"]; NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)" @@ -153,7 +154,7 @@ int main (int argc, const char * argv[]) [dictionnaireMutable removeObjectForKey:@"cle1"]; // Les ensembles - // Un ensemble peut ne peut contenir que des objets uniques contrairement aux NSArray + // Un ensemble ne peut contenir de duplicatas contrairement aux NSArray NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil]; NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (Pas forcément dans le même ordre) // NSMutableSet est un ensemble mutable @@ -166,7 +167,7 @@ int main (int argc, const char * argv[]) // Les Operateurs /////////////////////////////////////// - // Les opérateurs sont les mêmes que ceux du langage C + // Les opérateurs sont pareil qu'en C // Par exemple : 2 + 5; // => 7 4.2f + 5.1f; // => 9.3f @@ -176,13 +177,13 @@ int main (int argc, const char * argv[]) 0 || 1; // => 1 (ou logique) ~0x0F; // => 0xF0 (négation bit à bit) 0x0F & 0xF0; // => 0x00 (et bit à bit) - 0x01 << 1; // => 0x02 (décale à gauche (par 1)) + 0x01 << 1; // => 0x02 (décalage à gauche (par 1)) /////////////////////////////////////// - // Les Structures de Controle + // Les Structures de Contrôle /////////////////////////////////////// - // Expression "Si-Sinon" (If-Else) + // Structure "Si-Sinon" (If-Else) if (NO) { NSLog(@"Je ne suis jamais affiché"); @@ -194,7 +195,7 @@ int main (int argc, const char * argv[]) NSLog(@"Je suis affiché"); } - // Expression "Selon" (Switch) + // Structure "Selon" (Switch) switch (2) { case 0: @@ -211,7 +212,7 @@ int main (int argc, const char * argv[]) } break; } - // Expression de boucle "Tant Que" (While) + // Structure de boucle "Tant Que" (While) int ii = 0; while (ii < 4) { @@ -221,7 +222,7 @@ int main (int argc, const char * argv[]) // "2," // "3," - // Expression de boucle "Pour" (For) + // Structure de boucle "Pour" (For) int jj; for (jj=0; jj < 4; jj++) { @@ -231,7 +232,7 @@ int main (int argc, const char * argv[]) // "2," // "3," - // Expression de boucle "Pour Chaque" (Foreach) + // Structure de boucle "Pour Chaque" (Foreach) NSArray *valeurs = @[@0, @1, @2, @3]; for (NSNumber *valeur in valeurs) { @@ -241,7 +242,7 @@ int main (int argc, const char * argv[]) // "2," // "3," - // Expression "Essayer-Attraper-Finalement" (Try-Catch-Finally) + // Structure "Essayer-Attraper-Finalement" (Try-Catch-Finally) @try { @throw [NSException exceptionWithName:@"FileNotFoundException" @@ -264,8 +265,11 @@ int main (int argc, const char * argv[]) // étapes précédentes ne sont pas terminées MaClass *monObjet = [[MaClass alloc] init]; - // L'Objective-C est basé sur le principe d'envoie de message et non sur celui - // d'appel de méthode comme la plupart des autres langages de programmation + // L'Objet en Objective-C est basé sur le principe d'envoie de message et non sur + // celui d'appel de méthode comme la plupart des autres langages + // C'est un détail important car cela veut dire que l'on peut envoyer un message + // à un objet qui ne possède pas la méthode demandée sans aucune incidence sur le + // fonctionnement du programme (aucune exception ne sera levée) [myObject instanceMethodWithParameter:@"Steve Jobs"]; // Nettoie la mémoire qui a été utilisée dans le programme @@ -286,10 +290,10 @@ int main (int argc, const char * argv[]) // La déclaration d'une classe en Objective-C commence par la déclaration de son interface : // @interface NomDeLaClasse : NomDeLaClasseParent <ListeDesProtocoles> // { -// type nom; // declaration d'une variable; +// type nom; // Déclaration d'une variable; // } -// @property type nom; // declaration d'une propriété -// -/+ (type)nomDeLaMethode; // Declaration d'une methode +// @property type nom; // Déclaration d'une propriété +// -/+ (type)nomDeLaMethode; // Déclaration d'une methode // @end // Termine la déclaration // NSObject est la classe de base (super classe) en Objective-C @interface MaClasse : NSObject <MonProtocole> @@ -298,7 +302,7 @@ int main (int argc, const char * argv[]) @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation) NSString *nom; } -// Les propriétés permettent de générrer les accésseurs/affecteurs publiques à la compilation +// Les propriétés permettent de générer les accésseurs/affecteurs publiques à la compilation // Par défaut, le nom de l'affecteur est la chaine 'set' suivi par le nom de la @property @property int propInt; // Nom de l'affecteur = 'setPropInt' @property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation @@ -345,7 +349,7 @@ MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38]; MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"]; -// les sélecteurs sont un moyen de décrire les méthodes dynamiquement +// Les sélecteurs sont un moyen de décrire les méthodes dynamiquement // Ils sont utilisés pour appeler des méthodes de classe et avoir des pointeurs de fonctions // facilement manipulable // SEL est un type de donnée et @selector retourne un selecteur à partir d'un nom de methode @@ -363,20 +367,20 @@ else { // Le fichier d'implémentation de la classe MaClasse (MaClasse.m) doit commencer comme ceci : @implementation MaClasse { - long distance; // Variable d'instance privé (équivalent à @private dans l'interface) + long distance; // Variable d'instance privée (équivalent à @private dans l'interface) NSNumber hauteur; } // Pour accéder à une variable depuis l'implémentation on peut utiliser le _ (tiret bas) devant le nom // de la variable : _nombre = 5; -// Accès d'une variable défini dans le fichier d'implémentation : +// Accès d'une variable définie dans le fichier d'implémentation : distance = 18; -// Pour utiliser la variable défini par l'intermédiaire de @property, il faut utiliser @synthesize -// qui permet de créer les affecteurs et les accésseurs : +// Pour utiliser la variable définie par l'intermédiaire de @property, il faut utiliser @synthesize +// qui permet de créer les affecteurs et les accésseurs correspondants : @synthesize roString = _roString; // _roString est maintenant disponible dans l'implementation -// En contre-partie de l'appel de la fonction 'init' lors de la création d'un objet, la fonction +// A l'inverse dela méthode 'init' qui est appelée lors de la création d'un objet, la fonction // 'dealloc' est appelée quand l'objet est supprimé - (void)dealloc { @@ -384,18 +388,18 @@ distance = 18; [super dealloc]; // et à appeler la méthode 'dealloc' de la classe parent } -// Les constructeurs sont une manière de créer des instances de classes -// 'init' est le constructeur par défaut; il est appelé quand l'objet est créé +// Les constructeurs sont des fonctions qui permettent d'instancier un objet +// 'init' est le constructeur par défaut en Objective-C - (id)init { if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent { - self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'instance courante + self.count = 1; // 'self' permet d'appeler la méthode de l'instance courante } return self; } -// Vous pouvez aussi créer des constructeurs qui possèdent des arguments +// Vous pouvez aussi créer des constructeurs avec des arguments // Attention : chaque nom de constructeur doit absolument commencer par 'init' - (id)initAvecUneDistance:(int)distanceParDefault { @@ -447,8 +451,8 @@ distance = 18; @end // Fin de l'implémentation /* - * Un protocole déclare des méthodes que chaque objet respectant celui-ci doit implémenter - * afin de se conformer celui-ci + * Un protocole déclare des méthodes et propriétés que chaque implémentation doit avoir afin de se + * conformer à celui-ci * Un protocole n'est pas une classe, c'est juste une interface */ @protocol MonProtocole @@ -460,16 +464,17 @@ distance = 18; // Gestion de la mémoire /////////////////////////////////////// /* -A chaque fois qu'un objet est créé dans l'application, un bloque mémoire doit être alloué. -Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la bonne -réactivité du programme (éviter les fuites mémoires) -Il n'y a pas de ramasse-miettes en Objective-C contrairement à Java par example. L'Objective-C repose -sur le comptage de référence. A chaque objet est assigné un compteur qui permet de connaitre son état. +À chaque fois qu'un objet est créé dans l'application, un bloc mémoire doit être alloué. +Quand l'application en a fini avec cet objet, la mémoire doit être libérée afin d'éviter les fuites +mémoires +Il n'y a pas de ramasse-miettes en Objective-C contrairement à Java par exemple. La gestion de la +mémoire repose sur le comptage de référence qui, pour chaque objet, assigne un compteur qui permet +de connaitre le nombre de référence qui l'utilise. Le principe est le suivant : Lorsque l'objet est créé, le compteur est initialisé à 1. Quand une instance détient un objet, le -compteur est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un. Enfin -quand le compteur arrive à zéro, l'objet est supprimé de la mémoire +compteur est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un. Au moment +où le compteur arrive à zéro, l'objet est supprimé de la mémoire Une bonne pratique à suivre quand on travaille avec des objets est la suivante : (1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire @@ -478,34 +483,39 @@ Une bonne pratique à suivre quand on travaille avec des objets est la suivante MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence [classeVar release]; // Décrémente le compteur de rérence // 'retain' incrémente le compteur de référence -// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nulle +// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nul MaClasse *nouvelleVar = [classVar retain]; -[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du block +[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du bloc -// @property peuvent utiliser 'retain' et 'assign' +// Les @property peuvent utiliser 'retain' et 'assign' @property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle @property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur // Automatic Reference Counting (ARC) -// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de référence -// automatique (Automatic Reference Counting en anglais). -// ARC est une fonctionnalité du compilateur qui lui permet d'ajouter les 'retain', 'release' et 'autorelease' -// automatiquement. Donc quand utilisez ARC vous de devez plus utiliser ces mots clés +// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de +// référence automatique (Automatic Reference Counting en anglais) +// ARC est une fonctionnalité du compilateur qui permet d'ajouter les 'retain', 'release' et 'autorelease' +// automatiquement. Cela veut dire que lorsque vous utilisez ARC vous ne devez plus utiliser ces mot-clés MaClasse *arcMaClasse = [[MaClasse alloc] init]; // ... code utilisant arcMaClasse -// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC il n'y a plus -// besoin car le compilateur ajoutera l'expréssion automatiquement pour vous +// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC +// activé il n'est plus nécessaire de le faire car le compilateur ajoutera l'expréssion automatiquement +// pour vous // Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong' -@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si l'instance original descend à zero, weakVar -// sera automatiquement mis à nil -@property (strong) MaClasse *strongVar; // 'strong' prend posséssion de l'objet comme le ferai le mot clé 'retain' - -// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions suivantes : -__strong NSString *strongString; // Par defaut. La variable est retenu en mémoire jusqu'à la fin de sa portée -__weak NSSet *weakSet; // Réfère la variable en utilisant le mot clé '__weak' -__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais quand la variable n'est pas mis à nil quand l'objet -// est supprimé ailleurs +@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si le compteur de référence +// descend à zero, weakVar sera automatiquement mis à nil +@property (strong) MaClasse *strongVar; // 'strong' prend possession de l'objet comme le ferait avec +// le mot-clé 'retain' + +// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions +// suivantes : +__strong NSString *strongString; // Par défaut. La variable est retenue en mémoire jusqu'à la fin +// de sa portée +__weak NSSet *weakSet; // Maintient une référence vers l'objet sans incrémenter son compteur de référence : +// Lorsque l'objet sera supprimé, weakSet sera mis à nil automatiquement +__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'est pas mis à nil quand +// l'objet est supprimé ``` ## Lectures Complémentaires |