Skip to content
Extraits de code Groupes Projets
Valider 9e42200e rédigé par CharlyBVO's avatar CharlyBVO
Parcourir les fichiers

fix references aux codes src dans les sections langage C et fichiers

parent f69424fa
Aucune branche associée trouvée
Aucune étiquette associée trouvée
Aucune requête de fusion associée trouvée
Tout étendre Masquer les modifications d'espaces
En ligne Côte à côte
Affichage de
avec 668 ajouts et 104 suppressions
Theorie/C/datatypes.rst
+ 40
− 40
Voir le fichier @ 9e42200e
......@@ -85,7 +85,7 @@ convention préfixé par ``0x`` tandis qu'un nombre entier en notation
binaire est préfixé par ``0b``. Ainsi, les déclarations ci-dessous
correspondent toutes à la même valeur.
.. literalinclude:: /C/S2-src/num.c
.. literalinclude:: /_static/src/C/S2-src/num.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -109,7 +109,7 @@ contrairement à la notation hexadécimale qui fait partie du langage.
``65 et 53 sont différents`` car le compilateur C interprète la ligne
``j=065;`` comme contenant un entier en notation octale et non décimale.
.. literalinclude:: /C/S2-src/octal.c
.. literalinclude:: /_static/src/C/S2-src/octal.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -240,7 +240,7 @@ peut causer des erreurs dans certains calculs. Par exemple,
voici un petit programme qui affiche les 10 premières puissances de
cinq et dix.
.. literalinclude:: /C/S2-src/short.c
.. literalinclude:: /_static/src/C/S2-src/short.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -248,7 +248,7 @@ cinq et dix.
Lorsqu'il est exécuté, ce programme affiche la sortie suivante.
.. literalinclude:: /C/S2-src/short.out
.. literalinclude:: /_static/src/C/S2-src/short.out
:encoding: utf-8
:language: console
......@@ -316,7 +316,7 @@ Les tableaux
En langage C, les tableaux permettent d'agréger des données d'un même type. Il est possible de définir des vecteurs et des matrices en utilisant la syntaxe ci-dessous.
.. literalinclude:: /C/S2-src/array.c
.. literalinclude:: /_static/src/C/S2-src/array.c
:language: c
:encoding: utf-8
:start-after: ///AAA
......@@ -326,7 +326,7 @@ Les premières versions du langage C ne permettaient que la définition de table
Un tableau à une dimension peut s'utiliser avec une syntaxe similaire à celle utilisée par Java. Dans un tableau contenant ``n`` éléments, le premier se trouve à l'indice ``0`` et le dernier à l'indice ``n-1``. L'exemple ci-dessous présente le calcul de la somme des éléments d'un vecteur.
.. literalinclude:: /C/S2-src/array.c
.. literalinclude:: /_static/src/C/S2-src/array.c
:language: c
:encoding: utf-8
:start-after: ///CCC
......@@ -334,7 +334,7 @@ Un tableau à une dimension peut s'utiliser avec une syntaxe similaire à celle
Le langage C permet aussi la manipulation de matrices carrées ou rectangulaires qui sont composées d'éléments d'un même type. L'exemple ci-dessous calcule l'élément minimum d'une matrice rectangulaire. Il utilise la constante ``FLT_MAX`` qui correspond au plus grand nombre réel représentable avec un ``float`` et qui est définie dans `float.h`_.
.. literalinclude:: /C/S2-src/array.c
.. literalinclude:: /_static/src/C/S2-src/array.c
:language: c
:encoding: utf-8
:start-after: ///EEE
......@@ -374,7 +374,7 @@ caractères. À titre d'exemple, une fonction `toupper(3)`_ permettant
de transformer un caractère représentant une minuscule dans le
caractère représentant la majuscule correspondante peut s'écrire :
.. literalinclude:: /C/S2-src/toupper.c
.. literalinclude:: /_static/src/C/S2-src/toupper.c
:language: c
:encoding: utf-8
:start-after: ///AAA
......@@ -441,7 +441,7 @@ fonctions de manipulation de chaînes de
caractères. À titre d'exemple, la fonction ci-dessous calcule
la longueur d'une chaîne de caractères.
.. literalinclude:: /C/S2-src/strlen.c
.. literalinclude:: /_static/src/C/S2-src/strlen.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -556,7 +556,7 @@ donnée. Les adresses de données en mémoire sont rarement affichées,
mais quand c'est le cas, on utilise la notation hexadécimale comme
dans l'exemple ci-dessous.
.. literalinclude:: /C/S2-src/ptr.c
.. literalinclude:: /_static/src/C/S2-src/ptr.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -564,7 +564,7 @@ dans l'exemple ci-dessous.
L'exécution de ce fragment de programme produit la sortie suivante.
.. literalinclude:: /C/S2-src/ptr.out
.. literalinclude:: /_static/src/C/S2-src/ptr.out
:encoding: utf-8
:language: console
......@@ -591,7 +591,7 @@ l'expression ``*ptr``. Il est
représenté dans l'exemple ci-dessous.
.. literalinclude:: /C/S2-src/ptrex.c
.. literalinclude:: /_static/src/C/S2-src/ptrex.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -599,7 +599,7 @@ représenté dans l'exemple ci-dessous.
L'exécution de ce fragment de programme produit la sortie suivante.
.. literalinclude:: /C/S2-src/ptrex.out
.. literalinclude:: /_static/src/C/S2-src/ptrex.out
:encoding: utf-8
:language: console
......@@ -609,7 +609,7 @@ En pratique en C, les notations ``char*`` et ``char[]`` sont
les pointeurs, la fonction de calcul de la longueur d'une chaîne de
caractères peut se réécrire comme suit.
.. literalinclude:: /C/S2-src/strlenptr.c
.. literalinclude:: /_static/src/C/S2-src/strlenptr.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -618,7 +618,7 @@ caractères peut se réécrire comme suit.
Les pointeurs sont fréquemment utilisés dans les programmes écrits en langage C et il est important de bien comprendre leur fonctionnement. Un point important à bien comprendre est ce que l'on appelle l'`arithmétique des pointeurs`, c'est-à-dire la façon dont les opérations sur les pointeurs sont exécutées en langage C. Pour cela, il est intéressant de considérer la manipulation d'un tableau d'entiers à travers des pointeurs.
.. literalinclude:: /C/src/ptr_arith.c
.. literalinclude:: /_static/src/C/src/ptr_arith.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -626,7 +626,7 @@ Les pointeurs sont fréquemment utilisés dans les programmes écrits en langage
En mémoire, ce tableau est stocké en utilisant trois mots consécutifs de 32 bits comme le montre l'exécution du programme ci-dessous :
.. literalinclude:: /C/src/ptr_arith.c
.. literalinclude:: /_static/src/C/src/ptr_arith.c
:encoding: utf-8
:language: c
:start-after: ///CCC
......@@ -640,7 +640,7 @@ En mémoire, ce tableau est stocké en utilisant trois mots consécutifs de 32 b
La même sortie est produite avec le fragment de programme suivant qui utilise un pointeur.
.. literalinclude:: /C/src/ptr_arith.c
.. literalinclude:: /_static/src/C/src/ptr_arith.c
:encoding: utf-8
:language: c
:start-after: ///EEE
......@@ -658,7 +658,7 @@ Après l'exécution de la première ligne, ``ptr`` va contenir l'adresse de l'é
Il est intéressant pour terminer cette première discussion de l'arithmétique des pointeurs, de considérer l'exécution du fragment de code ci-dessous.
.. literalinclude:: /C/src/ptr_arith.c
.. literalinclude:: /_static/src/C/src/ptr_arith.c
:encoding: utf-8
:language: c
:start-after: ///GGG
......@@ -686,7 +686,7 @@ Outre les types de données décrits ci-dessus, les programmes informatiques doi
C permet la définition de structures qui combinent différents types de données simples ou structurés. Contrairement aux langages orientés objet, il n'y a pas de méthode directement associée aux structures qui sont définies. Une structure est uniquement un type de données. Voici quelques exemples de structures simples en C.
.. literalinclude:: /C/S2-src/struct.c
.. literalinclude:: /_static/src/C/S2-src/struct.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -698,7 +698,7 @@ La structure ``struct fract`` définit une fraction qui est composée de deux en
Les structures permettent de facilement regrouper des données qui sont logiquement reliées entre elles et doivent être manipulées en même temps. C permet d'accéder facilement à un élément d'une structure en utilisant l'opérateur '``.``'. Ainsi, la structure ``point`` dont nous avons parlé ci-dessus aurait pu être initialisée par les trois expressions ci-dessous :
.. literalinclude:: /C/S2-src/struct.c
.. literalinclude:: /_static/src/C/S2-src/struct.c
:encoding: utf-8
:language: c
:start-after: ///CCC
......@@ -724,7 +724,7 @@ Les structures sont également fréquemment utilisées pour représenter des for
La définition de ``struct timeval`` utilise une fonctionnalité fréquemment utilisée du C : la possibilité de définir des alias pour des noms de type de données existants. Cela se fait en utilisant l'opérateur ``typedef``. En C, il est possible de renommer des types de données existants. Ainsi, l'exemple ci-dessous utilise ``typedef`` pour définir ``Entier`` comme alias pour le type ``int`` et ``Fraction`` pour la structure ``struct fraction``.
.. literalinclude:: /C/S2-src/typedef.c
.. literalinclude:: /_static/src/C/S2-src/typedef.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -739,7 +739,7 @@ Les types ``Entier`` et ``int`` peuvent être utilisés de façon interchangeabl
``typedef`` est souvent utilisé pour avoir des identifiants de types de données plus courts. Par exemple, il est très courant de remplacer le types ``unsigned`` par les abréviations ci-dessous.
.. literalinclude:: /C/S2-src/typedef.c
.. literalinclude:: /_static/src/C/S2-src/typedef.c
:encoding: utf-8
:language: c
:start-after: ///EEE
......@@ -747,7 +747,7 @@ Les types ``Entier`` et ``int`` peuvent être utilisés de façon interchangeabl
Soyez prudents si vous utilisez des ``typedef`` pour redéfinir des pointeurs. En C, il est tout à fait valide d'écrire les lignes suivantes.
.. literalinclude:: /C/S2-src/typedef.c
.. literalinclude:: /_static/src/C/S2-src/typedef.c
:encoding: utf-8
:language: c
:start-after: ///CCC
......@@ -758,7 +758,7 @@ Les types ``Entier`` et ``int`` peuvent être utilisés de façon interchangeabl
Les pointeurs sont fréquemment utilisés lors de la manipulation de structures. Lorsqu'un pointeur pointe vers une structure, il est utile de pouvoir accéder facilement aux éléments de la structure. Le langage C supporte deux notations pour représenter ces accès aux éléments d'une structure. La première notation est ``(*ptr).elem`` où ``ptr`` est un pointeur et ``elem`` l'identifiant d'un des éléments de la structure pointée par ``ptr``. Cette notation est en pratique assez peu utilisée. La notation la plus fréquente est ``ptr->elem`` dans laquelle ``ptr`` et ``->elem`` sont respectivement un pointeur et un identifiant d'élément. L'exemple ci-dessous illustre l'initialisation de deux fractions en utilisant ces notations.
.. literalinclude:: /C/S2-src/structptr.c
.. literalinclude:: /_static/src/C/S2-src/structptr.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -774,7 +774,7 @@ Comme la plupart des langages, le C permet de faciliter la compréhension d'un p
en le découpant en de nombreuses fonctions. Chacune réalise une
tâche simple. Tout comme Java, C permet la définition de fonctions qui ne retournent aucun résultat. Celles-ci sont de type ``void`` comme l'exemple trivial ci-dessous.
.. literalinclude:: /C/S2-src/fct.c
.. literalinclude:: /_static/src/C/S2-src/fct.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -782,7 +782,7 @@ tâche simple. Tout comme Java, C permet la définition de fonctions qui ne reto
La plupart des fonctions utiles retournent un résultat qui peut être une donnée d'un des types standard ou une structure. Cette utilisation est similaire à ce que l'on trouve dans des langages comme Java. Il faut cependant être attentif à la façon dont le langage C traite les arguments des fonctions. Le langage C utilise le `passage par valeur` des arguments. Lorsqu'une fonction est exécutée, elle reçoit les valeurs de ces arguments. Ces valeurs sont stockées dans une zone mémoire qui est locale à la fonction. Toute modification faite sur la valeur d'une variable à l'intérieur d'une fonction est donc locale à cette fonction. Les deux fonctions ci-dessous ont le même résultat et aucune des deux n'a d'effet de bord.
.. literalinclude:: /C/S2-src/fct.c
.. literalinclude:: /_static/src/C/S2-src/fct.c
:encoding: utf-8
:language: c
:start-after: ///CCC
......@@ -790,7 +790,7 @@ La plupart des fonctions utiles retournent un résultat qui peut être une donn
Il faut être nettement plus attentif lorsque l'on écrit des fonctions qui utilisent des pointeurs comme arguments. Lorsqu'une fonction a un argument de type pointeur, celui-ci est passé par valeur, mais connaissant la valeur du pointeur, il est possible à la fonction de modifier le contenu de la zone mémoire pointée par le pointeur. Ceci est illustré par l'exemple ci-dessous.
.. literalinclude:: /C/S2-src/fct.c
.. literalinclude:: /_static/src/C/S2-src/fct.c
:encoding: utf-8
:language: c
:start-after: ///EEE
......@@ -798,13 +798,13 @@ Il faut être nettement plus attentif lorsque l'on écrit des fonctions qui util
Lors de l'exécution de la fonction ``f``, le programme ci-dessus affiche à la console la sortie suivante :
.. literalinclude:: /C/S2-src/fct.out
.. literalinclude:: /_static/src/C/S2-src/fct.out
:encoding: utf-8
:language: console
Cet exemple illustre aussi une contrainte imposée par le langage C sur l'ordre de définition des fonctions. Pour que les fonctions ``times_two`` et ``timestwo`` puissent être utilisées à l'intérieur de la fonction ``f``, il faut qu'elles aient été préalablement définies. Dans l'exemple ci-dessus, cela s'est fait en plaçant la définition des deux fonctions avant leur utilisation. C'est une règle de bonne pratique utilisable pour de petits programmes composés de quelques fonctions. Pour des programmes plus larges, il est préférable de placer au début du code source la signature des fonctions qui y sont définies. La signature d'une fonction comprend le type de valeur de retour de la fonction, son nom et les types de ses arguments. Généralement, ces déclarations sont regroupées à l'intérieur d'un :term:`fichier header` dont le nom se termine par ``.h``.
.. literalinclude:: /C/S2-src/fct.h
.. literalinclude:: /_static/src/C/S2-src/fct.h
:encoding: utf-8
:language: c
:start-after: ///HHH
......@@ -812,7 +812,7 @@ Cet exemple illustre aussi une contrainte imposée par le langage C sur l'ordre
Les fonctions peuvent évidemment recevoir également des tableaux comme arguments. Cela permet par exemple d'implémenter une fonction qui calcule la longueur d'une chaîne de caractères en itérant dessus jusqu'à trouver le caractère de fin de chaîne.
.. literalinclude:: /C/S2-src/strlenptr.c
.. literalinclude:: /_static/src/C/S2-src/strlenptr.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -826,7 +826,7 @@ Tout comme cette fonction peut accéder au `ième` caractère de la chaîne pass
Un autre exemple de fonctions qui manipulent les tableaux sont des fonctions mathématiques qui traitent des vecteurs par exemple.
.. literalinclude:: /C/S2-src/fctargs.c
.. literalinclude:: /_static/src/C/S2-src/fctargs.c
:encoding: utf-8
:language: c
:start-after: ///CCC
......@@ -835,7 +835,7 @@ Un autre exemple de fonctions qui manipulent les tableaux sont des fonctions mat
Ces deux fonctions peuvent être utilisées par le fragment de code ci-dessous :
.. literalinclude:: /C/S2-src/fctargs.c
.. literalinclude:: /_static/src/C/S2-src/fctargs.c
:encoding: utf-8
:language: c
:start-after: ///EEE
......@@ -846,7 +846,7 @@ Ces deux fonctions peuvent être utilisées par le fragment de code ci-dessous :
Certains langages comme Java sont fortement typés et le compilateur contient de nombreuses vérifications, notamment sur les types de données utilisés, qui permettent d'éviter un grand nombre d'erreurs. Le langage C est lui nettement plus libéral. Les premiers compilateurs C étaient très permissifs notamment sur les types de données passés en arguments. Ainsi, un ancien compilateur C accepterait probablement sans broncher les appels suivants :
.. literalinclude:: /C/S2-src/fctargs.c
.. literalinclude:: /_static/src/C/S2-src/fctargs.c
:encoding: utf-8
:language: c
:start-after: ///GGG
......@@ -863,7 +863,7 @@ Ces deux fonctions peuvent être utilisées par le fragment de code ci-dessous :
Pour terminer, mentionnons que les fonctions écrites en C peuvent utiliser des structures et des pointeurs vers des structures comme arguments. Elles peuvent aussi retourner des structures comme résultat. Ceci est illustré par deux variantes de fonctions permettant d'initialiser une fraction et de déterminer si deux fractions sont égales [#fegal]_.
.. literalinclude:: /C/S2-src/struct.c
.. literalinclude:: /_static/src/C/S2-src/struct.c
:encoding: utf-8
:language: c
:start-after: ///EEE
......@@ -873,7 +873,7 @@ Considérons d'abord les fonctions ``init`` et ``equal``. ``init`` est une fonct
Les fonctions ``initptr`` et ``equalptr`` utilisent toutes les deux des pointeurs vers des ``struct fraction`` comme arguments. Ce faisant, elles ne peuvent modifier la valeur de ces pointeurs puisqu'ils sont passés comme valeurs. Par contre, les deux fonctions peuvent bien entendu modifier les éléments de la structure qui se trouvent dans la zone de mémoire pointée par le pointeur. C'est ce que ``initptr`` fait pour initialiser la structure. ``equalptr`` par contre se contente d'accéder aux éléments des structures passées en argument sans les modifier. Le fragment de code ci-dessous illustre comment ces fonctions peuvent être utilisées en pratique.
.. literalinclude:: /C/S2-src/struct.c
.. literalinclude:: /_static/src/C/S2-src/struct.c
:encoding: utf-8
:language: c
:start-after: ///GGG
......@@ -941,13 +941,13 @@ Ces opérations peuvent être combinées entre elles. Pour des raisons technolog
Ces opérations binaires peuvent s'étendre à des séquences de bits. Voici quelques exemples qui permettent d'illustrer ces opérations sur des octets.
.. literalinclude:: /C/S2-src/exprbin.out
.. literalinclude:: /_static/src/C/S2-src/exprbin.out
:encoding: utf-8
:language: console
En C, ces expressions logiques s'utilisent comme dans le fragment de code suivant. En général, elles s'utilisent sur des représentations non signées, souvent des ``unsigned char`` ou des ``unsigned int``.
.. literalinclude:: /C/S2-src/exprbin.c
.. literalinclude:: /_static/src/C/S2-src/exprbin.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -955,7 +955,7 @@ En C, ces expressions logiques s'utilisent comme dans le fragment de code suivan
En pratique, les opérations logiques sont utiles pour effectuer des manipulations au niveau des bits de données stockées en mémoire. Une utilisation fréquente dans certaines applications réseaux ou systèmes est de forcer certains bits à prendre la valeur ``0`` ou ``1``. La conjonction logique permet de forcer facilement un bit à zéro tandis que la disjonction logique permet de forcer facilement un bit à un. L'exemple ci-dessous montre comment forcer les valeurs de certains bits dans un ``unsigned char``. Il peut évidemment se généraliser à des séquences de bits plus longues.
.. literalinclude:: /C/S2-src/exprbin.c
.. literalinclude:: /_static/src/C/S2-src/exprbin.c
:encoding: utf-8
:language: c
:start-after: ///CCC
......@@ -967,7 +967,7 @@ En pratique, les opérations logiques sont utiles pour effectuer des manipulatio
L'opération XOR joue un rôle important dans certaines applications. La plupart des méthodes de chiffrement et de déchiffrement utilisent de façon extensive cette opération. Une des propriétés intéressantes de l'opération XOR est que :math:`(A \oplus B) \oplus B=A`. Cette propriété est largement utilisée par les méthodes de chiffrement. La méthode développée par Vernam au début du vingtième siècle s'appuie sur l'opération XOR. Pour transmettre un message `M` de façon sûre, elle applique l'opération XOR bit à bit entre tous les bits du message `M` et une clé `K` doit avoir au moins le même nombre de bits que `M`. Si cette clé `K` est totalement aléatoire et n'est utilisée qu'une seule fois, alors on parle de *one-time-pad*. On peut montrer que dans ce cas, la méthode de chiffrement est totalement sûre. En pratique, il est malheureusement difficile d'avoir une clé totalement aléatoire qui soit aussi longue que le message à transmettre. Le programme ci-dessous implémente cette méthode de façon triviale. La fonction `memfrob(3)`_ de la librairie :term:`GNU` utilise également un chiffrement via un XOR.
.. literalinclude:: /C/S2-src/xor.c
.. literalinclude:: /_static/src/C/S2-src/xor.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -993,7 +993,7 @@ Pour terminer, le langage C supporte des expressions permettant le décalage à
Ces opérations de décalage permettent différentes manipulations de bits. À titre d'exemple, la fonction ``int2bin`` utilise à la fois des décalages et des masques pour calculer la représentation binaire d'un entier non signé et la placer dans une chaîne de caractères.
.. literalinclude:: /C/S2-src/exprbin.c
.. literalinclude:: /_static/src/C/S2-src/exprbin.c
:encoding: utf-8
:language: c
:start-after: ///EEE
......
Theorie/C/linker.rst
+ 15
− 15
Voir le fichier @ 9e42200e
......@@ -33,7 +33,7 @@ Un premier exemple sont les pointeurs vers des fonctions. Comme nous l'avons vu
Cette application qui supporte plusieurs niveaux de débogage utilise pourtant toujours le même appel pour afficher l'information de débogage : ``(debug_print[debug_level])(...);``. Cet appel profite des pointeurs vers les fonctions. Le tableau ``debug_print`` est un tableau de pointeurs vers des fonctions qui chacune prend comme argument un ``char *``. La variable globale ``debug_level`` est initialisée sur base de l'argument passé au programme.
.. literalinclude:: /C/S5-src/fctptr.c
.. literalinclude:: /_static/src/C/S5-src/fctptr.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -49,7 +49,7 @@ Ce n'est pas la seule utilisation des pointeurs vers des fonctions. Il y a notam
Le premier est un pointeur vers le début de la zone mémoire à trier. Le second est le nombre d'éléments à trier. Le troisième contient la taille des éléments stockés dans le tableau. Le quatrième argument est un pointeur vers la fonction qui permet de comparer deux éléments du tableau. Cette fonction retourne un entier négatif si son premier argument est inférieur au second et positif ou nul sinon. Un exemple de fonction de comparaison est la fonction `strcmp(3)`_ de la librairie standard. Un autre exemple est repris ci-dessous avec une fonction de comparaison simple qui permet d'utiliser `qsort(3)`_ pour trier un tableau de ``double``.
.. literalinclude:: /C/S5-src/qsort.c
.. literalinclude:: /_static/src/C/S5-src/qsort.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -60,7 +60,7 @@ Il est utile d'analyser en détails les arguments de la fonction de comparaison
Le second type de pointeurs que nous n'avons pas encore abordé en détails sont les pointeurs vers des pointeurs. En fait, nous les avons utilisés sans vraiment le savoir dans la fonction ``main``. En effet, le second argument de cette fonction est un tableau de pointeurs qui pointent chacun vers des chaînes de caractères différentes. La notation ``char *argv[]`` est équivalente à la notation ``char **argv``. ``**argv`` est donc un pointeur vers une zone qui contient des pointeurs vers des chaînes de caractères. Ce pointeur vers un pointeur doit être utilisé avec précaution. ``argv[0]`` est un pointeur vers une chaîne de caractères. La construction ``&(argv[0])`` permet donc d'obtenir un pointeur vers un pointeur vers une chaîne de caractères, ce qui correspond bien à la déclaration ``char **``. Ensuite, l'utilisation de ``*p`` pourrait surprendre. ``*p`` est un pointeur vers une chaîne de caractères. Il peut donc être comparé à ``NULL`` qui est aussi un pointeur, incrémenté et la chaîne de caractères qu'il référence peut être affichée par `printf(3)`_.
.. literalinclude:: /C/S5-src/ptrptr.c
.. literalinclude:: /_static/src/C/S5-src/ptrptr.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -82,14 +82,14 @@ L'utilisation principale de `strtol(3)`_ est de convertir une chaîne de caract
`strtol(3)`_ est un exemple de fonction qui doit retourner deux types d'informations. Tout d'abord, `strtol(3)`_ retourne un résultat (dans ce cas un nombre). Si la chaîne de caractères à convertir est erronée, `strtol(3)`_ convertit le début de la chaîne et retourne un pointeur indiquant le premier caractère en erreur. Pour bien comprendre le fonctionnement de `strtol(3)`_, considérons l'exemple ci-dessous.
.. literalinclude:: /C/S5-src/strtol.c
.. literalinclude:: /_static/src/C/S5-src/strtol.c
:encoding: utf-8
:language: c
:start-after: ///AAA
Lors de son exécution, ce programme affiche la sortie suivante.
.. literalinclude:: /C/S5-src/strtol.out
.. literalinclude:: /_static/src/C/S5-src/strtol.out
:encoding: utf-8
:language: console
......@@ -97,7 +97,7 @@ L'appel à `strtol(3)`_ prend trois arguments. Tout d'abord un pointeur vers la
Une implémentation partielle de `strtol(3)`_ pourrait être la suivante.
.. literalinclude:: /C/S5-src/mystrtol.c
.. literalinclude:: /_static/src/C/S5-src/mystrtol.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -116,7 +116,7 @@ Lorsque l'on développe de grands programmes en C, il est préférable de décou
Pour comprendre l'utilisation de ces modules, considérons d'abord un programme trivial composé de deux modules. Le premier module est celui qui contient la fonction ``main``. Tout programme C doit contenir une fonction ``main`` pour pouvoir être exécuté. C'est en général l'interface avec l'utilisateur. Le second module contient une fonction générique qui est utilisée par le module principal.
.. literalinclude:: /C/S5-src/main.c
.. literalinclude:: /_static/src/C/S5-src/main.c
:encoding: utf-8
:language: c
......@@ -126,7 +126,7 @@ Un module d'un programme C est en général décomposé en deux parties. Tout d'
- les constantes qui sont utilisées à l'intérieur du module et doivent être visibles en dehors de celui-ci, notamment par les modules qui utilisent les fonctions du module. Ces constantes peuvent être définies en utilisant des directives ``#define`` du préprocesseur
- les variables globales qui sont utilisées par les fonctions du module et doivent être accessibles en dehors de celui-ci
.. literalinclude:: /C/S5-src/min.h
.. literalinclude:: /_static/src/C/S5-src/min.h
:encoding: utf-8
:language: c
......@@ -134,7 +134,7 @@ Un module d'un programme C est en général décomposé en deux parties. Tout d'
L'exemple de :term:`fichier header` ci-dessus illustre une convention courante dans l'écriture de ces fichiers. Parfois, il est nécessaire d'inclure un :term:`fichier header` dans un autre fichier header. Suite à cela, il est possible que les mêmes définitions d'un :term:`fichier header` soient incluses deux fois ou plus dans le même module. Cela peut causer des erreurs de compilation qui risquent de perturber certains programmeurs. Une règle de bonne pratique pour éviter ce problème est d'inclure le contenu du :term:`fichier header` de façon conditionnelle comme présenté ci-dessus. Une constante, dans ce cas ``_MIN_H_``, est définie pour le :term:`fichier header` concerné. Cette constante est définie dans la première ligne effective du :term:`fichier header`. Celui-ci n'est inclus dans un module que si cette constante n'a pas été préalablement définie. Si cette constante est connue par le préprocesseur, cela indique qu'un autre :term:`fichier header` a déjà inclus les définitions de ce fichier et qu'elles ne doivent pas être incluses une seconde fois.
.. literalinclude:: /C/S5-src/min.c
.. literalinclude:: /_static/src/C/S5-src/min.c
:encoding: utf-8
:language: c
......@@ -144,7 +144,7 @@ Un module d'un programme C est en général décomposé en deux parties. Tout d'
Lorsque l'on doit compiler un programme qui fait appel à plusieurs modules, quelle que soit sa taille, il est préférable d'utiliser `make(1)`_ pour automatiser sa compilation. Le fichier ci-dessous est un petit exemple de :term:`Makefile` utilisable pour un tel projet.
.. literalinclude:: /C/S5-src/Makefile2
.. literalinclude:: /_static/src/C/S5-src/Makefile2
:encoding: utf-8
:language: makefile
:start-after: ###AAA
......@@ -176,17 +176,17 @@ Il faut noter que ``static`` peut aussi précéder des déclarations de fonction
Afin d'illustrer l'utilisation de ``static`` et ``extern``, considérons le programme ``prog.c`` ci-dessous qui inclut le module ``module.c`` et également le module ``min.c`` présenté plus haut.
.. literalinclude:: /C/S5-src/module.h
.. literalinclude:: /_static/src/C/S5-src/module.h
:encoding: utf-8
:language: c
.. literalinclude:: /C/S5-src/module.c
.. literalinclude:: /_static/src/C/S5-src/module.c
:encoding: utf-8
:language: c
Ce module contient deux fonctions, ``vmin`` et ``min``. ``vmin`` est accessible depuis n'importe quel module. Sa signature est reprise dans le :term:`fichier header` ``module.h``. La fonction ``min`` par contre est déclarée comme étant ``static``. Cela implique qu'elle n'est utilisable qu'à l'intérieur de ce module et invisible de tout autre module. La variable globale ``num1`` est accessible depuis n'importe quel module. La variable ``num2`` également, mais elle est initialisée dans un autre module. Enfin, la variable ``num3`` n'est accessible qu'à l'intérieur de ce module.
.. literalinclude:: /C/S5-src/prog.c
.. literalinclude:: /_static/src/C/S5-src/prog.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -195,7 +195,7 @@ Ce module inclus les fichiers ``min.h`` et ``module.h`` qui contiennent les sign
La fonction ``f`` mérite que l'on s'y attarde un peu. Cette fonction contient la définition de la variable ``static n``. Même si cette variable est locale à la fonction ``f`` et donc invisible en dehors de cette fonction, le compilateur va lui réserver une place dans la même zone que les variables globales. La valeur de cette variable ``static`` sera initialisée une seule fois : au démarrage du programme. Même si cette variable parait être locale, elle ne sera jamais réinitialisée lors d'un appel à la fonction ``f``. Comme cette variable est stockée en dehors de la pile, elle conserve sa valeur d'une invocation à l'autre de la fonction ``f``. Ceci est illustré par l'exécution du programme qui produit la sortie suivante.
.. literalinclude:: /C/S5-src/prog.out
.. literalinclude:: /_static/src/C/S5-src/prog.out
:encoding: utf-8
:language: console
......@@ -211,7 +211,7 @@ Les systèmes Unix utilisent la variable globale :term:`errno` pour résoudre ce
A titre d'exemple, le programme ci-dessous utilise `strerror(3)`_ pour afficher un message d'erreur plus parlant lors d'appels erronés à la fonction `setenv(3)`_.
.. literalinclude:: /C/S5-src/errno.c
.. literalinclude:: /_static/src/C/S5-src/errno.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......
Theorie/C/malloc.rst
+ 31
− 31
Voir le fichier @ 9e42200e
Ce diff est replié.
Theorie/Fichiers/fichiers.rst
+ 3
− 3
Voir le fichier @ 9e42200e
......@@ -201,7 +201,7 @@ Cette structure comprend le numéro de l'inode, c'est-à-dire la métadonnée qu
L'extrait de code ci-dessous permet de lister tous les fichiers présents dans le répertoire ``name``.
.. literalinclude:: /Fichiers/src/readdir.c
.. literalinclude:: /_static/src/Fichiers/src/readdir.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -343,7 +343,7 @@ Ces deux appels systèmes prennent trois arguments. Le premier est le `descripte
Il est important de noter que `read(2)`_ et `write(2)`_ permettent de lire et d'écrire des séquences contiguës d'octets. Lorsque l'on écrit ou lit des chaînes de caractères dans lesquels chaque caractère est représenté sous la forme d'un byte, il est possible d'utiliser `read(2)`_ et `write(2)`_ pour lire et écrire d'autres types de données que des octets comme le montre l'exemple ci-dessous.
.. literalinclude:: /Fichiers/src/read.c
.. literalinclude:: /_static/src/Fichiers/src/read.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -351,7 +351,7 @@ Il est important de noter que `read(2)`_ et `write(2)`_ permettent de lire et d'
Lors de son exécution, ce programme affiche la sortie ci-dessous.
.. literalinclude:: /Fichiers/src/read.out
.. literalinclude:: /_static/src/Fichiers/src/read.out
:encoding: utf-8
:language: console
......
Theorie/Threads/coordination.rst
+ 5
− 5
Voir le fichier @ 9e42200e
......@@ -110,7 +110,7 @@ Les sémaphores permettent de résoudre de nombreux problèmes classiques. Le pr
Les sémaphores peuvent être utilisés pour d'autres types de synchronisation. Par exemple, considérons une application découpée en threads dans laquelle la fonction ``after`` ne peut jamais être exécutée avant la fin de l'exécution de la fonction ``before``. Ce problème de coordination peut facilement être résolu en utilisant un sémaphore qui est initialisé à la valeur ``0``. La fonction ``after`` doit démarrer par un appel à `sem_wait(3)`_ sur ce sémaphore tandis que la fonction ``before`` doit se terminer par un appel à la fonction `sem_post(3)`_ sur ce sémaphore. De cette façon, si le thread qui exécute la fonction ``after`` est trop rapide, il sera bloqué sur l'appel à `sem_wait(3)`_. S'il arrive à cette fonction après la fin de la fonction ``before`` dans l'autre thread, il pourra passer sans être bloqué. Le programme ci-dessous illustre cette utilisation des sémaphores POSIX.
.. literalinclude:: /Threads/S7-src/pthread-sem-before.c
.. literalinclude:: /_static/src/Threads/S7-src/pthread-sem-before.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -266,7 +266,7 @@ Une deuxième solution serait d'avoir un tableau global qui contiendrait des poi
Pour résoudre ce problème, deux solutions sont possibles. La première combine une extension au langage C qui est supportée par `gcc(1)`_ avec la librairie threads POSIX. Il s'agit du qualificatif ``__thread`` qui peut être utilisé avant une déclaration de variable. Lorsqu'il est utilisé dans la déclaration d'une variable globale, il indique au compilateur et à la libraire POSIX qu'une copie de cette variable doit être créée pour chaque thread. Cette variable est initialisée au démarrage du thread et est utilisable uniquement à l'intérieur de ce thread. Le programme ci-dessous illustre cette utilisation du qualificatif ``__thread``.
.. literalinclude:: /Threads/S7-src/pthread-specific.c
.. literalinclude:: /_static/src/Threads/S7-src/pthread-specific.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -274,7 +274,7 @@ Pour résoudre ce problème, deux solutions sont possibles. La première combine
Lors de son exécution, ce programme affiche la sortie suivante sur :term:`stdout`. Cette sortie illustre bien que les variables dont la déclaration est précédée du qualificatif ``__thread`` sont utilisables uniquement à l'intérieur d'un thread.
.. literalinclude:: /Threads/S7-src/pthread-specific.out
.. literalinclude:: /_static/src/Threads/S7-src/pthread-specific.out
:encoding: utf-8
:language: console
......@@ -291,7 +291,7 @@ Il faut noter que la fonction `pthread_key_create(3posix)`_ associe en pratique
L'exemple ci-dessous illustre l'utilisation de cette API. Elle est nettement plus lourde à utiliser que le qualificatif ``__thread``. Dans ce code, chaque thread démarre par la fonction ``f``. Celle-ci crée une variable spécifique de type ``int`` qui joue le même rôle que la variable ``__thread int count;`` dans l'exemple précédent. La fonction ``g`` qui est appelée sans argument peut accéder à la zone mémoire créée en appelant ``pthread_getspecific(count)``. Elle peut ensuite exécuter ses calculs en utilisant le pointeur ``count_ptr``. Avant de se terminer, la fonction ``f`` libère la zone mémoire qui avait été allouée par `malloc(3)`_. Une alternative à l'appel explicite à `free(3)`_ aurait été de passer ``free`` comme second argument à `pthread_key_create(3posix)`_ lors de la création de la clé ``count``. En effet, ce second argument est la fonction à appeler à la fin du thread pour libérer la mémoire correspondant à cette clé.
.. literalinclude:: /Threads/S7-src/pthread-specific2.c
.. literalinclude:: /_static/src/Threads/S7-src/pthread-specific2.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -311,7 +311,7 @@ Dans un programme séquentiel, il n'y a qu'un thread d'exécution et de nombreux
Pour comprendre le problème, il est intéressant de comparer plusieurs implémentations d'une fonction simple. Considérons le problème de déterminer l'élément maximum d'une structure de données contenant des entiers. Si la structure de données est un tableau, une solution simple est de le parcourir entièrement pour déterminer l'élément maximum. C'est ce que fait la fonction ``max_vector`` dans le programme ci-dessous. Dans un programme purement séquentiel dans lequel le tableau peut être modifié de temps en temps, parcourir tout le tableau pour déterminer son maximum n'est pas nécessairement la solution la plus efficace. Une alternative est de mettre à jour la valeur du maximum chaque fois qu'un élément du tableau est modifié. Les fonctions ``max_global`` et ``max_static`` sont deux solutions possibles. Chacune de ces fonctions doit être appelée chaque fois qu'un élément du tableau est modifié. ``max_global`` stocke dans une variable globale la valeur actuelle du maximum du tableau et met à jour cette valeur à chaque appel. La fonction ``max_static`` fait de même en utilisant une variable statique. Ces deux solutions sont équivalentes et elles pourraient très bien être intégrées à une librairie utilisée par de nombreux programmes.
.. literalinclude:: /Threads/S7-src/reentrant.c
.. literalinclude:: /_static/src/Threads/S7-src/reentrant.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......
Theorie/Threads/threads.rst
+ 9
− 4
Voir le fichier @ 9e42200e
......@@ -66,8 +66,11 @@ Cette progression continue des performances en MIPS a été possible grâce à l
La notion de thread d'exécution est très importante dans un système informatique. Elle permet non seulement de comprendre comme un ordinateur équipé d'un seul microprocesseur peut exécuter plusieurs programmes simultanément, mais aussi comment des programmes peuvent profiter des nouveaux processeurs capables d'exécuter plusieurs threads simultanément.
.. Pour comprendre cette notion, il est intéressant de revenir à nouveau sur l'exécution d'une fonction en langage assembleur.
La notion de thread d'exécution est très importante dans un système informatique. Elle permet non seulement de comprendre comme un ordinateur équipé d'un seul microprocesseur peut exécuter plusieurs programmes simultanément, mais aussi comment des programmes peuvent profiter des nouveaux processeurs capables d'exécuter plusieurs threads simultanément.
..
Pour comprendre cette notion, il est intéressant de revenir à nouveau sur l'exécution d'une fonction en langage assembleur.
Considérons la fonction ``f`` :
.. code-block:: c
......@@ -126,6 +129,8 @@ Pour qu'un processeur puisse exécuter cette séquence d'instructions, il faut q
- aux registres, des zone de mémoire très rapide (mais peu nombreuses par soucis technique) se trouvant sur le processeur qui permettent de stocker entre autre : l'addresse de l'instruction à exécuter, des résultats intermédaires obtenus durant l'exécution d'un instruction ou encore des informations sur la pile.
.. et plus particulièrement, il doit accéder :
..
- aux registres de données pour stocker les résultats de chacune des instructions
......@@ -191,7 +196,7 @@ Le premier argument de `pthread_join(3)`_ est la structure ``pthread_t`` corresp
L'exemple ci-dessous illustre une utilisation simple des fonctions `pthread_create(3)`_, `pthread_join(3)`_ et `pthread_exit(3)`_.
.. literalinclude:: /Threads/S5-src/pthread.c
.. literalinclude:: /_static/src/Threads/S5-src/pthread.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -200,7 +205,7 @@ Dans ce programme, la fonction ``main`` lance deux threads. Le premier exécute
Afin d'illustrer la possibilité de passer des arguments à un thread et d'en récupérer la valeur de retour, considérons l'exemple ci-dessous.
.. literalinclude:: /Threads/S5-src/pthread-neg.c
.. literalinclude:: /_static/src/Threads/S5-src/pthread-neg.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......
Theorie/Threads/threads2.rst
+ 6
− 6
Voir le fichier @ 9e42200e
......@@ -84,7 +84,7 @@ Malheureusement les difficultés surviennent lorsque deux threads exécutent en
La taille de la pile d'un thread POSIX est l'un des attributs qui peuvent être modifiés lors de l'appel à `pthread_create(3)`_ pour créer un nouveau thread. Cet attribut peut être fixé en utilisant la fonction `pthread_attr_setstackaddr(3posix)`_ comme illustré dans l'exemple ci-dessous [#fpthreadc]_ (où ``thread_first`` est la fonction qui sera appelée à la création du thread). En général, la valeur par défaut choisie par le système suffit, sauf lorsque le programmeur sait qu'un thread devra par exemple allouer un grand tableau auquel il sera le seul à avoir accès. Ce tableau sera alors alloué sur la pile qui devra être suffisamment grande pour le contenir.
.. literalinclude:: /Threads/S6-src/pthread.c
.. literalinclude:: /_static/src/Threads/S6-src/pthread.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -95,7 +95,7 @@ Ce problème d'accès concurrent à une zone de mémoire par plusieurs threads e
Le fragment de code ci-dessus présente une autre illustration d'une section critique. Dans cet exemple, la fonction ``main`` (non présentée), créée deux threads. Le premier exécute la fonction ``inc`` qui incrémente la variable ``global``. Le second exécute la fonction ``is_even`` qui teste la valeur de cette variable et compte le nombre de fois qu'elle est paire. Après la terminaison des deux threads, le programme affiche le contenu des variables ``global`` et ``even``.
.. literalinclude:: /Threads/S6-src/pthread-test-if.c
.. literalinclude:: /_static/src/Threads/S6-src/pthread-test-if.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -274,7 +274,7 @@ En C, cela se fait en utilisant les fonctions `pthread_mutex_lock(3posix)`_ et `
L'exemple ci-dessous reprend le programme dans lequel une variable globale est incrémentée par plusieurs threads.
.. literalinclude:: /Threads/S6-src/pthread-mutex.c
.. literalinclude:: /_static/src/Threads/S6-src/pthread-mutex.c
:encoding: utf-8
:language: c
:start-after: ///AAA
......@@ -303,9 +303,9 @@ Pour montrer que la propriété de vivacité est bien respectée, il faut montre
.. rubric:: Footnotes
.. [#fexemple] Le programme complet est accessible via :download:`/Threads/S5-src/pthread-test.c`
.. [#fexemple] Le programme complet est accessible via :download:`/_static/src/Threads/S5-src/pthread-test.c`
.. [#fpthreadc] Le programme complet est accessible via :download:`/Threads/S6-src/pthread.c`
.. [#fpthreadc] Le programme complet est accessible via :download:`/_static/src/Threads/S6-src/pthread.c`
.. .. [#fframes] Il existe différents standards pour le nombre d'images par seconde en cinéma et en télévision. Les plus courants sont 24, 25 et 30 images par seconde. Voir http://en.wikipedia.org/wiki/Frame_rate
......@@ -317,4 +317,4 @@ Pour montrer que la propriété de vivacité est bien respectée, il faut montre
.. [#fstaticinit] Linux supporte également la macro ``PTHREAD_MUTEX_INITIALIZER`` qui permet d'initialiser directement un ``pthread_mutex_t`` déclaré comme variable globale. Dans cet exemple, la déclaration aurait été : ``pthread_mutex_t global_mutex=PTHREAD_MUTEX_INITIALIZER;`` et l'appel à `pthread_mutex_init(3posix)`_ aurait été inutile. Comme il s'agit d'une extension spécifique à Linux, il est préférable de ne pas l'utiliser pour garantir la portabilité du code.
.. [#fphilo] Le programme complet est :download:`/Threads/S6-src/pthread-philo.c`
.. [#fphilo] Le programme complet est :download:`/_static/src/Threads/S6-src/pthread-philo.c`
_static/src/C/S2-src/array.c 0 → 100644
+ 97
− 0
Voir le fichier @ 9e42200e
/***********************************************
* array.c
*
* Programme d'exemple d'utilisation de tableaux
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
///AAA
#define N 10
int vecteur[N];
float matriceC[N][N];
float matriceR[N][2*N];
///BBB
// calcule la somme des éléments d'un tableau
int sum(int v[])
{
///CCC
int i;
int sum = 0;
for (i = 0; i < N; i++) {
sum += v[i];
}
///DDD
return sum;
}
// calcule la somme des éléments d'un tableau
int sum2(int size, int v[size])
{
int i;
int sum = 0;
for (i = 0; i < size; i++) {
sum += v[i];
}
return sum;
}
#include <float.h>
// retourne le maximum d'un matrice
// carrée de NxN élément
float max()
{
///EEE
#define L 2
#define C 3
float matriceR[L][C] = { {1.0,2.0,3.0},
{4.0,5.0,6.0} };
int i, j;
float min = FLT_MAX;
for (i = 0; i < L; i++)
for (j = 0; j < C; j++)
if (matriceR[i][j] < min)
min=matriceR[i][j];
///FFF
return min;
}
// retourne le maximum d'un matrice
// carrée de NxN élément
float max2(int size, float mat[size][size]) {
int i,j;
float m=0.0; // corrige MINFLOAT
for(i=0;i<size;i++)
for(j=0;j<size;j++){
if(mat[i][j]>m)
m=mat[i][j];
}
return m;
}
int main(int argc, char *argv[]) {
///CCC
int vecteur[N]={0,1,2,3,4,5,6,7,8,9};
int i;
int sum=0;
for(i=0;i<N; i++) {
sum+=vecteur[i];
}
///DDD
return(EXIT_SUCCESS);
}
_static/src/C/S2-src/arrayvar.c 0 → 100644
+ 46
− 0
Voir le fichier @ 9e42200e
/***********************************************
* arrayvar.c
*
* Programme d'exemple d'utilisation de tableaux
* de taille non prédéfinie à la compilation
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define N 10
void init(int size, int v[]) {
int i;
for(i=0;i<size;i++)
v[i]=1;
}
int main(int argc, char *argv[]) {
/*
int size;
int vecteur[];
int i;
if(argc!=1) {
fprintf(stderr, "Usage : arrayvar n avec n entier\n");
return(EXIT_FAILURE);
}
size=atoi(argv[1]);
*/
///CCC
int vecteur[N]={0,1,2,3,4,5,6,7,8,9};
int i;
int sum=0;
for(i=0;i<N; i++) {
sum+=vecteur[i];
}
///DDD
return(EXIT_SUCCESS);
}
_static/src/C/S2-src/char-addr.c 0 → 100644
+ 27
− 0
Voir le fichier @ 9e42200e
/***********************************************
* charaddr.c
*
* Pointeurs et chaînes de caractères
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
///BBB
int main(int argc, char *argv[]) {
///AAA
int i;
char name1[] = "str";
// char name2[] = "SINF1252";
for(i=0;i<10;i++) {
printf("%c",name1[i]);
}
return(EXIT_SUCCESS);
}
_static/src/C/S2-src/char.c 0 → 100644
+ 36
− 0
Voir le fichier @ 9e42200e
/***********************************************
* strlen.c
*
* Initialisation de chaînes de caractères
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
///AAA
int length(char str[]) {
int i=0;
while(str[i]!=0) { // '\0' et 0 sont égaux
i++;
}
return(i);
}
///BBB
int main(int argc, char *argv[]) {
int i;
char name1[] = "str";
// char name2[] = "SINF1252";
printf("Longueur de name1 [%s] : %d\n",name1,length(name1));
for(i=0;i<10;i++) {
printf("%c",name1[i]);
}
return(EXIT_SUCCESS);
}
_static/src/C/S2-src/exprbin.c 0 → 100644
+ 104
− 0
Voir le fichier @ 9e42200e
/***********************************************
* exprbin.c
*
* Programme d'exemple d'utilisation d'expressions
* binaires
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <stdlib.h>
#define BITS_CHAR 8
///EEE
#define BITS_INT 32
// str[BITS_INT]
void int2bin(unsigned int num, char *str)
{
int i;
str[BITS_INT] = '\0';
for (i = BITS_INT - 1; i >= 0; i--) {
if ((num & 1) == 1)
str[i] = '1';
else
str[i] = '0';
num = num >> 1;
}
}
///FFF
// str[32]
void char2bin(unsigned char num, char *str)
{
int i;
str[BITS_CHAR]='\0';
for(i=BITS_CHAR-1; i>=0; i--) {
if( (num & 1)==1)
str[i]='1';
else
str[i]='0';
num = num >> 1;
}
}
int main(int argc, char *argv[]) {
unsigned char zero='\0'; ///EEE
unsigned char a=0xFA;
unsigned char b=0x5F;
unsigned char c=0x50;
unsigned char d=0x50;
unsigned char r;
unsigned int i1,i2,i3;
i1=0;
i2=0x4;
i3=0x5;
char str1[32];
char str2[32];
char str3[32];
char2bin(zero,str1);
char2bin(~zero,str2);
printf("~ %s = %s\n",str1,str2);
char2bin(a,str1);
char2bin(b,str2);
char2bin(a&b,str3);
printf("%s & %s = %s\n",str1,str2,str3);
char2bin(a,str1);
char2bin(b,str2);
char2bin(a|b,str3);
printf("%s | %s = %s\n",str1,str2,str3);
char2bin(a^b,str3);
printf("%s ^ %s = %s\n",str1,str2,str3);
///AAA
r = ~a; // négation bit à bit
r = a & b; // conjonction bit à bit
r = a | b; // disjonction bit à bit
r = a ^ b; // xor bit à bit
///BBB
///CCC
r = c & 0x7E; // 0b01111110 force les bits de poids faible et fort à 0
r = d | 0x18; // 0b00011000 force les bits 4 et 3 à 1
///DDD
/*
printf("0x%x & 0x%x = 0x%x\n",i2,i3,i2 & i3);
printf("0x%x && 0x%x = 0x%8x\n",i2,i3,i2 && i3);
printf("0x%x | 0x%x = 0x%8x\n",i2,i3,i2 | i3);
printf("0x%x || 0x%x = 0x%8x\n",i2,i3,i2 || i3);
*/
return(EXIT_SUCCESS);
}
_static/src/C/S2-src/exprbin.out 0 → 100644
+ 4
− 0
Voir le fichier @ 9e42200e
~ 00000000 = 11111111
11111010 & 01011111 = 01011010
11111010 | 01011111 = 11111111
11111010 ^ 01011111 = 10100101
_static/src/C/S2-src/fct.c 0 → 100644
+ 79
− 0
Voir le fichier @ 9e42200e
/***********************************************
* fct.c
*
* Programme d'exemple d'utilisation de fonctions
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
///AAA
void usage()
{
printf("Usage : ...\n");
}
///BBB
///CCC
int twotimes(int n)
{
return 2 * n;
}
int two_times(int n)
{
n = 2 * n;
return n;
}
///DDD
///EEE
int times_two(int *n)
{
return (*n) + (*n);
}
int timestwo(int *n)
{
*n = (*n) + (*n);
return *n;
}
void f()
{
int i = 1252;
printf("i:%d\n", i);
printf("times_two(&i)=%d\n", times_two(&i));
printf("après times_two, i:%d\n", i);
printf("timestwo(&i)=%d\n", timestwo(&i));
printf("après timestwo, i:%d\n", i);
}
///FFF
void plusun(int size, int *v) {
int i;
for(i=0;i<size;i++)
v[i]++;
}
///GGG
int main(int argc, char *argv[]) {
int i=1252;
int j;
f();
return(EXIT_SUCCESS);
}
_static/src/C/S2-src/fct.h 0 → 100644
+ 11
− 0
Voir le fichier @ 9e42200e
/***********************************************
* fct.h
*
* Exemple de signatures de fonctions
*
***********************************************/
///HHH
int times_two(int *);
int timestwo(int *);
///III
_static/src/C/S2-src/fct.out 0 → 100644
+ 5
− 0
Voir le fichier @ 9e42200e
i:1252
times_two(&i)=2504
après times_two, i:1252
timestwo(&i)=2504
après timestwo, i:2504
_static/src/C/S2-src/fctargs.c 0 → 100644
+ 65
− 0
Voir le fichier @ 9e42200e
/***********************************************
* fctargs.c
*
* Programme d'exemple d'utilisation de fonctions
* montre l'importance de traiter les arguments en
* ordre
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define N 5
///AAA
int length(char c[]) {
int i=0;
while(c[i]!='\0')
i++;
return (i);
}
///BBB
///CCC
void plusun(int size, int *v)
{
int i;
for (i = 0; i < size; i++)
v[i]++;
}
void print_vecteur(int size, int*v) {
int i;
printf("v={");
for (i = 0;i < size - 1; i++)
printf("%d,", v[i]);
if (size > 0)
printf("%d}", v[size - 1]);
else
printf("}");
}
///DDD
void wrong() {
int vecteur[N]={1,2,3,4,5};
/// provoque un segmentation fault
///GGG
plusun(vecteur,N);
print_vecteur(N,vecteur);
///HHH
}
int main(int argc, char *argv[]) {
///EEE
int vecteur[N] = {1, 2, 3, 4, 5};
plusun(N, vecteur);
print_vecteur(N, vecteur);
///FFF
return EXIT_SUCCESS;
}
_static/src/C/S2-src/foobar.c 0 → 100644
+ 25
− 0
Voir le fichier @ 9e42200e
/***********************************************
* foobar.c
*
* Exercice
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
void foo(void) {
int a = 42;
printf("%d\n", a);
}
void bar(void) {
// cppcheck-suppress uninitvar ;
int a;
printf("%d\n", a);
}
// cppcheck-suppress uninitvar //
int main(int argc, char *argv[]) {
foo();
bar();
return(EXIT_SUCCESS);
}
_static/src/C/S2-src/int2bin.c 0 → 100644
+ 36
− 0
Voir le fichier @ 9e42200e
/**********************************************
* int2bin
*
* Conversion d'entier non signé en binaire
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 33 // nombre maximum de bits+1
void print_bin(int num) {
int i;
int n=num;
char str[MAXSIZE];
i=MAXSIZE;
while (--i>=0) {
str[i] = n & 1 ? '1' : '0';
n >>= 1;
}
printf("La valeur de %d en hexadécimal est %x et en binaire : %s\n",num,num,str);
}
int main(int argc, char *argv[]) {
int n=7654321;
print_bin(n);
print_bin(123);
print_bin(987654321);
return(EXIT_SUCCESS);
}
// inspiré de http://stackoverflow.com/questions/111928/is-there-a-printf-converter-to-print-in-binary-format
_static/src/C/S2-src/num.c 0 → 100644
+ 24
− 0
Voir le fichier @ 9e42200e
/***********************************************
* num
*
* Déclaration de nombres
*
***********************************************/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
///AAA
int i;
i = 123; // décimal
i = 0x7b; // hexadécimal
i = 0173; // octal !!
// i = 0b1111011; // binaire, seulement certains compilateurs
///BBB
return EXIT_SUCCESS;
}
0% ou .
You are about to add 0 people to the discussion. Proceed with caution.
Terminez d'abord l'édition de ce message.
Veuillez vous inscrire ou vous pour commenter