Atelier programmation C
Série révision
LCE1 2020 -2021
A. Chafroud
Notions de :
* Pointeurs
* Allocation dynamique
* Structures
* Enumération
Notions de :
* Pointeurs
* Allocation dynamique
* Structures
* Enumération
* Pointeurs
A == *P P == &A
A == *&A et P == &*P
* Pointeurs
Parenthèses
obligatoires sans quoi, cela donne lieu à un accès non autorisé.
* Pointeurs
A B C P1 P2
int A = 1 , B = 2 , C = 3 ;
int *P1 , *P2 ;
P1 = &A ;
P2 = &C ;
*P1 = (*P2)++ ;
P1 = P2 ;
P2 = &B ;
*P1 - = *P2 ;
++*P2 ;
*P1* = *P2 ;
A = *P2**P1 ;
P1 = &A ;
*P2/ = *P1 ;
* Pointeurs
A B C P1 P2
int A = 1 , B = 2 , C = 3 ;
1 2 3 / /
int *P1 , *P2 ;
P1 = &A ;
P2 = &C ;
*P1 = (*P2)++ ;
P1 = P2 ;
P2 = &B ;
*P1 - = *P2 ;
++*P2 ;
*P1* = *P2 ;
A = *P2**P1 ;
P1 = &A ;
*P2/ = *P1 ;
* Pointeurs
A B C P1 P2
int A = 1 , B = 2 , C = 3 ;
1 2 3 / /
int *P1 , *P2 ;
P1 = &A ; 1 2 3 &A /
P2 = &C ;
*P1 = (*P2)++ ;
P1 = P2 ;
P2 = &B ;
*P1 - = *P2 ;
++*P2 ;
*P1* = *P2 ;
A = *P2**P1 ;
P1 = &A ;
*P2/ = *P1 ;
* Pointeurs
A B C P1 P2
int A = 1 , B = 2 , C = 3 ;
1 2 3 / /
int *P1 , *P2 ;
P1 = &A ; 1 2 3 &A /
P2 = &C ; 1 2 3 &A &C
*P1 = (*P2)++ ;
P1 = P2 ;
P2 = &B ;
*P1 - = *P2 ;
++*P2 ;
*P1* = *P2 ;
A = *P2**P1 ;
P1 = &A ;
*P2/ = *P1 ;
* Pointeurs
Pointeurs et tableaux
* Pointeurs
Notions de :
* Pointeurs
* Allocation dynamique
* Structures
* Enumération
* Allocation dynamique
void *malloc(size_t taille);
Exemple : inverser les lignes d’un texte
* Allocation dynamique
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main()
{
/* Déclarations */
char INTRO[500]; /* chaîne pour l'introduction des données
*/
char *TEXTE[10]; /* Tableau des pointeurs sur les 10 chaînes */
char *PAIDE; /* pointeur d'aide pour l'échange des pointeurs */
int I,J; /* indices courants */
/* Saisie des données et allocation dynamique de mémoire */
puts("Introduire 3 phrases terminées chaque fois"
" par un retour à la ligne :");
* Allocation dynamique
for (I=0; I<3; I++)
{
/* Lecture d'une phrase */
printf("Phrase %d : ",I);
gets(INTRO);
/* Réservation de la mémoire */
TEXTE[I] = malloc(strlen(INTRO)+1);
/* S'il y a assez de mémoire, ... */
if (TEXTE[I])
/* copier la phrase à l'adresse */
/* fournie par malloc, */
strcpy(TEXTE[I], INTRO);
else
{
/* sinon afficher un message d'erreur */
printf("\aPas assez de mémoire \n");
/* et quitter le programme. */
exit(-1);
}
}
* Allocation dynamique
/* Afficher le tableau donné */
puts("Contenu du tableau donne :");
for (I=0; I<3; I++)
puts(TEXTE[I]);
/* Inverser l'ordre des phrases avec le pointeur PAIDE */
for (I=0,J=2 ; I<J ; I++,J--)
{
PAIDE = TEXTE[I];
TEXTE[I] = TEXTE[J];
TEXTE[J] = PAIDE;
}
/* Afficher le tableau résultat */
puts("Contenu du tableau resultat :");
for (I=0; I<3; I++)
puts(TEXTE[I]);
return 0;
}
Notions de :
* Pointeurs
* Allocation dynamique
* Structures
* Enumération
* Structures
Un tableau est une variable composée de
données de même type, stockées de manière
contiguë en mémoire (les unes à la suite des
autres).
donnée donnée donnée ... donnée
Une structure est une variable composée de
données de types hétérogènes, stockées en
mémoire les unes derrière les autres.
donnée donnée ... donnée
(type 1) (type 2) (type n)
* Structures
Déclaration d’un type de structure nommée
toto.
struct toto {
int val;
char f;
int tab[];
};
- sizeof (toto) renverra la place mémoire
nécessaire à une variable de type
« struct toto ».
* Structures
Un nombre complexe est défini par une partie réelle et
une partie imaginaire (z=x + j y).
1. Déclarer une structure COMPLEXE.
2. Ecrire une fonction SaisiComplexe permettant de
lire la partie réelle et la partie imaginaire d’un
nombre complexe.
3. Ecrire une fonction SommeCompexe permettant de
calculer la somme de deux nombres complexes.
4. Ecrire une fonction ProduitCompexe permettant de
calculer le produit de deux nombres complexes.
5. Dans la fonction main, étant donnée deux nombres
complexes Z1 et Z2 saisis au clavier, calculer et
afficher le nombre Z3 tel que Z3 = Z1 + Z2, et le
nombre Z4 tel que Z4 = Z1*Z2.
* Structures
Un nombre complexe est défini par une partie réelle et
une partie imaginaire (z=x + j y).
1. Déclarer une structure COMPLEXE.
2. Ecrire une fonction SaisiComplexe permettant de
lire la partie réelle et la partie imaginaire d’un
nombre complexe.
3. Ecrire une fonction SommeCompexe permettant de
calculer la somme de deux nombres complexes.
4. Ecrire une fonction ProduitCompexe permettant de
calculer le produit de deux nombres complexes.
5. Dans la fonction main, étant donnée deux nombres
complexes Z1 et Z2 saisis au clavier, calculer et
afficher le nombre Z3 tel que Z3 = Z1 + Z2, et le
nombre Z4 tel que Z4 = Z1*Z2.
* Structures
1. Déclarer une structure COMPLEXE.
struct Complexe
{ float reel ; //partie réelle
float img ; // partie imaginaire
};
* Structures
Un nombre complexe est défini par une partie réelle et
une partie imaginaire (z=x + j y).
1. Déclarer une structure COMPLEXE.
2. Ecrire une fonction SaisiComplexe permettant de
lire la partie réelle et la partie imaginaire d’un
nombre complexe.
3. Ecrire une fonction SommeCompexe permettant de
calculer la somme de deux nombres complexes.
4. Ecrire une fonction ProduitCompexe permettant de
calculer le produit de deux nombres complexes.
5. Dans la fonction main, étant donnée deux nombres
complexes Z1 et Z2 saisis au clavier, calculer et
afficher le nombre Z3 tel que Z3 = Z1 + Z2, et le
nombre Z4 tel que Z4 = Z1*Z2.
* Structures
2. Ecrire une fonction SaisiComplexe
permettant de lire la partie réelle et la
partie imaginaire d’un nombre complexe.
void SaisirComplexe(struct Complexe *C)
{ printf("\n Donner la partie réelle : ") ;
scanf("%f",&(*C).reel) ;
printf("\n Donner la partie imaginaire : ") ;
scanf("%f",&(*C).img) ;
}
* Structures
Un nombre complexe est défini par une partie réelle et
une partie imaginaire (z=x + j y).
1. Déclarer une structure COMPLEXE.
2. Ecrire une fonction SaisiComplexe permettant de
lire la partie réelle et la partie imaginaire d’un
nombre complexe.
3. Ecrire une fonction SommeCompexe permettant de
calculer la somme de deux nombres complexes.
4. Ecrire une fonction ProduitCompexe permettant de
calculer le produit de deux nombres complexes.
5. Dans la fonction main, étant donnée deux nombres
complexes Z1 et Z2 saisis au clavier, calculer et
afficher le nombre Z3 tel que Z3 = Z1 + Z2, et le
nombre Z4 tel que Z4 = Z1*Z2.
* Structures
3. Ecrire une fonction SommeCompexe
permettant de calculer la somme de deux
nombres complexes.
struct Complexe SommeComplexe(struct
Complexe C1,struct Complexe C2)
{ struct Complexe CS ;
[Link] = [Link]+ [Link] ;
[Link] = [Link] + [Link] ;
return CS ;
}
* Structures
Un nombre complexe est défini par une partie réelle et
une partie imaginaire (z=x + j y).
1. Déclarer une structure COMPLEXE.
2. Ecrire une fonction SaisiComplexe permettant de
lire la partie réelle et la partie imaginaire d’un
nombre complexe.
3. Ecrire une fonction SommeCompexe permettant de
calculer la somme de deux nombres complexes.
4. Ecrire une fonction ProduitCompexe permettant de
calculer le produit de deux nombres complexes.
5. Dans la fonction main, étant donnée deux nombres
complexes Z1 et Z2 saisis au clavier, calculer et
afficher le nombre Z3 tel que Z3 = Z1 + Z2, et le
nombre Z4 tel que Z4 = Z1*Z2.
* Structures
4. Ecrire une fonction ProduitCompexe
permettant de calculer le produit de deux
nombres complexes.
struct Complexe ProduitComplexe(struct
Complexe C1,struct Complexe C2)
{ struct Complexe CP ;
[Link] = [Link] * [Link] ;
[Link] = [Link] * [Link] ;
return CP ;
}
* Structures
Un nombre complexe est défini par une partie réelle et
une partie imaginaire (z=x + j y).
1. Déclarer une structure COMPLEXE.
2. Ecrire une fonction SaisiComplexe permettant de
lire la partie réelle et la partie imaginaire d’un
nombre complexe.
3. Ecrire une fonction SommeCompexe permettant de
calculer la somme de deux nombres complexes.
4. Ecrire une fonction ProduitCompexe permettant de
calculer le produit de deux nombres complexes.
5. Dans la fonction main, étant donnée deux nombres
complexes Z1 et Z2 saisis au clavier, calculer et
afficher le nombre Z3 tel que Z3 = Z1 + Z2, et le
nombre Z4 tel que Z4 = Z1*Z2.
* Structures
5. Dans la fonction main, étant donnée deux nombres
complexes Z1 et Z2 saisis au clavier, calculer et afficher le
nombre Z3 tel que Z3 = Z1 + Z2, et le nombre Z4 tel que
Z4 = Z1*Z2.
main()
{ struct Complexe Z1, Z2, Z3, Z4 ;
SaisirComplexe(&Z1) ;
SaisirComplexe(&Z2) ;
Z3 = SommeComplexe(Z1, Z2) ;
Z4 = ProduitComplexe(Z1, Z2) ;
printf("\n Z1 + Z2 = %f + %f *i ", [Link], [Link]) ;
printf("\n Z1 * Z2 = %f + %f *i ", [Link], [Link]) ;
}
Notions de :
* Pointeurs
* Allocation dynamique
* Structures
* Enumération
* Enumération
#include<stdio.h>
enum week{Mon=10, Tue, Wed, Thur, Fri=10, Sat=16, Sun};
int main() {
printf("The value of enum week: %d %d %d %d
%d %d %d \n",Mon , Tue, Wed, Thur, Fri, Sat,
Sun);
return 0;
}
* Enumération
Merci pour votre attention !
Des questions ?
