Discussion :

[Aurelien.Regat-Barrel]

Sujet dédié à la traduction et la relecture du chapitre 3.8

[Invité]

let's go pour un nouveau chapitre...

[Aurelien.Regat-Barrel]

Note que c'est un chapitre volumineux, donc c'est normal si tu n'arrives pas à l'achever. Dans ce cas, quand tu ne peux plus avancer faute de temps, n'hésite pas à poster ici ce que tu as déjà fait, que quelqu'un reprenne le flambeau.
Bon courage

[Invité]

Note que c'est un chapitre volumineux, donc c'est normal si tu n'arrives pas à l'achever. Dans ce cas, quand tu ne peux plus avancer faute de temps, n'hésite pas à poster ici ce que tu as déjà fait, que quelqu'un reprenne le flambeau.
Bon courage

sans pb, effectivement, j'ai jeté un coup d'oeil a l'animal avant de le DL, et c'est sur, c'est pas un chapitre de **** ! lol

[Invité]

c'etait super long, et je m'en excuse.

voici la bete !

[r0d]

En effet, ce chapitre était énorme.

[Thierry Chappuis]

Je relis

Thierry

[ebgérard]

Chapeau pour le travail fourni car il y a de quoi se fatiguer.
Je vous propose quelques modifs, à vous de voir si cela vous va.

Le code va en fait créer un int* qui est x et un int (pas un int*) qui est y. Cela vient du fait que le ‘*’ s'associe par la droite, pas par la gauche. Cependant si vous utilisez un typedef :

Je pense qu'il serait plus correct de dire :

Le code va en fait créer un int* qui est x et un int (pas un int*) qui est y. Cela vient du fait que le ‘*’ s'associe par la droite, et non par la gauche. Cependant si vous utilisez un typedef :

Alors vous pourriez argumenter qu'il est plus explicite et donc plus lisible d'éviter les typedef sur les types primitifs, et que les programmes deviendraient rapidement difficiles à lire quand beacoup de typedef sont utilisés. Cependant, les typedef deviennent particulièrement importants en C quand ils sont utilisés avec struct.

Je suggère que vous enleviez le Alors du début.

La déclaration d'une struct doit être terminée par un point-virgule. Dans notre main( ), deux instances de Structure1 sont créée : s1 et s2. Chacune de ces instances dispose de ses propres version distinctes de c, i, f et d. ainsi s1 et s2 représentent des blocs de variables totallement indépendants. Pour sélectionner un des éléments encapsulé dans s1 ou s2, vous utilisez un ‘.’, syntaxe que vous avez rencontré dans le précédent chapitre en utilisant des objets de classes C++ – comme les classes sont des structures évoluées, voici donc d'où vient la syntaxe.

Ortographe de totallement totalement

Cependant, il existe une foultitude d'exemples pour lesquels vous pourriez avoir recours à struct au cours d'une définition.

Je pense que cette traduction n'est pas bonne, je crois que l'auteur veut plutot dire

Cependant, il y a des fois où vous pourriez avoir besoin de vous référer au struct pendant sa définition.

Pointeurs et structures
Dans les exemples ci-dessous, toutes les structures sont manipulées comme des objets.

Remplacer ci-dessous ci-dessus

//: C03:SimpleStruct3.cpp
// Utilisattion de pointeurs de struct
typedef struct Structure3 {

Ortographe de Utilisattion Utilisation

Dans main( ), le pointeur de struct sp pointe initiallement sur s1, et les membres de s1 sont initialisés en les sélectionnant grâce au ‘->’ (et vous utilisez ce même opérateur pour lire ces membres).

Ortographe initiallement initialement

Pour l'instant, c'est tout ce que vous avez vesoin de savoir à propos des struct, mais vous allez devenir très familiers (et particulièrement avec leur plus puissants succèsseurs, les classes) au fur et à mesure de la lecture de ce livre.

Ortographe vesoin besoin
succèsseurs successeurs

shape est une variable du type de données énuméré ShapeType, et sa valeur est comparée à lavaleur de l'énumération.

Il manque un espace à lavaleur la valeur

Vous devez savoir que l'exemple ci-dessus sur la séparation de l'exécution selon le type est une manière de programmer problématique.

Je pense que ce n'est pas ce que l'auteur veut dire mais je n'arrive pas à le traduire correctement, ce doit être plutot quelque chose du genre :
Vous devriez vous rendre compte dans l'exemple ci-dessus qu'effectuer un switch sur un type est une façon problématique de programmer.

le C++ propose une façon de faire ce genre de choses bien meilleure, laquelle méthode devant être reportée plus avant dans la lecture de ce livre.

Je propose :

Le c++ propose une façon bien meilleure pour faire ce genre de choses, l'explication de ceci sera donnée plus loin dans le livre.

On peut voir alors combien on gagne en lisibilité du code en utilisant des types de données énumérés. Cependant, à un certain degré, cela reste une tentative (en C) d'accomplir les choses que l'on peut faire avec une classs en C++, donc vous verez les enum moins utilisés en C++.

Je propose :

Cependant, d'une certaine façon, cela reste une tentative (en C) d'accomplir des choses que l'on peut faire avec une class en C++, c'est ainsi que vous verrez que les enum sont moins utilisées en C++.

En addition, il existe une vérification de type encore plus stricte pour les énumérations en C++ qu'en C. Vous noterez cela en particulier si vous avez une instance d'une énumération color appelée a. En C, pous pouvez dire a++, mais en C++ vous ne pouvez pas. C'est parce qu'incrémenter une énumération effectue en réalité deux conversions de type, l'une d'elle légale en C++, mais l'autre illégale. D'abord, la valeur de l'énumération est implicitement convertie de color vers un int, puis la valeur est incrémentée, et est reconvertie en color. En C++, ce n'est pas autorisé , parce que color est un type distinct est n'est pas équvalent à un int. Cela a du sens, parce que comment saurait-on si l'incrément de blue soit même dans la liste de couleurs ? Si vous souhaitez incrémenter un color, alors ce doit être une classe (avec une opération d'incrémentation) et non pas une enum, parce que la classe peut être rendue plus sûre. Chaque fois que vous écrivre du code qui nécessite une conversion implicite vers un type enum, Le compilateur vous avertira de la dangerosité inhérante de cette opération.

Je propose ici :
De plus, la vérification de type est plus stricte pour les énumérattions en C++ qu'en C. Vous noterez cela, en particulier, dans le cas d'une énumération color appelée a.En C, pous pouvez écrire a++, chose que vous ne pouvez pas faire en C++. Ceci parce que l'incrémenation d'une énumération effectue en réalité deux conversions de type, une d'elle légale en C++, et l'autre illégale. La valeur de l'énumération est, tout d'abord, implicitement convertie de color vers un int, cette valeur est ensuite incrémentée, puis reconvertie en color. En C++, ceci n'est pas autorisé , parce que color est un type distinct et n'est pas équivalent à un int. Cela a du sens, parce que comment saurait-on si le résultat de l'incrémentation de blue sera dans la liste de couleurs ? Si vous souhaitez incrémenter un color, alors vous devez utiliser une classe (avec une opération d'incrémentation) et non pas une enum, parce que la classe peut être écrite pour rendre ceci plus sûr. Chaque fois que vous écrirez du code qui nécessite une conversion implicite vers un type enum, le compilateur vous avertira du danger inhérant à cette opération.

Les unions (Décrites dans la prochaine section) possèdent la même vérification additionnelle de type en C++.

Majuscule (Décrites (décrites

Une union Empile toutes les données dans un meme espace ; cela signifie que la quantité de mémoire nécessaire sera celle de l'item le plus grand que vous avez placé dans l'union. Utilisez une union pour sauvegarder de la mémoire.

Majuscule Empile empile
Utilisez une union pour économiser de la mémoire

Chaque fois que vous écrivez une valeur dans une union, Cette valeur commence toujours à l'adresse de début de l'union, mais n'utilise toujours que la mémoire nécessaire.

Majuscule ,Cette ,cette
mais n'utilise toujours que la mémoire nécessaire. mais utilise seulement la mémoire nécessaire

Voici un simple usage d'une union. essayez de supprimer quelques éléments pour voir quel effet cela a sur la taille de l'union. Notez que cela n'a pas de sens de déclarer plus d'une instance d'un simple type de données dans une union (à moins que vous ne faites ceci juste pour utiliser différents noms).

Majuscule . essayez . Essayez
(à moins que vous ne fassiez ceci que pour utiliser différents noms).

J'arrête là pour ce soir, je verrai demain..
A bientôt donc

[ebgérard]

// L'union seera de la taille d'un

Ortographe seera sera

// double, puisque c'est le type le plus large

Je propose de se rapprocher du texte // double, puisque c'est l'élément le plus grand

Cependant, vous devez retenir que bien que la taille de a soit 10, on sélectionne les éléments d'un tableau en commençant à zero (ceci est parfois appelé indexation basée sur zero), donc vous pouvez sélectionner les éléments de notre tableau uniquement de 0-9, comme ceci :

Je propose de modifier la fin du paragraphe comme suit:
donc vous ne pouvez sélectionner que les éléments 0-9 du tableau.

L'accès aux tableau est extrèmement rapide. Cependant, si vous indexez au delà de la fin du tableau, il n'y a aucun filet de sécurité – vous serez directement sur d'autres variables.

Ortographe tableau tableaux
Pour la deuxième phrase, je propose:
Cependant, si votre index dépasse la fin du tableau, il n'y a aucun filet de protection - vous pointerez sur d'autres variables.

L'autre inconvénient est que l'on doit spécifier la taille du tableau au moment de la compilation

Je propose de garder la forme initiale :
L'autre inconvénient est que vous devez spécifier ....

Vous pouvez créer un tableau de n'importe quel type, même de structures :

Je propose de remplacer même y compris

Remarquez comment l'indentifiant i de la structure es indépendant de celui de la boucle for.

Ortographe es est

Pour vérifier que chaque élément d'un tableau est contigü avec le suivant, on peut afficher les adresses comme ceci :

Je propose de dire :
Pour vérifier que tous les éléments d'untableau se suivent, vous pouvez afficher ...

L'identifiant d'un tableau n'est pas comme celui d'une variable ordinaire. Le nom d'un tableau l'est pas une lvalue ; on ne peut pas lui lui affecter de valeur.

je propose de revenir au vous souhaité par l'auteur
; vous ne pouvez pas luis affecter de valeur

C'est en fait juste un crochet sur la syntaxe utilisant les crochets, et quand vous prenez le nom d'un tableau, sans crochets, vous n'avez en fait que l'adresse de son commencement :

Je pense que cette traduction est maladroite, mais comme vous je bute sur ce point, je propose cependant:
C'est seulement un pivot pour la syntaxe des crochets '[]' et si vous utilisez le nom du tableau sans crochets, vous obtenez l'adresse du début du tableau.

En exécutant ce programme, vous constatez que les deux adresses (affichée en hexadécimal, puisque aucun cast en long n'est fait) sont les même.

Je propose:
En exécutant ce programme, vous constaterez que .... sont identiques.

Donc une façon de voir un tableau est de le considérer comme un pointeur sur le début du tableau. Aussi vous on ne peut pas changer la variable pour qu'elle pointe ailleurs, on peut par contre créer un autre tableau et l'utiliser pour se déplacer dans le tableau. En fait, la syntaxe avec les crochets marche aussi avec les pointeurs normaux également :

Je propose ici de dire :
Nous pouvons considérer que le nom d'un tableau est un pointeur en lecture seule sur le début du tableau. Et bien que nous ne puissions changer le nom du tableau pour qu'il pointe ailleurs, nous pouvons créer un autre pointeur et l'utiliser pour se déplacer dans le tableau.

int main() {
int a[5], b[5];
// Probably garbage values:
print(a, "a", 5);
print(b, "b", 5);
// Initialize the arrays:

Traduction de // Probably garbage values Probablement des valeurs sans signification
// Initialize the arrays // Initialisation des tableaux

Il existe quelques autres problèmes que l'exemplesuivant nous révèle : les tableaux ne peuvent pas être passés par valeur A moins que vous ne considériez l'approche stricte selon laquelle “tous les paramètres en C/C++ sont passés par valeur,

Il manque un espace dans l'exemplesuivant l'exemple suivant
A moins à moins

Ceci peut être assimié comme étant vrai d'un point de vue du langage assembleur

Je propose ici de dire :
Ceci peut être considéré comme vrai ....

au point que je ressente plle besoin de penser en terme de “passage par valeur” contre “passage par adresse”, de façon que vous ne récupérez jamais de copie locale du tableau que vous passez à une fonction.

coquille plle le
je propose de remplacer contre par opposé à
je propose de remplacer de façon que par car

D'où, quand vous modifiez un tableau, vous modifiez toujours l'objet extérieur.

Je propose de remplacer D'où par Ainsi

Aussi, notez que la taille du tableau est passée en paramètre dans tous les cas.

Je propose de remplacer
Aussi, notez que : arrow: Notez également que

Simplement passer l'adresse d'un tableau n'est pas une information suffisante ;

Je propose d'inverser
Simplement passer : arrow: Passer simplement

vous devez toujours savoir de quelle taille est le tableau à l'intérieur de votre fonction

Je propose:
Vous devez toujours connaitre la taille du tableau....

Les deux formes sont équivalentes, mais je trouve la version utilisée dans ce libre la plus intuitive pour relire le code, puisqu'elle dit directement “Ceci est un tableau de pointeurs de caractères”.

coquille libre livre

Tous ce que vous récupérez de la ligne de commande n'est que tableaux de caractères ;

coquille Tous Tout

si vous vouslez traiter un argument comment étant d'un autre type, vous avez la responsabilité de le convertir depuis votre programme.

coquille vouslez voulez

Voici un example d'utilisation de atoi( ) (les deux autres fonctions sont appelées de la même manière) :

coquille example exemple

Aussi, si vous saisissez un nombre flottant contenant le point des décimales sur la ligne de commande, atoi( )

Je propose de remplacer Aussi Mais

Explorer le format flottant

Je propose ici Exploration du format flottant

pour que vous vous rendiez compte par vous même le schéma utilisé par votre compilateur

Je propose :
pour que vous vous rendiez compte du schéma....

D'abord, le programme garantie que le bon nombre de paramètres est fourni en vérifiant

coquille garantie garantit
Je propose également de remplacer D'abord soit par Tout d'abord ou En premier lieu

Puis le programme récupère le paramètre de la ligne de commande et convertis les caractères en double grâce à atof( ).

coquille convertis convertit

Ensuite le double est utilisé comme un tableau d'octets en prenant l'adresse et en le convertissant en unsigned char*.

Je propose et en la convertissant en pointeur sur unsigned char.

Cet example a été réalisé de façon que le bit de signe apparraisse d'abord sur ma machine.

coquille example exemple

Si tout ce que l'on pouvait aire avec un pointeur qui pointe sur un tableau était de l'utiliser comme un alias pour le nom du tableau,

coquille pouvait aire pouvait faire

Cependant, ce sont des outils plus flexible que cela, puisqu'ils peuvent être modifiés pour pointer n'importe où d'autre (mais rappelez vous que l'identifiant d'un tableau ne peut jamais être modifié pour pointer ailleurs).

coquille flexible flexibles
coorrection pour pointer n'importe où d'autre pour pointer n'importe où ailleurs

La raisonpour laquelle l'arithmétique des pointeurs est un sujet séparé de l'arithmétique ordinaire

coquille il manque un espace à Laraisonpour La raison pour

Pour une exécution szur ma machine, voici le résultat obtenu :

coquille szur sur

Le compilateur détermine la bonne quantité par laquelle le pointeur doit être changé de façon à ce qu'il pointe sur l'élément suivant

Je propose de dire:
Le compilateur détermine le bon déplacement à appliquer au pointeur pour qu'il pointe sur l'élément suivant

int main() {
int a[10];
for(int i = 0; i < 10; i++)
a[i] = i; // Give it index values
int* ip = a;
P(*ip);
P(*++ip);
P(*(ip + 5));
int* ip2 = ip + 5;
P(*ip2);
P(*(ip2 - 4));
P(*--ip2);
P(ip2 - ip); // Yields number of elements
} ///:~

traduction // Give it index values attribue les valeurs de l'index
// Yields number of elements Renvoit les nombre d'éléments

Dans tous les casn l'arithmétique des pointeurs résulte en un pointeur ajusté pour pointer au “bon endroit”, basé sur la taille des éléments pointés.

coquille Dans tous les casn l'arithmétique Dans tous les cas, l'arithmétique

La plus part du temps

orthographe La plupart du temps

vous aurez simplementbesoin de créer des tableaux

coquille il manque un espace entre simplement et besoin

la plupart des conteneurs standards du C++ cachent tous ces détails habiles pour que vous n'ayez pas à vous en préoccuper.

Je propose de remplacer habiles par intelligents.

Voilà les quelques propositions que je vous fait. Bravo pour le gros boulot effectué.

[r0d]

Vous pourriez en faire un fichier xml (ou txt) et le mettre en piece jointe siouplé ?

[ebgérard]

Je n'arrive pas à me défaire de mon problème de pièces jointes qui avait disparu mais est revenu csans que j'arrive à trouver la faille. Il me semble que le fait que BitDefender n'arrive pas à se mettre à jour en soit la raison. Quoiqu'il en soit je tiens à votre dispostion le fichier xml corrigé, envoyez moi une adresse mail que je puisse vous l'envoyer.

[ebgérard]

J'ai enfin réglé mon pb de pièces jointes, voici le fichier avec les corrections.
@+

[bigboomshakala]

MAJ

[koala01]

j'ai repéré, lors d'une lecture rapide, quelques erreurs subsitant apres la mise à jour (ie: des appostrophes devenant des ?, et quelques coquilles)...

je fournis le fichier corrigé dés qu'il est pret

[koala01]

Le voici... quelques autres modifications mineures ont été apportées

[bigboomshakala]

(re)merci

[Zavonen]

quelques appuis clavier
remplacé par
quelques frappes

ses propres version(s) distinctes

fermer la parenthèse
(comme cela ressort, c'est requis en C uniquement, pas en C++.

que celui dutypedef,

Vous devez savoir que l'exemple ci-dessus sur la séparation de l'exécution selon le type est une manière de programmer problématique.
Je propose plus simplement l'exemple de renommage ci-dessus

majuscule pour c++

C'est seulement un pivot pour la syntaxe utilisant les crochets ‘[]’,
Je propose 'point d'ancrage' au lieu de pivot.

fourni et non fournit
qui vaut deux si un seul argument est fournit (il vaut un si aucun argument n'est fournit, puisque le nom du programme est toujours le premier élément de argv)

circonflexe: La votre peut être différente

une valeur entière et non une valeur intégrale

parce qu'elle est appliquées

ne soit dé référencé: en un seul mot

Notez que seules les valeurs intégrales sont (entières)