John Samuel
CPE Lyon
Année: 2026-2027
Courriel: john(dot)samuel(at)cpe(dot)fr
L'architecture d'une machine influence la programmation en C en déterminant les détails de la gestion de la mémoire, la taille des types de données, l'ordre d'exécution des instructions (gestion des threads sur un processeur multicœur), et d'autres caractéristiques matérielles (par exemple, la taille des registres), ce qui peut nécessiter des ajustements spécifiques lors de la rédaction de code pour différentes plateformes matérielles.
Le nombre de bits dans une architecture détermine sa capacité à adresser et à gérer la mémoire, ce qui est essentiel pour la performance et la capacité des systèmes informatiques.
La capacité de la mémoire vive (RAM) d'un ordinateur est de 4 Go, 8 Go, 16 Go, etc., et elle détermine la quantité de données que l'ordinateur peut stocker temporairement pour un traitement rapide.
Dans une représentation binaire sur 8 bits (octet)
Dans une représentation binaire sur 16 bits
L'ordre d'organisation des octets en mémoire.
Remarque: Dans ce cours, nous utilisons la convention petit-boutiste.
char c = 'a';
char *my_char_addr = &c;
my_char_addr = 0xab71
short s = 0xa478;
short *my_short_addr = &s;
Ce code initialise une variable short s avec la valeur hexadécimale 0xa478, puis crée un pointeur my_short_addr qui référence l'adresse mémoire de s.
Remarque:
my_short_addr = 0xab71.
int i = 0xa47865ff;
int *my_int_addr = &i;
Ce code initialise une variable int i avec la valeur hexadécimale 0xa47865ff, puis crée un pointeur my_int_addr qui référence l'adresse mémoire de i.
Remarque: my_int_addr = 0xab71
long int li = 0xa47865ff;
long int *my_long_int_addr = &li;
Ce code initialise une variable long int li avec la valeur hexadécimale 0xa47865ff, puis crée un pointeur my_long_int_addr qui référence l'adresse mémoire de li.
Remarque: my_long_int_addr = 0xab71
float (32-bit)
double (64-bit)
Remarque: IEEE 754
float f = 2;
float *my_float_addr = &f;
Remarque: my_float_addr = 0xab71
float f = 1;
float *my_float_addr = &f;
Remarque: my_float_addr = 0xab71
double d = 2;
double *my_double_addr = &d;
Remarque: my_double_addr = 0xab71
double d = 1;
double *my_double_addr = &d;
Remarque: my_double_addr = 0xab71
Un tableau est un ensemble d'éléments homogènes.
char
a[8]
= {0xff,0x65,0x78,
0xa4,0x0,0x0,0x0,0x0};
char
*ptr
= &a[0];
L'opérateur d'addition sur les pointeurs est utilisé pour déplacer un pointeur vers une autre adresse mémoire en fonction du type de données auquel il pointe.
char
a[8]
= {0xff,0x65,0x78,
0xa4,0x0,0x0,0x0,0x0};
char
*ptr
= &a[0];
ptr
= ptr + 1;
char
a[8]
= {0xff,0x65,0x78,
0xa4,0x0,0x0,0x0,0x0};
char
*ptr
= &a[0];
ptr
= ptr + 1;
L'opérateur d'addition sur les pointeurs est utilisé pour déplacer un pointeur vers une autre adresse mémoire en fonction du type de données auquel il pointe.
short
s[4]
= {0x65ff,0xa478};
short
*sptr
= &s[0];
Remarque: Observez bien la position de sptr.
Remarque: Observez bien la position de sptr.
short
s[4]
= {0x65ff,0xa478};
short
*sptr
= &s[0];
sptr
= sptr + 1;
est un ensemble d'éléments homogènes
strcat concatene deux chaines de caractères strncat concatene deux chaines de caractères avec
une
taille maximum donnée par l'utilisateur.strcpy copie une chaîne de caractères dans une autrestrncpy copie au plus n caractères.
Attention : si la source est plus longue que n, le
résultat n'est pas terminé par '\0' — ce n'est donc pas une version sûre
de strcpy. Préférez snprintf.strcmp compare deux chaines de caractèresstrncmp compare deux chaines de caractères avec une
taille maximum donnée par l'utilisateur
/* Fichier: string3.c
* manipulation d'une chaine de caractères.
*/
#include
<stdio.h> // en-têtes(headers)
#include
<string.h>
int main(int argc, char ** argv)
{
char message[]= {"Bonjour"}, nom[]= {"John"}, string[20] = "";
strncat(string, message, 19);
strcat(string, " ");
strncat(string, nom, 19);
printf("%s\n", string);
return 0;
}
/* Fichier: string4.c
* manipulation d'une chaine de caractères.
* auteur: John Samuel
*/
#include
<stdio.h> // en-têtes(headers)
#include
<string.h>
int main(int argc, char ** argv)
{
char message[]= {"Bonjour"}, nom[]= {"John"}, string[20] = "";
strncpy(string, message, 19);
strcpy(string, " ");
strncpy(string, nom, 19);
printf("%s\n", string);
return 0;
}
$ gcc -o strncat string3.c
$ gcc -o strncpy string4.c
$./strncat
Bonjour John
$./strncpy
John
/* Fichier: file.c
* Lecture d'un fichier
*/
#include
<stdio.h> // en-têtes(headers)
#include
<sys/types.h>
#include
<sys/stat.h>
#include
<fcntl.h>
#include
<unistd.h>
int main(int argc, char ** argv)
{
char content[1000];
int fd, count, size;
fd = open ("./file.c", O_RDONLY);
if (fd == -1) return 1; // open peut échouer
size = read(fd, content, 1000);
for (count = 0; count < size; count ++) {
printf("%c", content[count]);
}
close(fd);
return 0;
}
/* Fichier: file.c
* Lecture d'un fichier
*/
#include
<stdio.h> // en-têtes(headers)
#include
<sys/types.h>
#include
<sys/stat.h>
#include
<fcntl.h>
#include
<unistd.h>
int main(int argc, char ** argv)
{
char content;
int fd, count, size;
fd = open ("./file.c", O_RDONLY);
if (fd == -1) return 1; // open peut échouer
while (1) {
size = read(fd, &content, 1);
if (size < 1) {
break;
}
printf("%c", content);
}
close(fd);
return 0;
}
/* Fichier: file.c
* Écriture dans un fichier (écrasement du contenu)
* auteur: John Samuel
*/
#include
<stdio.h> // en-têtes(headers)
#include
<sys/types.h>
#include
<sys/stat.h>
#include
<fcntl.h>
#include
<unistd.h>
int main(int argc, char ** argv)
{
char content[] = "Bonjour";
int fd, count, size;
fd = open ("./message.txt", O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR);
if (fd == -1) return 1; // open peut échouer
size = write(fd, content, sizeof(content));
close(fd);
return 0;
}
Écrivez une structure pour la répresentation d'une couleur RGB
(rouge, vert, bleu: chaque couleur prend un octet) en utilisant union et struct.
