therbron/Etudes
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test

Browse Source
This commit is contained in:
Tanguy Herbron 2016-10-14 17:08:58 +02:00
parent 4e6335c243
commit ee70b933a0
149 changed files with 0 additions and 9438 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
C/Deuxieme annee/bonhommeFork.c
View File

@ -1,61 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
//Les variables testFourchetteX correspondent aux fourchette de séparation d'un processus.
int main()
{
int testFourchette1, testFourchette2, testFourchette3, testFourchette4, testFourchette5, testFourchette6;
testFourchette1 = fork();
if(testFourchette1 == 0) //Je suis P3, l'enfant de P1
{
boite("Boite 3");
testFourchette2 = fork();
if(testFourchette2 == 0) //Je suis P2, l'enfant de P3
{
boite("Boite 2");
}
else //Je suis P3
{
testFourchette3 = fork();
if(testFourchette3 == 0) //Je suis P4, l'enfant de P3
{
boite("Boite 4");
}
else //Je suis P3, l'enfant de P1
{
testFourchette4 = fork();
if(testFourchette4 == 0) //Je suis P5, l'enfant de P3
{
boite("Boite 5");
testFourchette5 = fork();
if(testFourchette5 == 0) //Je suis P6, l'enfant de P5
{
boite("Boite 6");
}
else //Je suis P5, l'enfant de P3
{
testFourchette6 = fork();
if(testFourchette6 == 0) //Je suis P7, l'enfant de P5
{
boite("Boite 7");
}
else //Je suis P5, l'enfant de P3
{
boite("Boite 5");
}
}
}
else //Je suis P3, l'enfant de P1
{
boite("Boite 3");
}
}
}
}
else //Je suis P1
{
boite("Boite 1");
}
return EXIT_SUCCESS;
}

110
C/Deuxieme annee/chatSocketSelectServer.c
View File

@ -1,110 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <unistd.h>
#define BACKLOG 5
#define MAX 512
int main()
{
fd_set rfds;
struct timeval tv;
struct sockaddr_in infoServer;
struct sockaddr_in retourServer;
socklen_t tailleInfoServ;
int retourSocket;
int retourBind;
int retourListen;
int retourAccept;
int retourRead;
int retourWrite;
char msg[MAX];
infoServer.sin_family = AF_INET;
infoServer.sin_addr.s_addr = htonl(INADDR_ANY);
infoServer.sin_port = htons(3434);
retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if(retourSocket == -1)
{
printf("Erreur socket\n");
printf("%s", strerror(errno));
exit(errno);
}
retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer));
if(retourBind == -1)
{
printf("Erreur bind\n");
printf("%s", strerror(errno));
exit(errno);
}
retourListen = listen(retourSocket, BACKLOG);
if(retourListen == -1)
{
printf("Erreur listen\n");
printf("%s", strerror(errno));
exit(errno);
}
printf("Attente d'une connexion.\n\n");
tailleInfoServ = sizeof(retourServer);
retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleInfoServ);
if(retourAccept == -1)
{
printf("Erreur accept\n");
printf("%s", strerror(errno));
exit(errno);
}
while(1)
{
FD_ZERO(&rfds);
FD_SET(0, &rfds);
tv.tv_sec = 5;
tv.tv_usec = 0;
printf("Attente d'un nouveau message...\n\n");
if(select(retourSocket+1, &rfds, NULL, NULL, &tv))
{
retourRead = read(retourAccept, &msg, sizeof(msg));
if(retourRead == -1)
{
printf("Erreur read\n");
printf("%s", strerror(errno));
exit(errno);
}
printf("Nouveau message \n");
printf("IP : %s:%d: %s\n\n", inet_ntoa(retourServer.sin_addr), ntohs(retourServer.sin_port), msg);
}
printf("Message : ");
gets(msg);
printf("\n\n");
retourWrite = write(retourAccept, &msg, sizeof(msg));
if(retourWrite == -1)
{
printf("Erreur write\n");
printf("%s", strerror(errno));
exit(errno);
}
}
close(retourAccept);
return 0;
}

39
C/Deuxieme annee/fileMessageP1/main.c
View File

@ -1,39 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>
#include "zone.h"
#include <unistd.h>
#include <time.h>
float randomF()
{
return ((float)100.0*(rand()/(RAND_MAX+0.1)));
}
int main()
{
int i;
zone maZoneMemoire;
key_t clef;
int msqid;
clef = ftok("/tmp/bidon", 5678);
msqid = msgget(clef, 0666 | IPC_CREAT);
if(msqid == -1)
{
printf("Erreur creation file message : %s\n", strerror(errno));
}
while(1)
{
maZoneMemoire.type = randomF();
msgsnd(msqid, (struct msgbuf *) &maZoneMemoire, sizeof(maZoneMemoire), 0);
printf("Nouveau message envoye.\n");
usleep(99999);
}
}

9
C/Deuxieme annee/fileMessageP1/zone.h
View File

@ -1,9 +0,0 @@
#ifndef ZONE_H_INCLUDED
#define ZONE_H_INCLUDED
typedef struct donnees{
long type;
char texte;
}zone;
#endif // ZONE_H_INCLUDED

39
C/Deuxieme annee/fileMessageP2/main.c
View File

@ -1,39 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>
#include "zone.h"
#include <unistd.h>
#include <time.h>
float randomC()
{
return ((char)('A'+((char)(25.0*(rand()/(RAND_MAX+0.1))))));
}
int main()
{
int i;
zone maZoneMemoire;
key_t clef;
int msqid;
clef = ftok("/tmp/bidon", 5678);
msqid = msgget(clef, 0666 | IPC_CREAT);
if(msqid == -1)
{
printf("Erreur creation file message : %s\n", strerror(errno));
}
while(1)
{
maZoneMemoire.texte = (char)randomC();
msgsnd(msqid, (struct msgbuf *) &maZoneMemoire, sizeof(maZoneMemoire), 0);
printf("Nouveau message envoye.\n");
usleep(99999);
}
}

9
C/Deuxieme annee/fileMessageP2/zone.h
View File

@ -1,9 +0,0 @@
#ifndef ZONE_H_INCLUDED
#define ZONE_H_INCLUDED
typedef struct donnees{
long type;
char texte;
}zone;
#endif // ZONE_H_INCLUDED

35
C/Deuxieme annee/fileMessageP3/main.c
View File

@ -1,35 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>
#include "zone.h"
#include <unistd.h>
#include <string.h>
int main()
{
zone maZoneMemoire;
key_t clef;
int msqid;
clef = ftok("/tmp/bidon", 5678);
msqid = msgget(clef, 0600 | IPC_CREAT);
if(msqid == -1)
{
printf("Erreur creation file message : %s\n", strerror(errno));
}
while(1)
{
msgrcv(msqid, (struct msgbuf *) &maZoneMemoire, sizeof(maZoneMemoire), 0, 0);
printf("%ul %c\n", maZoneMemoire.type, maZoneMemoire.texte);
usleep(99999);
}
return 0;
}

9
C/Deuxieme annee/fileMessageP3/zone.h
View File

@ -1,9 +0,0 @@
#ifndef ZONE_H_INCLUDED
#define ZONE_H_INCLUDED
typedef struct donnees{
long type;
char texte;
}zone;
#endif // ZONE_H_INCLUDED

26
C/Deuxieme annee/forkElevesTP.c
View File

@ -1,26 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main ( int argc, char *argv[] )
{
int pid1,pid2;
pid1 = fork();
if ( pid1 == 0 )
{
boite("boite1","pid1=0");
pid2 = fork();
if ( pid2 == 0 )
{
boite("boite2","pid2=0");
}
else
{
boite("boite3","pid2<>0");
}
}
else
{
boite("boite4","pid1<>0");
}
return EXIT_SUCCESS;
}

8
C/Deuxieme annee/jeparleagrandpere.c
View File

@ -1,8 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("Hello world!\n");
return 0;
}

48
C/Deuxieme annee/memShareP1.c
View File

@ -1,48 +0,0 @@
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
typedef struct {
float temp;
int press;
char ordre;
}uneStruct;
float randomF(){
return ((float)100.0*(rand()/(RAND_MAX+0.1)));
}
int randomI(){
return ((int)100.0*(rand()/(RAND_MAX+0.1)));
}
int main()
{
uneStruct *memShare;
int shmid;
key_t clef;
void *shm;
clef = ftok("/tmp/bidon", 1234);
shmid = shmget(clef, sizeof(uneStruct), 0666);
if(shmid < 0)
{
perror("Erreur shmget");
exit(EXIT_FAILURE);
}
memShare = shmat(shmid, NULL, 0);
while(1)
{
memShare->press = randomI();
memShare->temp = randomF();
printf("Memoire mise a jour.\nVal->\n\tpress : %d, temp : %f\n\n", memShare->press, memShare->temp);
usleep(999999);
}
}

43
C/Deuxieme annee/memShareP2.c
View File

@ -1,43 +0,0 @@
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
typedef struct {
float temp;
int press;
char ordre;
}uneStruct;
char randomC(){
return ((char)126.0*(rand()/(RAND_MAX+0.1)));
}
int main()
{
uneStruct *memShare;
int shmid;
key_t clef;
void *shm;
clef = ftok("/tmp/bidon", 1234);
shmid = shmget(clef, sizeof(uneStruct), 0666);
if(shmid < 0)
{
perror("Erreur shmget");
exit(EXIT_FAILURE);
}
memShare = shmat(shmid, NULL, 0);
while(1)
{
memShare->ordre = randomC();
printf("Memoire mise a jour.\nVal->\n\tordre : %c\n\n", memShare->ordre);
usleep(999999);
}
}

36
C/Deuxieme annee/memShareP3.c
View File

@ -1,36 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
typedef struct {
float temp;
int press;
char ordre;
}uneStruct;
int main()
{
int shmid, loop = 0;
char *shm;
uneStruct *sharedStruct;
key_t clef;
clef = ftok("/tmp/bidon", 1234);
shmid = shmget(clef, sizeof(uneStruct), IPC_CREAT | 0666);
if(shmid < 0)
{
perror("Erreur shmget");
exit(EXIT_FAILURE);
}
sharedStruct = shmat(shmid, NULL, 0);
while(1)
{
loop++;
printf("Loop %d\t|%d\t|%f\t| %c\n", loop, sharedStruct->temp, sharedStruct->press, sharedStruct->ordre);
usleep(999999);
}
return 0;
}

47
C/Deuxieme annee/popen.c
View File

@ -1,47 +0,0 @@
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define BUFSIZ 255
int main()
{
int nbOctets;
int descTube[2];
int descTube2[2];
char chaine[] = "Salut papa!";
char buffer[BUFSIZ];
pid_t pid;
memset(buffer, '\0', BUFSIZ);
if ( pipe(descTube) == 0 && pipe(descTube2) == 0)
{
pid = fork(); // duplication du processus
if (pid == -1) // oups un probleme
{
fprintf(stderr, "Pb de fork");
exit(EXIT_FAILURE);
}
else // fork ok
{
if (pid == 0) // je suis dans le process fils
{
nbOctets = read(descTube[0], buffer, BUFSIZ);
nbOctets = write(descTube2[1], chaine, strlen(chaine));
printf("%d octets ecrits\n", nbOctets);
printf("octets lus: %d: %s\n", nbOctets, buffer);
exit(EXIT_SUCCESS);
}
else //je suis dans le process pere
{
strcpy(chaine, "test");
nbOctets = write(descTube[1], chaine, strlen(chaine));
nbOctets = read(descTube2[0], buffer, BUFSIZ);
printf("%d octets ecrits\n", nbOctets);
printf("octets lus: %d: %s\n", nbOctets, buffer);
}
}
}
exit(EXIT_SUCCESS);
}

101
C/Deuxieme annee/selectTCPServer.c
View File

@ -1,101 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <unistd.h>
#define BACKLOG 5
int main()
{
fd_set rfds;
struct timeval tv;
int retval;
struct sockaddr_in infoServer;
struct sockaddr_in retourServer;
socklen_t tailleRetourServ;
int retourSocket;
int retourBind;
int retourListen;
int retourAccept;
int retourRead;
int retourWrite;
int msg;
infoServer.sin_family = AF_INET;
infoServer.sin_addr.s_addr = htonl(INADDR_ANY);
infoServer.sin_port = htons(3434);
FD_ZERO(&rfds);
FD_SET(0, &rfds);
tv.tv_sec = 5;
tv.tv_usec = 0;
retval = select(1, &rfds, NULL, NULL, &tv);
retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if(retourSocket == -1)
{
printf("Erreur socket\n");
printf("%s", strerror(errno));
exit(errno);
}
retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer));
if(retourBind == -1)
{
printf("Erreur bind\n");
printf("%s", strerror(errno));
exit(errno);
}
retourListen = listen(retourSocket, BACKLOG);
if(retourListen == -1)
{
printf("Erreur listen\n");
printf("%s", strerror(errno));
exit(errno);
}
tailleRetourServ = sizeof(retourServer);
retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleRetourServ);
if(retourAccept == -1)
{
printf("Erreur accept\n");
printf("%s", strerror(errno));
exit(errno);
}
retourRead = read(retourAccept, &msg, sizeof(msg));
if(retourRead == -1)
{
printf("Erreur recv\n");
printf("%s", strerror(errno));
exit(errno);
}
printf("%d", msg);
msg = -msg;
retourWrite = write(retourAccept, &msg, sizeof(msg));
if(retourWrite == -1)
{
printf("Erreur sendto\n");
printf("%s", strerror(errno));
exit(errno);
}
return 0;
}

80
C/Deuxieme annee/semaphoreP1/main.c
View File

@ -1,80 +0,0 @@
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include "semtools.h"
typedef struct
{
float temp;
int press;
char ordre;
} uneStruct;
float randomF()
{
return ((float)100.0*(rand()/(RAND_MAX+0.1)));
}
int randomI()
{
return ((int)100.0*(rand()/(RAND_MAX+0.1)));
}
int main()
{
uneStruct *memShare;
int shmid;
key_t clef;
void *shm;
clef = ftok("/tmp/bidon", 5678);
shmid = shmget(clef, sizeof(uneStruct), 0666);
if(shmid < 0)
{
perror("Erreur shmget");
exit(EXIT_FAILURE);
}
//debut sem
id_sem = semget (5678, 1, IPC_CREAT | 0600);
if (id_sem == -1)
{
printf("Probleme semget : %s\n", strerror(errno));
if(errno != EEXIST)
{
exit(errno);
}
}
if(fixe_valeursem() == 0)
{
exit(0);
}
//fin init sem
memShare = shmat(shmid, NULL, 0);
while(1)
{
if(P() == 1)
{
memShare->press = randomI();
memShare->temp = randomF();
printf("Memoire mise a jour.\nVal->\n\tpress : %d, temp : %f\n\n", memShare->press, memShare->temp);
if(V() == 0)
{
exit(EXIT_FAILURE);
}
}
else
{
exit(EXIT_FAILURE);
}
usleep(999999);
}
}

56
C/Deuxieme annee/semaphoreP1/semtools.c
View File

@ -1,56 +0,0 @@
/******************************************************
Fichier : semtools.c
Boite a outils pour manipuler des semaphores
******************************************************/
#include "semtools.h"
int fixe_valeursem(){
union semun sem_union;
sem_union.val = 1;
int retour = 1;
printf("id_sem dans fixe_valeur = %d\n",id_sem);
if (semctl(id_sem,0,SETVAL,/*sem_union*/1) == -1){
printf("impossible de creer le semaphore\n%s\n",strerror(errno));
retour = 0;
}
return(retour);
}
void supp_valeursem(){
union semun sem_union;
if (semctl(id_sem,0,IPC_RMID,sem_union) == -1){
printf("impossible de supprimer le semaphore\n%s\n",strerror(errno));
}
}
int P(){
struct sembuf sem_b;
int retour = 1;
sem_b.sem_num = 0;
sem_b.sem_op = -1; //P()
sem_b.sem_flg = SEM_UNDO ;
if (semop(id_sem,&sem_b,1) == -1){
printf("echec semaphore P()\n%s\n",strerror(errno));
retour = 0 ;
}
return(retour);
}
int V(){
struct sembuf sem_b;
int retour=1;
sem_b.sem_num = 0;
sem_b.sem_op = 1; //V()
sem_b.sem_flg = SEM_UNDO ;
if (semop(id_sem,&sem_b,1) == -1){
printf("echec semaphore V()\n%s\n",strerror(errno));
retour = 0 ;
}
return(retour);
}

39
C/Deuxieme annee/semaphoreP1/semtools.h
View File

@ -1,39 +0,0 @@
/******************************************************
Fichier : semtools.h
Boite a outils pour manipuler des semaphores
******************************************************/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#ifndef _SEMTOOLS_H
#define _SEMTOOLS_H
// identifiant de semaphore
int id_sem;
// fixe la valeur du sempahore
int fixe_valeursem();
// supprime le semaphore
void supp_valeursem();
// modification de la valeur du semaphore de -1 (attente)
int P();
// modification de la valeur du semaphore de 1 (sem dispo)
int V();
#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
/* l'union semun est définie par l'inclusion de <sys/sem.h> */
#else
/* d'après X/OPEN il faut la définir nous-mêmes */
union semun {
int val; /* valeur pour SETVAL */
struct semid_ds *buf; /* buffer pour IPC_STAT, IPC_SET */
unsigned short *array; /* table pour GETALL, SETALL */
/* Spécificité Linux : */
struct seminfo *__buf; /* buffer pour IPC_INFO */
};
#endif
#endif

75
C/Deuxieme annee/semaphoreP2/main.c
View File

@ -1,75 +0,0 @@
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include "semtools.h"
typedef struct
{
float temp;
int press;
char ordre;
} uneStruct;
char randomC()
{
return ((char)126.0*(rand()/(RAND_MAX+0.1)));
}
int main()
{
uneStruct *memShare;
int shmid;
key_t clef;
void *shm;
clef = ftok("/tmp/bidon", 5678);
shmid = shmget(clef, sizeof(uneStruct), 0666);
if(shmid < 0)
{
perror("Erreur shmget");
exit(EXIT_FAILURE);
}
//debut sem
id_sem = semget (5678, 1, IPC_CREAT | 0600);
if (id_sem == -1)
{
printf("Probleme semget : %s\n", strerror(errno));
if(errno != EEXIST)
{
exit(errno);
}
}
if(fixe_valeursem() == 0)
{
exit(0);
}
//fin init sem
memShare = shmat(shmid, NULL, 0);
while(1)
{
if(P() == 1)
{
memShare->ordre = randomC();
printf("Memoire mise a jour.\nVal->\n\tordre : %c\n\n", memShare->ordre);
if(V() == 0)
{
exit(EXIT_FAILURE);
}
}
else
{
exit(EXIT_FAILURE);
}
usleep(999999);
}
}

56
C/Deuxieme annee/semaphoreP2/semtools.c
View File

@ -1,56 +0,0 @@
/******************************************************
Fichier : semtools.c
Boite a outils pour manipuler des semaphores
******************************************************/
#include "semtools.h"
int fixe_valeursem(){
union semun sem_union;
sem_union.val = 1;
int retour = 1;
printf("id_sem dans fixe_valeur = %d\n",id_sem);
if (semctl(id_sem,0,SETVAL,/*sem_union*/1) == -1){
printf("impossible de creer le semaphore\n%s\n",strerror(errno));
retour = 0;
}
return(retour);
}
void supp_valeursem(){
union semun sem_union;
if (semctl(id_sem,0,IPC_RMID,sem_union) == -1){
printf("impossible de supprimer le semaphore\n%s\n",strerror(errno));
}
}
int P(){
struct sembuf sem_b;
int retour = 1;
sem_b.sem_num = 0;
sem_b.sem_op = -1; //P()
sem_b.sem_flg = SEM_UNDO ;
if (semop(id_sem,&sem_b,1) == -1){
printf("echec semaphore P()\n%s\n",strerror(errno));
retour = 0 ;
}
return(retour);
}
int V(){
struct sembuf sem_b;
int retour=1;
sem_b.sem_num = 0;
sem_b.sem_op = 1; //V()
sem_b.sem_flg = SEM_UNDO ;
if (semop(id_sem,&sem_b,1) == -1){
printf("echec semaphore V()\n%s\n",strerror(errno));
retour = 0 ;
}
return(retour);
}

39
C/Deuxieme annee/semaphoreP2/semtools.h
View File

@ -1,39 +0,0 @@
/******************************************************
Fichier : semtools.h
Boite a outils pour manipuler des semaphores
******************************************************/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#ifndef _SEMTOOLS_H
#define _SEMTOOLS_H
// identifiant de semaphore
int id_sem;
// fixe la valeur du sempahore
int fixe_valeursem();
// supprime le semaphore
void supp_valeursem();
// modification de la valeur du semaphore de -1 (attente)
int P();
// modification de la valeur du semaphore de 1 (sem dispo)
int V();
#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
/* l'union semun est définie par l'inclusion de <sys/sem.h> */
#else
/* d'après X/OPEN il faut la définir nous-mêmes */
union semun {
int val; /* valeur pour SETVAL */
struct semid_ds *buf; /* buffer pour IPC_STAT, IPC_SET */
unsigned short *array; /* table pour GETALL, SETALL */
/* Spécificité Linux : */
struct seminfo *__buf; /* buffer pour IPC_INFO */
};
#endif
#endif

66
C/Deuxieme annee/semaphoreP3/main.c
View File

@ -1,66 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include "semtools.h"
typedef struct
{
float temp;
int press;
char ordre;
} uneStruct;
int main()
{
int shmid, loop = 0;
uneStruct *sharedStruct;
key_t clef;
clef = ftok("/tmp/bidon", 5678);
shmid = shmget(clef, sizeof(uneStruct), IPC_CREAT | 0666);
if(shmid < 0)
{
perror("Erreur shmget");
exit(EXIT_FAILURE);
}
//debut sem
id_sem = semget (5678, 1, IPC_CREAT | 0600);
if (id_sem == -1)
{
printf("pb semget: %s\n",strerror(errno));
if (errno!=EEXIST)
{
exit(errno);
}
}
if ( fixe_valeursem()== 0)
{
exit ( 0 );
}
//fin init sem
sharedStruct = shmat(shmid, NULL, 0);
while(1)
{
if(P() == 1)
{
printf("Loop %d\t|%d\t|%f\t| %c\n", loop, sharedStruct->temp, sharedStruct->press, sharedStruct->ordre);
if(V() == 0)
{
exit(EXIT_FAILURE);
}
}
else
{
exit(EXIT_FAILURE);
}
loop++;
usleep(999999);
}
return 0;
}

56
C/Deuxieme annee/semaphoreP3/semtools.c
View File

@ -1,56 +0,0 @@
/******************************************************
Fichier : semtools.c
Boite a outils pour manipuler des semaphores
******************************************************/
#include "semtools.h"
int fixe_valeursem(){
union semun sem_union;
sem_union.val = 1;
int retour = 1;
printf("id_sem dans fixe_valeur = %d\n",id_sem);
if (semctl(id_sem,0,SETVAL,/*sem_union*/1) == -1){
printf("impossible de creer le semaphore\n%s\n",strerror(errno));
retour = 0;
}
return(retour);
}
void supp_valeursem(){
union semun sem_union;
if (semctl(id_sem,0,IPC_RMID,sem_union) == -1){
printf("impossible de supprimer le semaphore\n%s\n",strerror(errno));
}
}
int P(){
struct sembuf sem_b;
int retour = 1;
sem_b.sem_num = 0;
sem_b.sem_op = -1; //P()
sem_b.sem_flg = SEM_UNDO ;
if (semop(id_sem,&sem_b,1) == -1){
printf("echec semaphore P()\n%s\n",strerror(errno));
retour = 0 ;
}
return(retour);
}
int V(){
struct sembuf sem_b;
int retour=1;
sem_b.sem_num = 0;
sem_b.sem_op = 1; //V()
sem_b.sem_flg = SEM_UNDO ;
if (semop(id_sem,&sem_b,1) == -1){
printf("echec semaphore V()\n%s\n",strerror(errno));
retour = 0 ;
}
return(retour);
}

39
C/Deuxieme annee/semaphoreP3/semtools.h
View File

@ -1,39 +0,0 @@
/******************************************************
Fichier : semtools.h
Boite a outils pour manipuler des semaphores
******************************************************/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#ifndef _SEMTOOLS_H
#define _SEMTOOLS_H
// identifiant de semaphore
int id_sem;
// fixe la valeur du sempahore
int fixe_valeursem();
// supprime le semaphore
void supp_valeursem();
// modification de la valeur du semaphore de -1 (attente)
int P();
// modification de la valeur du semaphore de 1 (sem dispo)
int V();
#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
/* l'union semun est définie par l'inclusion de <sys/sem.h> */
#else
/* d'après X/OPEN il faut la définir nous-mêmes */
union semun {
int val; /* valeur pour SETVAL */
struct semid_ds *buf; /* buffer pour IPC_STAT, IPC_SET */
unsigned short *array; /* table pour GETALL, SETALL */
/* Spécificité Linux : */
struct seminfo *__buf; /* buffer pour IPC_INFO */
};
#endif
#endif

46
C/Deuxieme annee/serverSocket/main.c
View File

@ -1,46 +0,0 @@
#include "socketBibli.h"
int main()
{
int socket;
int choix;
socket = demarrage();
while(1)
{
printf("Type de donner a transmettre :\n");
printf("1- Int\n");
printf("2- Float\n");
printf("3- Char\n");
printf("Choix : ");
scanf("%d", &choix);
switch (choix)
{
case 1 :
printf("Demarrage reussi, en attente de donnees.\n");
dialogueInt(socket);
break;
case 2 :
printf("Demarrage reussi, en attente de donnees.\n");
dialogueFloat(socket);
break;
case 3 :
printf("Demarrage reussi, en attente de donnees.\n");
dialogueChar(socket);
break;
default :
printf("Reponse non conforme.");
break;
}
}
return 0;
}

111
C/Deuxieme annee/serverSocket/socketBibli.c
View File

@ -1,111 +0,0 @@
#include "socketBibli.h"
void mort(char *cituation)
{
printf("Erreur avec le dernier paquet recu, probleme %s : %s \n", cituation, strerror(errno));
}
int demarrage()
{
struct sockaddr_in infoServer;
int retourSocket;
int port;
printf("Port sur lequel vous voulez lancer le serveur :");
scanf("%d", &port);
infoServer.sin_family = AF_INET;
infoServer.sin_addr.s_addr = htonl(INADDR_ANY);
infoServer.sin_port = htons(port);
retourSocket = socket(AF_INET, SOCK_DGRAM, 0);
if(retourSocket == -1)
{
mort("demarrage socket");
}
if(bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer)) == -1)
{
mort("bind");
}
return retourSocket;
}
void dialogueInt(int socket)
{
struct sockaddr_in infoClient;
int infoClientTaille;
int retourMsg;
int retourSendTo;
while(1)
{
if(recvfrom(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, &infoClientTaille) == -1)
{
mort("recvfrom");
exit(errno);
}
printf("%d\n", retourMsg);
if(sendto(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, sizeof(infoClient))==-1)
{
mort("sendto");
exit(errno);
}
}
}
void dialogueFloat(int socket)
{
struct sockaddr_in infoClient;
int infoClientTaille;
float retourMsg;
while(1)
{
if(recvfrom(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, &infoClientTaille) == -1)
{
mort("recvfrom");
exit(errno);
}
printf("%f\n", retourMsg);
if(sendto(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, sizeof(infoClient))==-1)
{
mort("sendto");
exit(errno);
}
}
}
void dialogueChar(int socket)
{
struct sockaddr_in infoClient;
int infoClientTaille;
char retourMsg[CHARLEN];
int retourSendTo;
while(1)
{
if(recvfrom(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, &infoClientTaille) == -1)
{
mort("recvfrom");
}
printf("%s\n", retourMsg);
if(sendto(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, sizeof(infoClient))==-1)
{
mort("sendto");
}
}
}

22
C/Deuxieme annee/serverSocket/socketBibli.h
View File

@ -1,22 +0,0 @@
#ifndef SOCKETBIBLI_H_INCLUDED
#define SOCKETBIBLI_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#define CHARLEN 512
void mort(char *cituation);
int demarrage();
void dialogueInt(int socket);
void dialogueChar(int socket);
void dialogueFloat(int socket);
#endif // SOCKETBIBLI_H_INCLUDED

89
C/Deuxieme annee/serveurHTTP.c
View File

@ -1,89 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <unistd.h>
#define BACKLOG 5
int main()
{
struct sockaddr_in infoServer;
struct sockaddr_in retourServer;
socklen_t tailleInfoServ;
int retourSocket;
int retourBind;
int retourListen;
int retourAccept;
int retourRead;
int retourWrite;
char html[]= "HTTP/1.0 200 OK\nContent-Length:68\nContent-Type: text/html\n\n<html><head><title>cc</title></head><body><h1>slt</h1></body></html>";
char msg[512];
infoServer.sin_family = AF_INET;
infoServer.sin_addr.s_addr = htonl(INADDR_ANY);
infoServer.sin_port = htons(8080);
retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if(retourSocket == -1)
{
printf("Erreur socket\n");
printf("%s", strerror(errno));
exit(errno);
}
retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer));
if(retourBind == -1)
{
printf("Erreur bind\n");
printf("%s", strerror(errno));
exit(errno);
}
retourListen = listen(retourSocket, BACKLOG);
if(retourListen == -1)
{
printf("Erreur listen\n");
printf("%s", strerror(errno));
exit(errno);
}
tailleInfoServ = sizeof(retourServer);
while(1){
retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleInfoServ);
if(retourAccept == -1)
{
printf("Erreur accept\n");
printf("%s", strerror(errno));
exit(errno);
}
retourRead = read(retourAccept, &msg, sizeof(msg));
if(retourRead == -1)
{
printf("Erreur read\n");
printf("%s", strerror(errno));
exit(errno);
}
printf("Nouvelle requete \n");
printf("IP : %s:%d", retourServer.sin_addr, retourServer.sin_port);
retourWrite = write(retourAccept, &html, sizeof(html));
if(retourWrite == -1)
{
printf("Erreur write\n");
printf("%s", strerror(errno));
exit(errno);
}
close(retourAccept);
}
return 0;
}

50
C/Deuxieme annee/signauxQ1.c
View File

@ -1,50 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
// fonction de traitement du signal SIGUSR1
void traitement(int sig)
{
(void) signal(SIGUSR1, traitement);
printf("un signal SIGUSR1 ppid :%d\n", getppid());
}
int main(int argc, char *argv[])
{
int pid;
(void) signal(SIGUSR1, traitement); // rederoutage des signaux SIGUSR1
// vers la fonction traitement
pid = fork();
if (pid == -1)
{
printf("pb creation fork : %s\n", strerror(errno));
exit(1);
}
else
{
if (pid == 0) // process fils
{
printf("fils pid=%d\n", getpid());
kill(getppid(), SIGUSR1);
sleep(2); // tempo pour être certain que le fils sera
//encore vivant quand le pere lui
//enverra son signal
}
else // process principal (pere)
{
printf("pere pid=%d\n", getpid());
kill(pid, SIGUSR1);
sleep(2); // tempo pour être certain que le pere sera
//encore vivant quand le fils lui
//enverra son signal
}
}
return EXIT_SUCCESS;
}

71
C/Deuxieme annee/signauxQ2.c
View File

@ -1,71 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
void traitement(int sig)
{
(void ) signal(SIGUSR1, traitement);
printf("Un signal SIGUSR1 ppid : %d %d\n", getppid(), getpid());
}
int main(int argc, char *argv[])
{
int pid;
int pid2;
int pid2temp;
(void) signal(SIGUSR1, traitement);
pid = fork();
pid2temp = pid;
if (pid == -1)
{
printf("pb creation fork : %s\n", strerror(errno));
exit(1);
}
else
{
if (pid == 0) // process fils
{
pid2 = fork();
if(pid2 == -1)
{
printf("Pb creation fork :%s\n", strerror(errno));
exit(1);
}
else
{
if(pid2 == 0)// Process fils du fils
{
printf("fils P3 pid=%d\n", getpid());
kill(pid2temp, SIGUSR1);
sleep(2); // tempo pour être certain que le fils sera
//encore vivant quand le pere lui
//enverra son signal
}
else //process fils
{
printf("fils P2 pid=%d\n", getpid());
sleep(2); // tempo pour être certain que le fils sera
//encore vivant quand le pere lui
//enverra son signal
}
}
}
else // process principal (pere)
{
kill(pid2temp, SIGUSR1);
printf("pere pid=%d\n", getpid());
sleep(2); // tempo pour être certain que le pere sera
//encore vivant quand le fils lui
//enverra son signal
}
}
return EXIT_SUCCESS;
}

8
C/Deuxieme annee/signauxQ3.c
View File

@ -1,8 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("Hello world!\n");
return 0;
}

95
C/Deuxieme annee/socketChat.c
View File

@ -1,95 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <unistd.h>
#define BACKLOG 5
#define MAX 512
int main()
{
struct sockaddr_in infoServer;
struct sockaddr_in retourServer;
socklen_t tailleInfoServ;
int retourSocket;
int retourBind;
int retourListen;
int retourAccept;
int retourRead;
int retourWrite;
char msg[MAX];
infoServer.sin_family = AF_INET;
infoServer.sin_addr.s_addr = htonl(INADDR_ANY);
infoServer.sin_port = htons(3434);
retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if(retourSocket == -1)
{
printf("Erreur socket\n");
printf("%s", strerror(errno));
exit(errno);
}
retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer));
if(retourBind == -1)
{
printf("Erreur bind\n");
printf("%s", strerror(errno));
exit(errno);
}
retourListen = listen(retourSocket, BACKLOG);
if(retourListen == -1)
{
printf("Erreur listen\n");
printf("%s", strerror(errno));
exit(errno);
}
tailleInfoServ = sizeof(retourServer);
retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleInfoServ);
if(retourAccept == -1)
{
printf("Erreur accept\n");
printf("%s", strerror(errno));
exit(errno);
}
while(1)
{
retourRead = read(retourAccept, &msg, sizeof(msg));
if(retourRead == -1)
{
printf("Erreur read\n");
printf("%s", strerror(errno));
exit(errno);
}
printf("Nouveau message \n");
printf("IP : %s:%d: %s\n\n", inet_ntoa(retourServer.sin_addr), ntohs(retourServer.sin_port), msg);
printf("Message : ");
gets(msg);
printf("\n\n");
retourWrite = write(retourAccept, &msg, sizeof(msg));
if(retourWrite == -1)
{
printf("Erreur write\n");
printf("%s", strerror(errno));
exit(errno);
}
}
close(retourAccept);
return 0;
}

79
C/Deuxieme annee/socketChatClient.c
View File

@ -1,79 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#define LEN 512
int main()
{
struct sockaddr_in infoServeur;
struct sockaddr_in infoServeurRetour;
char msg[LEN];
int infoServeurRetourTaille;
int retourSocket;
int retourConnect;
int retourRead;
int retourWrite;
int socketFd;
infoServeur.sin_addr.s_addr = inet_addr("172.18.58.93");
infoServeur.sin_family = AF_INET;
infoServeur.sin_port = htons(3434);
retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if(retourSocket == -1)
{
printf("Erreur socket\n");
printf("%s", strerror(errno));
exit(errno);
}
retourConnect = connect(retourSocket, &infoServeur, sizeof(infoServeur));
if(retourSocket == -1)
{
printf("Erreur connect\n");
printf("%s", strerror(errno));
exit(errno);
}
while (1)
{
printf("Message :");
gets(msg);
retourWrite = write(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur));
if(retourSocket == -1)
{
printf("Erreur write\n");
printf("%s", strerror(errno));
exit(errno);
}
//if(select())
//{
retourRead = read(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeurRetour, sizeof(infoServeurRetour));
if(retourRead == -1)
{
printf("Erreur read\n");
printf("%s", strerror(errno));
exit(errno);
}
printf("Message de %s:%d\n", inet_ntoa(infoServeur.sin_addr), ntohs(infoServeur.sin_port));
printf("%s\n", msg);
//}
}
close(retourSocket);
return 0;
}

37
C/Deuxieme annee/socketClient/main.c
View File

@ -1,37 +0,0 @@
#include "socketBibli.h"
int main()
{
struct sockaddr_in *infoServeur;
int retourSocket;
int choix;
retourSocket = connection(&infoServeur);
while(1)
{
printf("Donnee transferes par le serveur : \n");
printf("1- Int\n");
printf("2- Float\n");
printf("3- Char\n");
printf("Choix :");
scanf("%d", &choix);
switch (choix)
{
case 1:
dialogueInt(retourSocket, &infoServeur);
break;
case 2:
dialogueFloat(retourSocket, &infoServeur);
break;
case 3:
dialogueChar(retourSocket, &infoServeur);
break;
default:
printf("Mauvais choix");
exit(0);
}
}
return 0;
}

104
C/Deuxieme annee/socketClient/socketBibli.c
View File

@ -1,104 +0,0 @@
#include "socketBibli.h"
void mort(char *cituation)
{
printf("Erreur avec le dernier paquet recu, probleme %s : %s \n", cituation, strerror(errno));
}
int connection(struct sockaddr_in *infoServeur)
{
char IP[16];
int port;
int retourSocket;
printf("IP du serveur cible : ");
scanf("%s", &IP);
printf("Port du serveur cible : ");
scanf("%d", &port);
infoServeur->sin_addr.s_addr = inet_addr(IP);
infoServeur->sin_family = AF_INET;
infoServeur->sin_port = htons(port);
retourSocket = socket(PF_INET, SOCK_DGRAM, 0);
if(retourSocket==-1)
{
mort("socket");
}
return retourSocket;
}
void dialogueInt(int retourSocket, struct sockaddr_in *infoServeur)
{
int msg;
struct sockaddr_in infoServeurRetour;
int infoServeurRetourTaille;
while(1)
{
printf("Message (int) :");
scanf("%d", &msg);
if(sendto(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur)) == -1)
{
mort("sendto");
}
if(recvfrom(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeurRetour, &infoServeurRetourTaille) == -1)
{
mort("resvfrom");
}
}
}
void dialogueFloat(int retourSocket, struct sockaddr_in *infoServeur)
{
float msg;
struct sockaddr_in infoServeurRetour;
int infoServeurRetourTaille;
while(1)
{
printf("Message (float) :");
scanf("%f", &msg);
if(sendto(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur)) == -1)
{
mort("sendto");
}
if(recvfrom(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeurRetour, &infoServeurRetourTaille))
{
mort("resvfrom");
}
}
}
void dialogueChar(int retourSocket, struct sockaddr_in *infoServeur)
{
char msg[LONGCHAR];
struct sockaddr_in infoServeurRetour;
int infoServeurRetourTaille;
while(1)
{
printf("Message (float) :");
scanf("%s", &msg);
if(sendto(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur)) == -1)
{
mort("sendto");
}
if(recvfrom(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeurRetour, &infoServeurRetourTaille))
{
mort("resvfrom");
}
}
}

22
C/Deuxieme annee/socketClient/socketBibli.h
View File

@ -1,22 +0,0 @@
#ifndef SOCKETBIBLI_H_INCLUDED
#define SOCKETBIBLI_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#define LONGCHAR 512
void mort(char *cituation);
int connection(struct sockaddr_in *infoServeur);
void dialogueInt(int retourSocket, struct sockaddr_in *infoServeur);
void dialogueChar(int retourSocket, struct sockaddr_in *infoServeur);
void dialogueFloat(int retourSocket, struct sockaddr_in *infoServeur);
#endif // SOCKETBIBLI_H_INCLUDED

80
C/Deuxieme annee/socketClientTCP.c
View File

@ -1,80 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
typedef struct{
unsigned char jour;
unsigned char mois;
unsigned short int annee;
char jourDeLaSemaine[10];
}datePerso;
int main()
{
datePerso perso;
datePerso retourPerso;
struct sockaddr_in infoServeur;
struct sockaddr_in infoServeurRetour;
int infoServeurRetourTaille;
int retourSocket;
int retourConnect;
int retourRead;
int retourWrite;
int socketFd;
int retourMsg;
int msg = 8;
perso.jour = 17;
perso.mois = 12;
perso.annee = 1997;
strcpy(perso.jourDeLaSemaine, "Lundi");
infoServeur.sin_addr.s_addr = inet_addr("172.18.58.142");
infoServeur.sin_family = AF_INET;
infoServeur.sin_port = htons(5555);
retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if(retourSocket == -1)
{
printf("Erreur socket\n");
printf("%s", strerror(errno));
exit(errno);
}
retourConnect = connect(retourSocket, &infoServeur, sizeof(infoServeur));
if(retourSocket == -1)
{
printf("Erreur connect\n");
printf("%s", strerror(errno));
exit(errno);
}
retourWrite = write(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur));
if(retourSocket == -1)
{
printf("Erreur write\n");
printf("%s", strerror(errno));
exit(errno);
}
retourRead = read(retourSocket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoServeurRetour, &infoServeurRetourTaille);
if(retourSocket == -1)
{
printf("Erreur read\n");
printf("%s", strerror(errno));
exit(errno);
}
printf("%d", retourMsg);
close(retourSocket);
return 0;
}

88
C/Deuxieme annee/socketServeurTCP.c
View File

@ -1,88 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <unistd.h>
#define BACKLOG 5
int main()
{
struct sockaddr_in infoServer;
struct sockaddr_in retourServer;
socklen_t tailleRetourServ;
int retourSocket;
int retourBind;
int retourListen;
int retourAccept;
int retourRead;
int retourWrite;
int msg;
infoServer.sin_family = AF_INET;
infoServer.sin_addr.s_addr = htonl(INADDR_ANY);
infoServer.sin_port = htons(5555);
retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if(retourSocket == -1)
{
printf("Erreur socket\n");
printf("%s", strerror(errno));
exit(errno);
}
retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer));
if(retourBind == -1)
{
printf("Erreur bind\n");
printf("%s", strerror(errno));
exit(errno);
}
retourListen = listen(retourSocket, BACKLOG);
if(retourListen == -1)
{
printf("Erreur listen\n");
printf("%s", strerror(errno));
exit(errno);
}
tailleRetourServ = sizeof(retourServer);
retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleRetourServ);
if(retourAccept == -1)
{
printf("Erreur accept\n");
printf("%s", strerror(errno));
exit(errno);
}
retourRead = read(retourAccept, &msg, sizeof(msg));
if(retourRead == -1)
{
printf("Erreur recv\n");
printf("%s", strerror(errno));
exit(errno);
}
printf("%d", msg);
msg = -msg;
retourWrite = write(retourAccept, &msg, sizeof(msg));
if(retourWrite == -1)
{
printf("Erreur sendto\n");
printf("%s", strerror(errno));
exit(errno);
}
return 0;
}

11
C/Deuxieme annee/testFork.c
View File

@ -1,11 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
fork();
fork();
fork();
printf("* ");
return 0;
}

33
C/Deuxieme annee/testFork2.c
View File

@ -1,33 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
int pid1, pid2, pid3;
pid1 = fork();
if (pid1 == 0)
{
printf("p1\n");
}
else
{
pid2 = fork();
if (pid2 == 0)
{
printf("p2\n");
}
else
{
pid3 = fork();
if (pid3 == 0)
{
printf("p3\n");
}
else
{
printf("p4\n");
}
}
}
return 0;
}

8
C/Deuxieme annee/testFork3.c
View File

@ -1,8 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("Hello world!\n");
return 0;
}

86
C/Deuxieme annee/threadTD.c
View File

@ -1,86 +0,0 @@
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
typedef struct {
int v1;
int v2;
int v3;
}laStruct;
laStruct maStruct;
void *fonction_update1 ()
{
maStruct.v1 = 1;
}
void *fonction_update2 ()
{
maStruct.v2 = 2;
}
void *fonction_update3 ()
{
maStruct.v3 = 3;
}
int main()
{
int resultat;
pthread_t un_thread;
pthread_t deux_thread;
pthread_t trois_thread;
void *thread_result;
resultat = pthread_create(&un_thread, NULL, fonction_update1, NULL);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
resultat = pthread_create(&deux_thread, NULL, fonction_update2, NULL);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
resultat = pthread_create(&trois_thread, NULL, fonction_update3, NULL);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
printf("Attente de la fin du thread...\n");
resultat = pthread_join(un_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
printf("Attente de la fin du thread...\n");
resultat = pthread_join(deux_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
printf("Attente de la fin du thread...\n");
resultat = pthread_join(trois_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
printf("%d\n%d\n%d\n", maStruct.v1, maStruct.v2, maStruct.v3);
exit(EXIT_SUCCESS);
return 0;
}

BIN
C/Deuxieme annee/threadTDQ2/bin/Debug/threadTDQ2
View File

Binary file not shown.

BIN
C/Deuxieme annee/threadTDQ2/obj/Debug/main.o
View File

Binary file not shown.

87
C/Deuxieme annee/threadTDQ2/threadTDQ2.c
View File

@ -1,87 +0,0 @@
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
typedef struct {
int v1;
int v2;
int v3;
}laStruct;
laStruct maStruct;
void *fonction_update1 (int val)
{
maStruct.v1 = val;
}
void *fonction_update2 (int val)
{
maStruct.v2 = val;
}
void *fonction_update3 (int val)
{
maStruct.v3 = val;
}
int main()
{
int resultat;
pthread_t un_thread;
pthread_t deux_thread;
pthread_t trois_thread;
void *thread_result;
int val[3] = {1, 3, 5};
resultat = pthread_create(&un_thread, NULL, fonction_update1, (void *) val[0]);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
resultat = pthread_create(&deux_thread, NULL, fonction_update2, (void *) val[1]);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
resultat = pthread_create(&trois_thread, NULL, fonction_update3, (void *) val[2]);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
printf("Attente de la fin du thread...\n");
resultat = pthread_join(un_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
printf("Attente de la fin du thread...\n");
resultat = pthread_join(deux_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
printf("Attente de la fin du thread...\n");
resultat = pthread_join(trois_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
printf("%d\n%d\n%d\n", maStruct.v1, maStruct.v2, maStruct.v3);
exit(EXIT_SUCCESS);
return 0;
}

47
C/Deuxieme annee/threadTDQ2/threadTDQ2.cbp
View File

@ -1,47 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="threadTDQ2" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/threadTDQ2" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
</Compiler>
</Target>
<Target title="Release">
<Option output="bin/Release/threadTDQ2" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O2" />
</Compiler>
<Linker>
<Add option="-s" />
</Linker>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
</Compiler>
<Linker>
<Add library="pthread" />
</Linker>
<Unit filename="main.c">
<Option compilerVar="CC" />
</Unit>
<Extensions>
<code_completion />
<envvars />
<lib_finder disable_auto="1" />
<debugger />
</Extensions>
</Project>
</CodeBlocks_project_file>

8
C/Deuxieme annee/threadTDQ2/threadTDQ2.depend
View File

@ -1,8 +0,0 @@
# depslib dependency file v1.0
1475661104 source:/home/USERS/ELEVES/SNIR2015/therbron/Workspace/C/threadTDQ2/main.c
<stdio.h>
<unistd.h>
<stdlib.h>
<string.h>
<pthread.h>

9
C/Deuxieme annee/threadTDQ2/threadTDQ2.layout
View File

@ -1,9 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_layout_file>
<ActiveTarget name="Debug" />
<File name="main.c" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="0" topLine="5" />
</Cursor>
</File>
</CodeBlocks_layout_file>

BIN
C/Deuxieme annee/threadTDQ3/bin/Debug/threadTDQ3
View File

Binary file not shown.

96
C/Deuxieme annee/threadTDQ3/main.c
View File

@ -1,96 +0,0 @@
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
typedef struct {
int v1;
int v2;
int v3;
}laStruct;
laStruct maStruct;
pthread_mutex_t mutex;
void *fonction_update (int val[])
{
pthread_mutex_lock(&mutex);
maStruct.v1 = val[0];
maStruct.v2 = val[1];
maStruct.v3 = val[2];
printf("Valeur en cours de Thread :\n\t%d\t%d\t%d\n\n",maStruct.v1, maStruct.v2, maStruct.v3);
pthread_mutex_unlock(&mutex);
}
int main()
{
pthread_t un_thread;
pthread_t deux_thread;
pthread_t trois_thread;
void *thread_result;
int resultat;
int valT1[3] = {1, 3, 5};
int valT2[3] = {2, 4, 6};
int valT3[3] = {10, 20, 30};
int retourMutex;
pthread_mutexattr_t mutexattr = PTHREAD_MUTEX_INITIALIZER;
retourMutex = pthread_mutex_init(&mutex, &mutexattr);
if (retourMutex != 0)
{
perror("Erreur peu probable dans l'initialisation du mutex.");
exit(EXIT_FAILURE);
}
resultat = pthread_create(&un_thread, NULL, fonction_update, (void *) valT1);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
printf("Attente de la fin du thread...\n");
resultat = pthread_create(&deux_thread, NULL, fonction_update, (void *) valT2);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
printf("Attente de la fin du thread...\n");
resultat = pthread_create(&trois_thread, NULL, fonction_update, (void *) valT3);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
printf("Attente de la fin du thread...\n");
resultat = pthread_join(un_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
resultat = pthread_join(deux_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
resultat = pthread_join(trois_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
pthread_mutex_lock(&mutex);
printf("Val finale :\n\t%d\t%d\t%d\n", maStruct.v1, maStruct.v2, maStruct.v3);
pthread_mutex_unlock(&mutex);
exit(EXIT_SUCCESS);
return 0;
}

BIN
C/Deuxieme annee/threadTDQ3/obj/Debug/main.o
View File

Binary file not shown.

47
C/Deuxieme annee/threadTDQ3/threadTDQ3.cbp
View File

@ -1,47 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="threadTDQ3" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/threadTDQ3" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
</Compiler>
</Target>
<Target title="Release">
<Option output="bin/Release/threadTDQ3" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O2" />
</Compiler>
<Linker>
<Add option="-s" />
</Linker>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
</Compiler>
<Linker>
<Add library="pthread" />
</Linker>
<Unit filename="main.c">
<Option compilerVar="CC" />
</Unit>
<Extensions>
<code_completion />
<envvars />
<lib_finder disable_auto="1" />
<debugger />
</Extensions>
</Project>
</CodeBlocks_project_file>

8
C/Deuxieme annee/threadTDQ3/threadTDQ3.depend
View File

@ -1,8 +0,0 @@
# depslib dependency file v1.0
1475825404 source:/home/USERS/ELEVES/SNIR2015/therbron/Workspace/C/threadTDQ3/main.c
<stdio.h>
<unistd.h>
<stdlib.h>
<string.h>
<pthread.h>

9
C/Deuxieme annee/threadTDQ3/threadTDQ3.layout
View File

@ -1,9 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_layout_file>
<ActiveTarget name="Debug" />
<File name="main.c" open="1" top="1" tabpos="4" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="796" topLine="17" />
</Cursor>
</File>
</CodeBlocks_layout_file>

51
C/Deuxieme annee/threads.c
View File

@ -1,51 +0,0 @@
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <sys/syscall.h>
char message[255];
typedef struct {
int v1;
int v2;
int v3;
}laStruct;
void *ma_fonction_thread(void *arg)
{
int tid = syscall(SYS_gettid);
printf("Le tid du thread est :%d\n", tid);
sleep(3);
strcpy(message, "Bye!");
pthread_exit((void *) "Merci pour le temps CPU.");
}
int main()
{
int resultat;
pthread_t un_thread;
void *thread_result;
strcpy(message, "Debian c'est cool.");
resultat = pthread_create(&un_thread, NULL, ma_fonction_thread, (void *)message);
if (resultat != 0) {
perror("Thread creation failed");
exit(EXIT_FAILURE);
}
printf("PID du programme principal : %d\n", getpid());
printf("Attente de la fin du thread...\n");
resultat = pthread_join(un_thread, &thread_result);
if (resultat != 0) {
perror("Thread join a foir... echoué");
exit(EXIT_FAILURE);
}
printf("OK, valeur de retour du Thread join :%s\n", (char *)thread_result);
printf("Le message est maintenant %s\n", message);
exit(EXIT_SUCCESS);
}

159
C/Premiere annee/IMC.c
View File

@ -1,159 +0,0 @@
//Herbron Tanguy
//Calcul de l'IMC
#include <stdio.h>
#include <stdlib.h>
int main()
{
char nom[100];
char prenom[100];
char sexe;
char choixFormule;
float age;
int menu = 0;
float taille;
float poids;
float imc;
float poidsIdeal;
printf("Bienvenue dans notre programme de calcul de l'IMC.\n");
printf("Nous avons besoin de quelques renseignements.\n");
printf("Votre nom: ");
gets(nom);
printf("Votre prénom: ");
gets(prenom);
printf("Votre sexe (h ou f): ");
scanf(" %c", &sexe);
while(sexe != 'h' && sexe != 'f')
{
printf("Saisie incorrecte, réessayez.\n");
printf("Votre sexe (h ou f): ");
scanf(" %c", &sexe);
}
printf("Votre age: ");
scanf("%d", &age);
printf("Votre taille (en mètre): ");
scanf("%f", &taille);
printf("Votre poids (en kg): ");
scanf("%f", &poids);
printf("\n");
printf("Votre fiche récapitulative :\n");
printf("- Identite : %s %s\n", prenom, nom);
printf("- Age : %.0f ans\n", age);
printf("- Poids : %.2f kg\n", poids);
printf("- Taille : %.2f m\n", taille);
//Vérification du sexe pour une écriture plus correcte
if(sexe == 'h')
{
printf("- Sexe : homme\n\n");
}
else
{
printf("- Sexe : femme\n\n");
}
imc = poids / (taille * taille);
//Correspondance de la corpulence en fonction de l'IMC
if(imc <= 16.5)
{
printf("Votre indice de masse corporelle est de %.1f.\n", imc);
printf("Votre corpulence est qualifiée de famine.\n");
}
else
{
if(imc <= 18.5)
{
printf("Votre indice de masse corporelle est de %.1f.\n", imc);
printf("Votre corpulence est qualifiée de maigreur.\n");
}
else
{
if(imc <= 25)
{
printf("Votre indice de masse corporelle est de %.1f.\n", imc);
printf("Votre corpulence est qualifiée de normale.\n");
}
else
{
if(imc <= 30)
{
printf("Votre indice de masse corporelle est de %.1f.\n", imc);
printf("Votre corpulence est qualifiée de surpoids.\n");
}
else
{
if(imc <= 35)
{
printf("Votre indice de masse corporelle est de %.1f.\n", imc);
printf("Votre corpulence est qualifiée de obésité modéré.\n");
}
else
{
if(imc <= 40)
{
printf("Votre indice de masse corporelle est de %.1f.\n", imc);
printf("Votre corpulence est qualifiée de obésité sévère.\n");
}
else
{
printf("Votre indice de masse corporelle est de %.1f.\n", imc);
printf("Votre corpulence est qualifiée de obésité morbide.\n");
}
}
}
}
}
}
printf("\n");
do
{
printf("Calculez votre poids idéal :\n");
printf("a - formule de Lorents\n");
printf("b - formule de Devine\n");
printf("c - formule de Lorents en tenant compte de l'age\n");
printf("q - quitter le menu de calcul du poids idéal\n");
printf("Votre choix: ");
scanf(" %c", &choixFormule);
//Menu pour choisir le mode de calcul du poids idéal
switch (choixFormule)
{
case 'a':
if(sexe == 'h')
{
}
printf("Votre poids idéal selon la formule de Lorents est de %.1f kg.\n\n", poidsIdeal);
break;
case 'b':
if(sexe == 'h')
{
poidsIdeal = 50 + 2.3 * (taille / 0.0254 - 60);
}
else
{
poidsIdeal = 45.5 + 2.3 * (taille / 0.0254 - 60);
}
printf("Votre poids idéal selon la formule de Devine est de %.1f kg.\n\n", poidsIdeal);
break;
case 'c':
poidsIdeal = 50 + ((taille * 100 - 150) / 4) + ((age - 20) / 4);
printf("Votre poids idéal selon la formule de Lorents en tenant compte de l'age est de %.1f kg.\n\n", poidsIdeal);
break;
case 'q':
printf("Vous avez quitté le menu de calcul du poids idéal.\n");
menu++;
break;
default:
printf("Caractère entré incorrecte. Réessayez.\n\n");
}
}
while (menu == 0);
}

100
C/Premiere annee/Monayeur/bibliotheque_perso.c
View File

@ -1,100 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#define DELTA 0.001
double demanderBoisson()
{
int choixBoisson;
double prixBoisson;
printf("Choisissez votre boisson :\n");
printf("1 - Café long [1.5€]\n");
printf("2 - Café cours [0.8€]\n");
printf("Votre choix :");
scanf("%d", &choixBoisson);
switch (choixBoisson){
case 1:
prixBoisson = 1.5;
break;
case 2:
prixBoisson = 0.8;
break;
}
return prixBoisson;
}
double attendrePiece(double prixBoisson, int pieceUser[])
{
int piece;
double somme = 0;
do{
printf("Le prix est de %.1f€\n", prixBoisson);
printf("Monnaie :\n");
printf("1 - 20€\n");
printf("2 - 10€\n");
printf("3 - 5€\n");
printf("4 - 2€\n");
printf("5 - 1€\n");
printf("6 - 0.5€\n");
printf("7 - 0.2€\n");
printf("8 - 0.1€\n");
printf("Piece a entrer :");
scanf("%d", &piece);
switch (piece){
case 1:
somme = somme + 20;
pieceUser[0]++;
break;
case 2:
somme = somme + 10;
pieceUser[1]++;
break;
case 3:
somme = somme + 5;
pieceUser[2]++;
break;
case 4:
somme = somme + 2;
pieceUser[3]++;
break;
case 5:
somme = somme + 1;
pieceUser[4]++;
break;
case 6:
somme = somme + 0.5;
pieceUser[5]++;
break;
case 7:
somme = somme + 0.2;
pieceUser[6]++;
break;
case 8:
somme = somme + 0.1;
pieceUser[7]++;
break;
}
printf("La somme que vous avez entree est de %.1f€\n", somme);
}while(prixBoisson > somme);
return somme - prixBoisson;
}
double rendrePiece(double rendrePrix, double valPiece[], int nbPiece[], int pieceRendu[])
{
int boucle;
// mise à jours des pieces a rendre
for(boucle = 0; boucle < 8; boucle++){
// je peux rendre des pieces de la valeur courante
if(valPiece[boucle] <= rendrePrix){
// tant que je peux rendre des pieces de la valeur courante, je le fais
while((rendrePrix > (valPiece[boucle]-DELTA)) && (nbPiece[boucle] != 0)){
rendrePrix = rendrePrix - valPiece[boucle];
pieceRendu[boucle]++;
nbPiece[boucle]--;
}
}
}
return rendrePrix;
}

8
C/Premiere annee/Monayeur/bibliotheque_perso.h
View File

@ -1,8 +0,0 @@
#ifndef BIBLIOTHEQUE_PERSO_H_INCLUDED
#define BIBLIOTHEQUE_PERSO_H_INCLUDED
double demanderBoisson();
double attendrePiece(double prixBoisson, int pieceUser[]);
double rendrePiece(double rendrePrix, double valPiece[], int nbPiece[], int pieceRendu[]);
#endif // BIBLIOTHEQUE_PERSO_H_INCLUDED

54
C/Premiere annee/Monayeur/main.c
View File

@ -1,54 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include "bibliotheque_perso.h"
int main()
{
double valPiece[8] = {20, 10, 5, 2, 1, 0.5, 0.2, 0.1};
double prixBoisson;
double valeurARendre;
int nbPiece[8] = {0, 0, 0, 5, 5, 8, 9, 12};
int pieceUser[8] = {0, 0, 0, 0, 0};
int pieceRendu[8] = {0, 0, 0, 0, 0};
int choix;
int boucle;
printf("Bonjour.\n");
do{
printf("Que voulez-vous faire ?\n");
printf("1 - Commander une boisson\n");
printf("2 - Quitter\n");
printf("Votre choix :");
scanf("%d", &choix);
switch (choix){
case 1:
prixBoisson = demanderBoisson();
valeurARendre = attendrePiece(prixBoisson, pieceUser);
printf("Somme à rendre : %.1f\n", valeurARendre);
// ajouter les pieces de l'usager dans le monnayeur
for(boucle = 0; boucle < 8; boucle++){
nbPiece[boucle] = nbPiece[boucle] + pieceUser[boucle];
}
valeurARendre = rendrePiece(valeurARendre, valPiece, nbPiece, pieceRendu);
printf("Pieces rendues :\n");
for(boucle = 0; boucle < 8; boucle++){
printf("%d piece de %.1f€\n", pieceRendu[boucle], valPiece[boucle]);
}
break;
case 2:
printf("Au revoir\n");
break;
default:
printf("Saisie incorrecte\n");
break;
}
}while(choix != 2);
return 0;
}

119
C/Premiere annee/Pendu/gestionPendu.c
View File

@ -1,119 +0,0 @@
#include "gestionPendu.h"
int motEstTrouve(char *motATtrouver, char *motPropose){
return(strcmp(motATtrouver,motPropose));
}
int verifierLettrePropose(char *lettresProposees, int nbLettreProposee, char lettre)
{
int lettreTrouve=1;
int i;
for(i = 0; i<nbLettreProposee;i++){
/*
a completer
*/
}
return lettreTrouve;
}
//retourne une valeur entiere E[0..maxAlea[
unsigned int aleatoire( unsigned int maxAlea )
{
struct timeb t;
float a, b ;
unsigned int nbmilli;
ftime( &t );
nbmilli = t.time * 1000 + t.millitm;
srand( nbmilli );
a = rand();
b = ( maxAlea * a ) / RAND_MAX;
return( ( unsigned int )b );
}
void initialiserMot(char *motCourant,int longueurMot){
/*
a completer
*/
motCourant[longueurMot]='\0'; // pour que le tableau de caracteres devienne une chaine de caracteres
}
int afficherMenu(){
int choix;
printf("Voulez-vous jouer ?");
printf("1 - Oui");
printf("2 - Non");
scanf("%d", &choix);
if(choix == 1){
return choix;
}else{
if(choix == 2){
return -choix;
}else{
printf("Erreur");
return -choix;
}
}
}
void afficherPendu(int nroErreur){
switch (nroErreur){
case 1:
printf(" \n \n \n \n \n \n \n \n \n \n");
break;
case 2:
printf(" \n \n \n \n \n \n \n \n \n \n==================");
break;
case 3:
printf(" \n || \n || \n || \n || \n || \n ||\n ||\n ||\n ||\n==================");
break;
case 4:
printf(" \n || \n || \n || \n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 5:
printf(" \n || / \n || / \n ||/ \n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 6:
printf("\n ,==========Y===\n || / \n || / \n ||/ \n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 7:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ \n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 8:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 9:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || |\n || \n ||\n ||\n /||\n //||\n==================");
break;
case 10:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\n || \n ||\n ||\n /||\n //||\n==================");
break;
case 11:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\\\n || \n ||\n ||\n /||\n //||\n==================");
break;
case 12:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\\\n || /\n ||\n ||\n /||\n //||\n==================");
break;
case 13:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\\\n || /|\n ||\n ||\n /||\n //||\n==================");
break;
}
printf("\n");
}
void afficherLettre(char *histo, int nbLettre){
int boucle;
for(boucle = 0; boucle < nbLettre; boucle++){
printf("%c", histo[nbLettre]);
}
}
int motEstTrouve(char *motATtrouver, char *motPropose){
}

48
C/Premiere annee/Pendu/gestionPendu.h
View File

@ -1,48 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <sys/timeb.h>
#include <math.h>
#ifndef _PENDU_H_
#define _PENDU_H_
#define NB_MAX_ERREUR 7
#define NB_MAX_LETTRES_POSSIBLE 26
#define NBMOTS 5
// affiche un menu proposant de jouer ou de quitter
// recupère la réponse du joueur et retourne une valeur
// positive s'il veut jouer et négative sinon
int afficherMenu();
// affiche le pendu en fonction du nombre d'erreurs
// passee en parametre
void afficherPendu(int nroErreur);
// Affiche les lettres deja proposees
// qui se trouve dans le tableau de lettre "histo"
// le nombre de lettre etant donne par nbLettre
void afficherLettre(char *histo, int nbLettre);
// retourne 0 et le mot est trouve
int motEstTrouve(char *motATtrouver, char *motPropose);
// remplace les - par la lettre propose dans le tableau mot courant
// si la lettre fait partie du mot a trouver
// retourne 1 si aucune lettre ne correspond, et 0 sinon
int placerLettre(char *motATrouver,char *motCourant,char lettrePropose);
// retourne 0 si la lettre a deja ete propose ou si ce n'est pas une lettre
int verifierLettrePropose(char *lettresProposees, int nbLettreProposee, char lettre);
// retourne un entier compris entre 0 et maxAlea
unsigned int aleatoire( unsigned int maxAlea );
// met des - dans chaque case du tableau motCourant
void initialiserMot(char *motCourant,int longueurMot);
#endif

65
C/Premiere annee/Pendu/main.c
View File

@ -1,65 +0,0 @@
#include "gestionPendu.h"
int main(int argc, char *argv[])
{
char *listeMots[NBMOTS]={"bonjour","maison","noyau","temps","blond"};
int cptErreur=0;
int longueurMot;
char *motATrouver;
char *motCourant;
int choix,i;
char lettre;
char histo[NB_MAX_LETTRES_POSSIBLE];
int cptProposition=0;
int trouve;
do{
choix=afficherMenu();
// l'utilisateur veut jouer
if (choix>0){
// init des compteurs
cptErreur=0;
cptProposition=0;
// tirage aleatooire du mot
motATrouver=listeMots[aleatoire(NBMOTS-1)];
// init du motCourant
longueurMot=strlen(motATrouver);
motCourant=(char *)malloc(longueurMot+1);
initialiserMot(motCourant,longueurMot);
// boucle de jeu
do{
printf("%s\n",motCourant);
afficherLettre(histo,cptProposition);
// demander/redemander une lettre tant que
// le caractere saisi n'est pas une lettre
// ou a deja ete propose
do{
printf("donnez une lettre :");
scanf(" %c",&lettre);
}while(verifierLettrePropose(histo,cptProposition,lettre)==0);
// mise a jour du tableau des lettres proposees
histo[cptProposition]=lettre;
cptProposition++;
// mise a jour du compteur d'erreur
cptErreur+=placerLettre(motATrouver,motCourant,lettre);
afficherPendu(cptErreur);
trouve=motEstTrouve(motATrouver,motCourant);
}while(/* a completer*/);
// liberation de la memoire du mot courant
free(motCourant);
// affichage des messages de fin de jeu
if (trouve==0)
{
printf("bravo\n");
}
else
{
printf("Perdu le mot etait %s\n",motATrouver);
}
} // fin boucle de jeu
}while (choix!=-1);
return EXIT_SUCCESS;
}

152
C/Premiere annee/PointeursMois/biblio.c
View File

@ -1,152 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define NBMOIS 12
#define TAILLEMAX 50
char* moisNom(int numeroMois){
char *mois[NBMOIS] = {"Janvier", "Fevrier", "Mars", "Avril", "Mai", "Juin", "Juillet", "Aout", "Septembre", "Octobre", "Novembre", "Decembre"};
char *moisRetour;
numeroMois--;
moisRetour = (char*)malloc( ( strlen(mois[numeroMois])+1) * sizeof(char));
strcpy(moisRetour, mois[numeroMois]);
return moisRetour;
}
char* supprimerE(char chaine[]){
int boucle;
int boucleSensE = 0;
int nbE = 0;
char *sensE;
for(boucle = 0; boucle < strlen(chaine); boucle++){
if(chaine[boucle] == 'e'){
nbE++;
}
}
sensE = (char*)malloc( ( strlen(chaine)-nbE+1) * sizeof(char));
for(boucle = 0; boucle < strlen(chaine); boucle++){
if(chaine[boucle] != 'e'){
sensE[boucleSensE] = chaine[boucle];
boucleSensE++;
}
}
return sensE;
}
char* saisirChaine(char *message){
char *nom;
char buffer[TAILLEMAX];
printf("%s", message);
scanf("%s", buffer);
nom = (char*) malloc((strlen(buffer)+1)*sizeof(char));
strcpy(nom, buffer);
return nom;
}
void swapFloat(float *ptr1, float *ptr2){
float tmp;
tmp = *ptr1;
*ptr1 = *ptr2;
*ptr2 = tmp;
}
void discriminant(float a, float b, float c, float *racine1, float *racine2, int *printResult){
int delta;
delta = b*b - 4*a*c;
if(delta >= 0){
*racine1 = ((-b - sqrt(delta)) / (2*a));
*racine2 = ((-b + sqrt(delta)) / (2*a));
*printResult = 1;
}
}
void exercice1(){
int choix;
char *pointeur;
printf("De quel mois voulez-vous le nom ? (Entre 1 et 12)\n");
scanf("%d", &choix);
pointeur = moisNom(choix);
printf("%s", pointeur);
}
void exercice2(){
char chaine[TAILLEMAX];
char *pointeur;
printf("Saisissez une chaine de caractère :");
scanf("%s", chaine);
pointeur = supprimerE(chaine);
printf("%s", pointeur);
}
void exercice3(){
char *nom;
nom = saisirChaine("Comment vous appelez-vous ?");
printf("Vous vous appelez %s.\n", nom);
}
void exercice4(){
float val1;
float val2;
printf("Saisissez deux réels.\n");
printf("1: ");
scanf("%f", &val1);
printf("2: ");
scanf("%f", &val2);
printf("Avant le changement:\n");
printf("Val1 = %.2f \tVal2 = %.2f\n", val1, val2);
swapFloat(&val1, &val2);
printf("Après le changement:\n");
printf("Val1 = %.2f \tVal2 = %.2f", val1, val2);
}
void exercice5(){
float a;
float b;
float c;
float racine1;
float racine2;
int printResult = 0;
printf("Calcul de discriminant.\n");
printf("a: ");
scanf("%f", &a);
printf("b: ");
scanf("%f", &b);
printf("c: ");
scanf("%f", &c);
discriminant(a, b, c, &racine1, &racine2, &printResult);
if(printResult){
printf("%f\t%f", racine1, racine2);
}else{
printf("Aucune racine.");
}
}

24
C/Premiere annee/PointeursMois/biblio.h
View File

@ -1,24 +0,0 @@
#ifndef BIBLIO_H_INCLUDED
#define BIBLIO_H_INCLUDED
char* moisNom(int numeroMois);
char* supprimerE(char chaine[]);
char* saisirChaine(char *message);
void swapFloat(float *ptr1, float *ptr2);
void discriminant(float a, float b, float c, float *racine1, float *racine2);
void exercice1();
void exercice2();
void exercice3();
void exercice4();
void exercice5();
#endif // BIBLIO_H_INCLUDED

41
C/Premiere annee/PointeursMois/main.c
View File

@ -1,41 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include "biblio.h"
int main()
{
int choixExercice;
printf("Quel exercice voulez-vous essayer ?\n");
printf("1- Adresse des mois\n");
printf("2- Enlever le caractere e\n");
printf("3- Nom et chaine de caractere\n");
printf("4- Inversion de float\n");
printf("5- Discriminant\n");
printf("Votre choix : ");
scanf("%d", &choixExercice);
switch (choixExercice){
case 1:
exercice1();
break;
case 2:
exercice2();
break;
case 3:
exercice3();
break;
case 4:
exercice4();
break;
case 5:
exercice5();
break;
default:
break;
}
return 0;
}

54
C/Premiere annee/TDFonction/biblioPerso.c
View File

@ -1,54 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
void afficherMenu(char sexe){
if(sexe == 'f'){
printf("Menu pour femme\n");
}
if(sexe == 'h'){
printf("Menu pour homme\n");
}
}
float additionReel(float v1, float v2){
return v1+v2;
}
void afficherCarrer(int v1){
printf("%d", v1*v1);
}
int calculerCarrer(int v1){
return v1*v1;
}
float calculerDiscriminant(float a, float b, float c){
return b*b-4*a*c;
}
void afficherRacines(float a, float b, float c){
int delta = b*b-4*a*c;
if(delta > 0){
printf("Il y a deux solutions.\n");
printf("La première est %.2f.\n", (-b+(delta/delta))/(2*a));
printf("La seconde est %.2f.\n", (-b-(delta/delta))/(2*a));
}
if(delta == 0){
printf("Il n'y a qu'une solution qui est %.2f.\n", -b/(2*a));
}
if(delta < 0){
printf("Le discriminant n'admet aucune solution.\n");
}
}
void afficherCarre(int cote){
int boucleHor;
int boucleVer;
for(boucleVer = 0; boucleVer < cote; boucleVer++){
for(boucleHor = 0; boucleHor < cote; boucleHor++){
printf("*");
}
printf("\n");
}
}

12
C/Premiere annee/TDFonction/biblioPerso.h
View File

@ -1,12 +0,0 @@
#ifndef BIBLIOPERSO_H_INCLUDED
#define BIBLIOPERSO_H_INCLUDED
void afficherMenu(char sexe);
float additionReel(float v1, float v2);
void afficherCarrer(int v1);
int calculerCarrer(int v1);
float calculerDiscriminant(float a, float b, float c);
void afficherRacines(float a, float b, float c);
void afficherRectance(int cote);
#endif // BIBLIOPERSO_H_INCLUDED

59
C/Premiere annee/TDFonction/main.c
View File

@ -1,59 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include "biblioPerso.h"
int main()
{
char sexe;
int valeurCarrer;
int coteCarre;
int coteRectLargeur;
int coteRectLongueur;
float valeurAddition1;
float valeurAddition2;
float a;
float b;
float c;
printf("Bonjour.\n");
printf("Votre sexe :");
scanf("%c", &sexe);
afficherMenu(sexe);
printf("\nSaisissez une valeur :");
scanf("%f", &valeurAddition1);
printf("Saisissez une seconde valeur :");
scanf("%f", &valeurAddition2);
printf("Votre somme est égale à %.2f.\n", additionReel(valeurAddition1, valeurAddition2));
printf("\nSaisissez une valeur pour afficher un carré :");
scanf("%d", &valeurCarrer);
afficherCarrer(valeurCarrer);
printf("\n\nSaisissez une valeur pour calculer un carré :");
scanf("%d", &valeurCarrer);
printf("Votre valeur calculée au carré donne %d.", calculerCarrer(valeurCarrer));
printf("\n\nNous voulons calculer un discriminant.\n");
printf("Saisissez a :");
scanf("%f", &a);
printf("Saisissez b :");
scanf("%f", &b);
printf("Saisissez c :");
scanf("%f", &c);
printf("Votre discriminant est %.2f.\n", calculerDiscriminant(a, b, c));
afficherRacines(a, b, c);
printf("\nNous voulons dessiner un carré.\n");
printf("Saisissez la taille du côté :");
scanf("%d", &cote);
afficherCarre(cote);
printf("\nNous voulons dessiner un carré.\n");
printf("Saisissez la taille du côté :");
scanf("%d", &cote);
afficherCarre(cote);
return 0;
}

26
C/Premiere annee/TD_boucle.c
View File

@ -1,26 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
float note;
printf("Entrer la note obtenue :");
scanf("%f", &note);
if(note >= 16){
printf("Votre note est A.\n");
}else{
if(note >= 12){
printf("Votre note est B.\n");
}else{
if(note >= 8){
printf("Votre note est C.\n");
}else{
if(note >= 4){
printf("Votre note est D.\n");
}else{
printf("Votre note est E.\n");
}}}}
return 0;
}

19
C/Premiere annee/TP1.c
View File

@ -1,19 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#define length 255
int main()
{
char chaineScan [length];
char chaineGet [length];
printf("Entrer chaine de caractère, test pour gets: ");
fgets(chaineGet, sizeof(chaineGet), stdin);
printf("La saisie retenue est: %s\n", chaineGet);
printf("Entrer chaine de caractère, test pour scanf: ");
scanf("%s", chaineScan);
printf("La saisie retenue est: %s\n", chaineScan);
}

24
C/Premiere annee/TP1_11.c
View File

@ -1,24 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
int nbValeur;
int tabValeur[255];
int loop;
int plusGrosseValeur;
printf("Combien de valeur avez-vous à comparer ?\n");
scanf("%d", &nbValeur);
printf("\n");
for(loop = 1; nbValeur >= loop; loop++){
printf("%d valeur: ", loop);
scanf("%d", &tabValeur[loop]);
if(plusGrosseValeur <= tabValeur[loop]){
plusGrosseValeur = tabValeur[loop];
}
}
printf("\nLa plus grosse valeur est %d.\n",plusGrosseValeur);
}

13
C/Premiere annee/TP1_13.c
View File

@ -1,13 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
char caractere;
printf("Donner un caractère: ");
scanf("%s", &caractere);
printf("La valeur décimale est %d.\n", caractere);
printf("La valeur hexadécimale est 0x%x.\n", caractere);
}

21
C/Premiere annee/TP_17.c
View File

@ -1,21 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
float a,b,c,resultat;
printf("Dans l'ordre, entrer les valeurs de a, de b et de c pour l'équation ax²+bx+c=0.\n");
scanf("%f", &a);
scanf("%f", &b);
scanf("%f", &c);
resultat = b * b - 4 * a * c;
if(resultat > 0){
printf("L'équation admet 2 solutnios.");
}else if(resultat == 0){
printf("L'équation admet une solution.");
}else{
printf("L'équation n'admet aucune solution.");
}
}

8
C/Premiere annee/TP_PI.c
View File

@ -1,8 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
float pi = (4.0/1.0) - (4.0/3.0) + (4.0/5.0) - (4.0/7.0) + (4.0/9.0) - (4.0/11.0) + (4.0/13.0) - (4.0/15.0);
printf("%f", pi);
}

30
C/Premiere annee/TP_boucle.c
View File

@ -1,30 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
char note;
printf("Entrer la note en minuscule:");
scanf("%c", &note);
switch (note){
case 'a':
printf("Votre note est entre 16 et 20.\n");
break;
case 'b':
printf("Votre note est entre 12 et 16.\n");
break;
case 'c':
printf("Votre note est entre 8 et 12.\n");
break;
case 'd':
printf("Votre note est entre 4 et 8.\n");
break;
case 'e':
printf("Votre note est entre 0 et 4.\n");
break;
default:
printf("Vous n'avez pas entrer de valeur correcte.\n");
}
}

30
C/Premiere annee/TP_boucle_if.c
View File

@ -1,30 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
char note;
printf("Entrer la note en minuscule:");
scanf("%c", &note);
if(note == 'a'){
printf("Votre note est entre 16 et 20.\n");
}else{
if(note == 'b'){
printf("Votre note est entre 12 et 16.\n");
}else{
if(note == 'c'){
printf("Votre note est entre 8 et 12.\n");
}else{
if(note == 'd'){
printf("Votre note est entre 4 et 8.\n");
}else{
if(note == 'e'){ printf("Votre note est entre 0 et 4.\n");
}
}
}
}
}
}

10
C/Premiere annee/TP_boucle_tableau7.c
View File

@ -1,10 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
int var = 7, loop;
for(loop = 0; loop <= 10; loop++){
printf("%d x 7 = %d\n", loop, loop*7);
}
}

12
C/Premiere annee/TP_boucle_tableuser.c
View File

@ -1,12 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
int var, loop;
printf("Le chiffre que vous voulez mutliplier est :");
scanf("%d", &var);
for(loop = 0; loop <= 10; loop++){
printf("%d x %d = %d\n", loop, var, loop*var);
}
}

24
C/Premiere annee/TP_population.c
View File

@ -1,24 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
float taillePopulation1, taillePopulation2, annee=0;
float tauxPopulation1, tauxPopulation2;
printf("Entrer la taille de la population 1 :");
scanf("%f", &taillePopulation1);
printf("Entrer la taille de la population 2 :");
scanf("%f", &taillePopulation2);
printf("Entrer le taux de croissance de la population 1 par an en pourcent:");
scanf("%f", &tauxPopulation1);
printf("Entrer le taux de croissance de la population 2 par an en pourcent:");
scanf("%f", &tauxPopulation2);
while(taillePopulation2 <= taillePopulation1){
annee++;
taillePopulation1 = taillePopulation1 * (tauxPopulation1/100+1);
taillePopulation2 = taillePopulation2 * (tauxPopulation2/100+1);
}
printf("La population 2 aura dépassé la population 1 au bout de %.0f année(s).", annee);
return 0;
}

109
C/Premiere annee/TP_somme.c
View File

@ -1,109 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
int boucle = 0;
while(!boucle){
int numeroExercice;
printf("Quel exercice voulez vous essayez ?\n\n");
printf("Exercice 1 : Addition\n");
printf("Exercice 2 : Division\n");
printf("Exercice 3 : Acquisition caractères\n\n");
printf("Numéro de l'exercice demandé: ");
scanf("%d", &numeroExercice);
if(numeroExercice == 1){
printf("\n\n");
printf("EXERCICE 1\n\n\n");
float premier_entier;
float second_entier;
printf("Premier chiffre: ");
scanf("%f", &premier_entier);
printf("Second chiffre: ");
scanf("%f", &second_entier);
printf("\n");
float resultat = premier_entier + second_entier;
printf("La somme est %f.\n\n\n",resultat);
printf("Voules-vous quitter le programme ?\n");
printf("0 - Non\n");
printf("1 - Oui\n");
printf("Votre choix: ");
scanf("%d", &boucle);
}else if(numeroExercice == 2){
printf("\n\n");
printf("EXERCICE 2\n\n\n");
float divise;
float diviseur;
printf("Chiffre à divisé: ");
scanf("%f", &divise);
printf("Chiffre diviseur: ");
scanf("%f", &diviseur);
printf("\n");
if(diviseur != 0){
float resultat = divise / diviseur;
printf("La division de %f par %f est %f.\n\n\n" ,divise, diviseur, resultat);
printf("Voules-vous quitter le programme ?\n");
printf("0 - Non\n");
printf("1 - Oui\n");
printf("Votre choix: ");
scanf("%d", &boucle);
}else{
printf("Le diviseur est nul, la division est donc impossible.\n\n");
printf("Voules-vous quitter le programme ?\n");
printf("0 - Non\n");
printf("1 - Oui\n");
printf("Votre choix: ");
scanf("%d", &boucle);
}
}else if(numeroExercice == 3){
printf("\n\n");
printf("EXERCICE 3\n\n\n");
char nom [80];
char prenom [80];
printf("Votre nom est: ");
scanf("%79s", nom);
printf("Votre prenom est: ");
scanf("%79s", prenom);
printf("\n");
printf("Bonjour %s %s.\n\n\n" ,prenom, nom);
printf("Voules-vous quitter le programme ?\n");
printf("0 - Non\n");
printf("1 - Oui\n");
printf("Votre choix: ");
scanf("%d", &boucle);
}else{
printf("\n");
printf("Il n'y a pas d'exercice %d.\n", numeroExercice);
printf("\n");
printf("Voules-vous quitter le programme ?\n");
printf("0 - Non\n");
printf("1 - Oui\n");
printf("Votre choix: ");
scanf("%d", &boucle);
}
}
}

45
C/Premiere annee/TP_station_meteo.c
View File

@ -1,45 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
float boolean = 1, lacune = 0, entree = 0;
float minimum = 0, maximum = 0, minimumBuffer = 0, maximumBuffer = 0;
do{
printf("Entrer température minimum :");
scanf("%f", &minimum);
printf("Entrer température maximum :");
scanf("%f", &maximum);
maximumBuffer = maximumBuffer + maximum;
minimumBuffer = minimumBuffer + minimum;
if(minimum == 0 && maximum == 0)
{
boolean = 0;
}
else
{
if(minimum == 0 || maximum == 0)
{
lacune++;
entree++;
}
else
{
entree++;
}
}
}while(boolean == 1);
if(entree != 0){
printf("La moyenne des températures maximum est de %.2f.\n", maximumBuffer/entree);
printf("La moyenne des températures minimum est de %.2f.\n", minimumBuffer/entree);
printf("Il y a eu %.0f lacune(s).\n", lacune);
printf("Il y a eu %.0f entrée(s).\n", entree);
printf("Le nombre de lacune représente %.2f pourcent du nombre de données.", ((lacune/entree)/2)*100);
}else{
printf("Vous devez entrer une valeur.\n");
}
}

24
C/Premiere annee/TP_test_negatif.c
View File

@ -1,24 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
int var = 0;
int boolean = 0;
int varPositive = 0;
int somme = 0;
while(boolean == 0){
printf("Entrer une valeur :");
scanf("%d", &var);
if(var < 0){
printf("Vous avez entré une valeure néfative.\n");
boolean++;
}else{
printf("Valeur correcte.\n");
somme = somme + var;
varPositive++;
}
}
printf("Vous avez saisi %d valeurs positives et leur somme est de %d et la moyenne est de %f.\n",
varPositive, somme, somme/varPositive);
}

15
C/Premiere annee/TP_triangle_isocele.c
View File

@ -1,15 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
int cote, loopColonne, loopLigne;
printf("Le côté du triangle est de :");
scanf("%d", &cote);
for(loopColonne=0; loopColonne < cote; loopColonne++){
for(loopLigne=1; loopLigne <= cote-loopColonne; loopLigne++){
printf("#");
}
printf("\n");
}
}

70
C/Premiere annee/Vacances_1.c
View File

@ -1,70 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
int main()
{
void affichageDate(int jour, int mois, int annee){
int choix;
do{
printf("Format d'affichage de votre date de naissance :\n");
printf("1 - jj/mm/aaaa\n");
printf("2 - jj-mm-aaaa\n");
printf("3 - jj:mm:aaaa\n");
printf("4 - jj.mm.aaaa\n");
printf("Choisissez le format d'affichage (1,2,3 ou 4) : ");
scanf("%d", &choix);
switch (choix){
case 1:
printf("Votre date de naissance est le %d/%d/%d.\n", jour, mois, annee);
break;
case 2:
printf("Votre date de naissance est le %d-%d-%d.\n", jour, mois, annee);
break;
case 3:
printf("Votre date de naissance est le %d:%d:%d.\n", jour, mois, annee);
break;
case 4:
printf("Votre date de naissance est le %d.%d.%d.\n", jour, mois, annee);
break;
default :
printf("Votre choix n'est pas correcte, réessayez.\n");
}
}while(choix != 1 || choix != 2 || choix != 3 || choix != 4);
}
int jour = 17;
int moisNum = 12;
int annee = 1991;
char nom[50] = "Herbron";
char prenom[50] = "Tanguy";
/*printf("Jour de naissance : ");
scanf("%d", &jour);
printf("Mois de naissance : ");
scanf("%d", &moisNum);
printf("Année de naissance : ");
scanf("%d", &annee);
printf("\n");
printf("Votre date de naissance est le %d/%d/%d.\n\n", jour, moisNum, annee);
printf("Votre nom : ");
scanf("%s", nom);
printf("Votre prénom : ");
scanf("%s", prenom);
printf("\n");*/
printf("Bonjour %s %s.\n\n", prenom, nom);
if(annee >= 1995){
printf("Désolé, vous êtes trop jeune pour continuer.");
}else{
printf("Vous êtes autorisé à continuer.");
affichageDate(jour, moisNum, annee);
}
return 0;
}

120
C/Premiere annee/accesFichier/biblio.c
View File

@ -1,120 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include "biblio.h"
void testErreur(){
if(errno != NULL){
printf("Erreur fichier : erreur n'%d\n", errno);
exit(0);
}
}
void exercice1Et2(){
int i;
int size;
int lettre = 0;
char car;
FILE *pFich = fopen("/home/USERS/ELEVES/SNIR2015/fichierTexte1.txt", "r");
testErreur();
fseek(pFich, 0, 2);
size = ftell(pFich);
fseek(pFich, 0, SEEK_SET);
for(i = 0; i < size; i++){
car = fgetc(pFich);
printf("%c", car);
if('a' <= car && car <= 'z'){
lettre++;
}
}
printf("\n%d caracteres minuscules non accentués dans ce fichier.\n", lettre);
}
void exercice3(){
typePersonne personne;
FILE *pFich = fopen("personnes.txt", "w+");
int i;
testErreur();
for(i = 0; i < NBPERSONNE; i++){
printf("Nouvelle personne :\n");
printf("\tNom :");
scanf("%s", personne.nom);
fprintf(pFich, "%s", personne.nom);
fprintf(pFich, "\n");
printf("\tPrenom :");
scanf("%s", personne.prenom);
fprintf(pFich, "%s", personne.prenom);
fprintf(pFich, "\n");
printf("\tAge :");
scanf("%d", &personne.age);
fprintf(pFich, "%d", personne.age);
fprintf(pFich, "\n");
printf("\tPoids :");
scanf("%.2f", &personne.poids);
fprintf(pFich, "%f", personne.poids);
fprintf(pFich, "\n");
printf("\tSexe (m ou f) :");
scanf(" %c", &personne.sexe);
fprintf(pFich, "%c", personne.sexe);
fprintf(pFich, "\n");
}
}
void exercice9(){
FILE *pFich = fopen("/home/USERS/ELEVES/SNIR2015/adeneu/personne.txt", "r");
typePersonne personneAxel;
testErreur();
fscanf(pFich, "%s", personneAxel.nom);
fscanf(pFich, "%s", personneAxel.prenom);
fscanf(pFich, "%d", personneAxel.age);
printf("%s\n", personneAxel.nom);
printf("%s\n", personneAxel.prenom);
printf("%d",personneAxel.age);
}
void exercice3HautNiveau(){
typePersonne personne;
FILE *pFich = fopen("personnes.b", "w+");
int i;
testErreur();
for(i = 0; i < NBPERSONNE; i++){
printf("Nouvelle personne :\n");
printf("\tNom :");
scanf("%s", personne.nom);
fwrite(personne.nom, 50, 1, pFich);
fwrite("\n", 2, 1, pFich);
printf("\tPrenom :");
scanf("%s", personne.prenom);
fwrite(personne.prenom, 50, 1, pFich);
fwrite("\n", 2, 1, pFich);
printf("\tAge :");
scanf("%d", &personne.age);
fwrite(&personne.age, 4, 1, pFich);
fwrite("\n", 2, 1, pFich);
printf("\tPoids :");
scanf("%.2f", &personne.poids);
fwrite(&personne.poids, 4, 1, pFich);
fwrite("\n", 2, 1, pFich);
printf("\tSexe (m ou f) :");
scanf(" %c", &personne.sexe);
fwrite(&personne.sexe, 4, 1, pFich);
fwrite("\n", 2, 1, pFich);
}
fcloseall();
}

24
C/Premiere annee/accesFichier/biblio.h
View File

@ -1,24 +0,0 @@
#ifndef BIBLIO_H_INCLUDED
#define BIBLIO_H_INCLUDED
#define NBMAXCAR 50
#define NBPERSONNE 1
typedef struct personne{
char nom[NBMAXCAR];
char prenom[NBMAXCAR];
int age;
float poids;
char sexe ; // 'f' ou 'm'
}typePersonne;
void testErreur();
void exercice1Et2();
void exercice3();
void exercice9();
void exercice3HautNiveau();
#endif // BIBLIO_H_INCLUDED

33
C/Premiere annee/accesFichier/main.c
View File

@ -1,33 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include "biblio.h"
int main(int argc, char *argv[])
{
int choix;
printf("Quel exercice voulez-vous essayer ?\n");
printf("1 - Print fichierTexte.txt et contage caracteres\n");
printf("2 - Création d'adherents bas niveau\n");
printf("3 - Création d'adherents haut niveau\n");
printf("4 - Lecture txt voisin\n");
printf("Votre choix : ");
scanf("%d", &choix);
switch(choix){
case 1:
exercice1Et2();
break;
case 2:
exercice3();
break;
case 3:
exercice3HautNiveau();
break;
case 4:
exercice9();
break;
}
return 0;
}

37
C/Premiere annee/argument1.c
View File

@ -1,37 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[])
{
float val1, val2;
char car1;
if(argc < 4){
exit(0);
}
sscanf(argv[1], "%c", &car1);
sscanf(argv[2], "%f", &val1);
sscanf(argv[3], "%f", &val2);
switch (car1){
case '+':
printf("%f\n", val1 + val2);
break;
case '*':
printf("%f\n", val1 * val2);
break;
case '/':
printf("%f\n", val1 / val2);
break;
case '-':
printf("%f\n", val1 - val2);
break;
default:
printf("Non\n");
break;
}
return 0;
}

366
C/Premiere annee/caveHunter/caveHunter.c
View File

@ -1,366 +0,0 @@
/***************************************************************************
caveHunter.c
***************************************************************************/
#include "caveHunter.h"
#include <sys/timeb.h>
#include <math.h>
#include <time.h>
// attendre un maxTime millisecondes
void msleep(unsigned int maxTime)
{
/*
struct timespec {
time_t tv_sec; // secondes
long tv_nsec; // nanosecondes
};
*/
struct timespec req;
struct timespec rem;
time_t secondes=0;
long nanoSecondes=0;
if (maxTime>=1000)
{
do
{
secondes++;
maxTime-=1000;
}
while(maxTime>=1000);
}
nanoSecondes=maxTime*1000000;
req.tv_sec=secondes;
req.tv_nsec=nanoSecondes;
nanosleep(&req,&rem);
}
void initPiege( char tab[LARGEUR][HAUTEUR], int nbPiege )
{
int x, y, i;
for ( i = 0; i < nbPiege; i++ )
{
do
{
x = aleatoire( LARGEUR );
y = aleatoire( HAUTEUR );
}
while ( tab[x][y] != 0 );
tab[x][y] = PIEGE;
}
}
void initMonstre( char tab[LARGEUR][HAUTEUR], int nbMonstre )
{
int x, y, i;
for(i = 0; i < nbMonstre; i++){
do{
x = aleatoire(LARGEUR);
y = aleatoire(HAUTEUR);
}while(tab[x][y] != 0);
tab[x][y] = MONSTRE;
}
}
void initPotion( char tab[LARGEUR][HAUTEUR], int nbPotion )
{
int x, y, i;
for(i = 0; i < nbPotion; i++){
do{
x = aleatoire(LARGEUR);
y = aleatoire(HAUTEUR);
}while(tab[x][y] != 0);
tab[x][y] = POTION;
}
}
void initSortie(char tab[LARGEUR][HAUTEUR])
{
int x, y;
x = aleatoire(LARGEUR);
y = aleatoire(HAUTEUR);
tab[x][y] = SORTIE;
}
void initMonde( char tab[LARGEUR][HAUTEUR], int nbMonstre, int nbPotion, int nbPiege )
{
int x, y;
printf("veuillez patientez, creation du monde...\n");
for ( x = 0; x < LARGEUR; x++ )
{
for ( y = 0; y < HAUTEUR; y++ )
{
tab[x][y] = 0;
}
}
// placer tresor
x = aleatoire( LARGEUR );
y = aleatoire( HAUTEUR );
tab[x][y] = TRESOR;
initPotion( tab, nbPotion );
initMonstre( tab, nbMonstre );
initPiege( tab, nbPiege );
initSortie(tab);
}
void afficheMonde( char tab[LARGEUR][HAUTEUR], int posX, int posY )
{
int x, y, cadre, i;
// afficher haut du cadre
for(i = 0; i <= LARGEUR+1; i++){
printf("*");
}
printf("\n");
//afficher les bords du cadre et l'aire de jeu
for ( y = HAUTEUR - 1; y >= 0; y-- )
{
// bord gauche
printf( "*" );
// aire de jeu
for ( x = 0; x < LARGEUR; x++ )
{
// afficher un . pour representer l'aire de jeu
// afficher une X si x,y sont la position du joueur
if(x == posX && y == posY){
printf("X");
}else{
printf(".");
}
}
// bord droit
printf( "*" );
printf( "\n" );
}
// afficher bas du cadre
for(i = 0; i <= LARGEUR+1; i++){
printf("*");
}
printf("\n");
// afficher les coordonnees du joueur
printf( "pos(%d,%d) ", posX, posY );
}
//retourne une valeur entiere E[0..maxAlea[
unsigned int aleatoire( unsigned int maxAlea )
{
/* struct timeb {
time_t time;
unsigned short millitm;
short timezone;
short dstflag;
};*/
struct timeb t;
//long t;
float a, b ;
unsigned int nbmilli;
ftime( &t );
nbmilli = t.time * 1000 + t.millitm;
srand( nbmilli );
a = rand();
b = ( maxAlea * a ) / RAND_MAX;
//printf( "in alea %i\n", nbmilli );
msleep(100);
return( ( unsigned int )b );
}
unsigned int getXTresor( char tab[LARGEUR][HAUTEUR] )
{
int x = 0, y;
int retour = -1;
do
{
y = 0;
do
{
if ( ( tab[x][y] ) == TRESOR )
{
retour = x;
}
y++;
}
while ( y < HAUTEUR && retour == -1 );
x++;
}
while ( x < LARGEUR && retour == -1 );
return retour;
}
unsigned int getYTresor( char tab[LARGEUR][HAUTEUR] )
{
int x, y=0;
int retour = -1;
do
{
x = 0;
do
{
if ( ( tab[x][y] ) == TRESOR )
{
retour = y;
}
x++;
}
while ( x < LARGEUR && retour == -1 );
y++;
}
while ( y < HAUTEUR && retour == -1 );
return retour;
}
unsigned int getXSortie( char tab[LARGEUR][HAUTEUR] )
{
int x = 0, y;
int retour = -1;
do
{
y = 0;
do
{
if ( ( tab[x][y] ) == SORTIE )
{
retour = x;
}
y++;
}
while ( y < HAUTEUR && retour == -1 );
x++;
}
while ( x < LARGEUR && retour == -1 );
return retour;
}
unsigned int getYSortie( char tab[LARGEUR][HAUTEUR] )
{
int x, y=0;
int retour = -1;
do
{
x = 0;
do
{
if ( ( tab[x][y] ) == SORTIE )
{
retour = y;
}
x++;
}
while ( x < LARGEUR && retour == -1 );
y++;
}
while ( y < HAUTEUR && retour == -1 );
return retour;
}
float getDistance( unsigned int xt, unsigned int yt, unsigned int xp, unsigned int yp )
{
int xVecteur=xt-xp;
int yVecteur=yt-yp;
float module;
module=sqrt((xVecteur*xVecteur+yVecteur*yVecteur));
return module;
}
void afficheTresor()
{
printf(" _______ _____ ______ _____ ____ _____ \n |__ __| __ \\| ____|/ ____|/ __ \\| __ \\ \n | | | |__) | |__ | (___ | | | | |__) |\n | | | _ /| __| \\___ \\| | | | _ / \n | | | | \\ \\| |____ ____) | |__| | | \\ \\ \n |_| |_| \\_\\______|_____/ \\____/|_| \\_\\\n");
}
void afficheMonstre()
{
printf(" __ __ ____ _ _ _____ _______ _____ ______ \n | \\/ |/ __ \\| \\ | |/ ____|__ __| __ \\| ____|\n | \\ / | | | | \\| | (___ | | | |__) | |__ \n | |\\/| | | | | . ` |\\___ \\ | | | _ /| __| \n | | | | |__| | |\\ |____) | | | | | \\ \\| |____ \n |_| |_|\\____/|_| \\_|_____/ |_| |_| \\_\\______|\n");
}
void affichePotion()
{
printf(" _____ _ _ _ _ \n | __ \\ | | (_) | | (_) \n | |__) |__ | |_ _ ___ _ __ __| | ___ ___ ___ _ _ __ \n | ___/ _ \\| __| |/ _ \\| '_ \\ / _` |/ _ \\ / __|/ _ \\| | '_ \\ \n | | | (_) | |_| | (_) | | | | | (_| | __/ \\__ \\ (_) | | | | |\n |_| \\___/ \\__|_|\\___/|_| |_| \\__,_|\\___| |___/\\___/|_|_| |_|\n");
}
void affichePiege()
{
printf(" _ \n (_) \n ___ _ _ _ __ ___ _ _ _ __ _ __ _ ___ __ _ ___ \n / _ \\| | | | '_ \\/ __| | | | | '_ \\ | '_ \\| |/ _ \\/ _` |/ _ \\\n | (_) | |_| | |_) \\__ \\_ | |_| | | | | | |_) | | __/ (_| | __/\n \\___/ \\__,_| .__/|___( ) \\__,_|_| |_| | .__/|_|\\___|\\__, |\\___|\n | | |/ | | __/ | \n |_| |_| |___/ \n");
}
void afficheSortie()
{
printf(" ________ _______ _______ \n | ____\\ \\ / /_ _|__ __|\n | |__ \\ V / | | | | \n | __| > < | | | | \n | |____ / . \\ _| |_ | | \n |______/_/ \\_\\_____| |_| \n");
}
void affichePerdu()
{
printf(" (\\ _ /)\n ( \\ O / )\n (// \\\\)\n X\n / \\\n /___\\\n _____/ \\\\_____\n | ||\n | ||\n | ||\n | _ ___ _ ||\n | | \\ | | \\ ||\n | | | | | | ||\n | |_/ | |_/ ||\n | | \\ | | ||\n | | \\ | | ||\n | | \\. _|_. | . ||\n | ||\n * * | * ** * ** |** **\n ");
}

38
C/Premiere annee/caveHunter/caveHunter.h
View File

@ -1,38 +0,0 @@
/***************************************************************************
caveHunter.h
***************************************************************************/
#ifndef TRESOR_H
#define TRESOR_H
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#define LARGEUR 20
#define HAUTEUR 10
#define TRESOR 4
#define SORTIE 5
#define PIEGE 2
#define MONSTRE 1
#define POTION 3
#define VIE 4
void initMonde( char tab[LARGEUR][HAUTEUR], int nbMonstre, int nbPotion, int nbPiege );
unsigned int aleatoire(unsigned int maxAlea);
void initPiege( char tab[LARGEUR][HAUTEUR], int nbPiege );
void initMonstre( char tab[LARGEUR][HAUTEUR], int nbMonstre );
void initPotion( char tab[LARGEUR][HAUTEUR], int nbPotion );
void afficheMonde( char tab[LARGEUR][HAUTEUR] , int posX, int posY );
unsigned int getXTresor(char tab[LARGEUR][HAUTEUR]);
unsigned int getYTresor(char tab[LARGEUR][HAUTEUR]);
unsigned int getXSortie(char tab[LARGEUR][HAUTEUR]);
unsigned int getYSortie(char tab[LARGEUR][HAUTEUR]);
void afficheTresor();
void afficheMonstre();
void affichePotion();
void affichePiege();
void afficheSortie();
void affichePerdu();
float getDistance(unsigned int xt,unsigned int yt,unsigned int xp,unsigned int yp);
#endif

167
C/Premiere annee/caveHunter/main.c
View File

@ -1,167 +0,0 @@
#include "caveHunter.h"
int main( int argc, char *argv[] )
{
char monde[LARGEUR][HAUTEUR];
int i;
int x, y;
int sortie = 1;
int tresor = 0;
int vie ;
unsigned char dir;
char choix;
do
{
initMonde(monde,10,2,5); // 10 monstres, 2 potions et 5 pieges
x = LARGEUR / 2;
y = HAUTEUR / 2;
sortie = 1;
tresor = 0;
vie = VIE;
do
{
afficheMonde( monde, x, y );
printf( " Vie[%d] ", vie );
if ( tresor == 0 )
{
printf( "(tresor a %.1f m)\n", getDistance( x, y, getXTresor( monde ), getYTresor( monde ) ) );
}
else
{
printf( "(sortie a %.1f m)\n", getDistance( x, y, getXSortie( monde ), getYSortie( monde ) ) );
}
printf( "direction : " );
scanf( " %c", &dir );
switch ( dir )
{
case '7':
x--;
y++;
break;
case '8':
y++;
break;
case '9':
x++;
y++;
break;
case '4':
x--;
break;
case '6':
x++;
break;
case '1':
x--;
y--;
break;
case '2':
y--;
break;
case '3':
x++;
y--;
break;
}
if ( x == LARGEUR )
{
x = LARGEUR - 1;
}
if ( x == -1 )
{
x = 0;
}
if ( y == HAUTEUR )
{
y = HAUTEUR - 1;
}
if ( y == -1 )
{
y = 0;
}
switch ( monde[x][y] )
{
case MONSTRE:
vie -= MONSTRE;
afficheMonstre();
printf( "un monstre!!! vous perdez %d pv\n", MONSTRE );
break;
case PIEGE:
vie -= PIEGE;
affichePiege();
printf("arg, un piege!!! %d pv en moins\n", PIEGE);
break;
case POTION:
vie += POTION;
affichePotion();
printf("une potion de soin! %d pv en plus\n", POTION);
break;
case SORTIE:
if ( tresor == 1 )
{
sortie = 0;
}
afficheSortie();
printf( "La sortie\n" );
break;
case TRESOR:
tresor = 1;
afficheTresor();
printf( "vous avez trouve le tresor. reste a trouver la sortie\n" );
break;
}
if ( vie <= 0 )
{
sortie = 0;
}
}
while ( sortie == 1 );
if ( vie <= 0 )
{
affichePerdu();
printf( "vous avez perdu\n" );
}
else
{
printf( "congratulation!!\n" );
}
printf("\nUne autre partie (O/N)?");
scanf(" %c",&choix);
}
while (choix=='o' || choix=='O');
return EXIT_SUCCESS;
}

45
C/Premiere annee/cercle/cercle.c
View File

@ -1,45 +0,0 @@
/*********************************************************************
Nom du projet : cercle
Nom du fichier : cercle.c
*********************************************************************/
#include "cercle.h"
#include <stdio.h>
#include <stdlib.h>
typeCercle *creerCercle(double xx, double yy, double rr)
{
typeCercle *c;
c=(typeCercle *)malloc(sizeof(typeCercle));
c->rayon=rr;
c->x=xx;
c->y=yy;
return c;
}
void deplacerCercle(double nouveauX, double nouveauY, typeCercle *ptrCercle)
{
ptrCercle->x=nouveauX;
ptrCercle->y=nouveauY;
}
void changerRayonCercle(double nouveauRayon, typeCercle *ptrCercle)
{
ptrCercle->rayon=nouveauRayon;
}
void afficherCercle(typeCercle *ptrCercle)
{
printf("x : %.2f\n",ptrCercle->x);
printf("y : %.2f\n",ptrCercle->y);
printf("rayon : %.2f\n\n",ptrCercle->rayon);
}
float calculerPerimetre(typeCercle *ptrCercle)
{
float perimetreCercle = 0;
perimetreCercle = 2 * M_PI * ptrCercle->rayon;
return perimetreCercle;
}

18
C/Premiere annee/cercle/cercle.h
View File

@ -1,18 +0,0 @@
#ifndef CERCLE_H_INCLUDED
#define CERCLE_H_INCLUDED
#include <math.h>
typedef struct {
double x;
double y;
double rayon;
}typeCercle;
typeCercle *creerCercle(double xx, double yy, double rr);
void deplacerCercle(double nouveauX, double nouveauY, typeCercle *ptrCercle);
void changerRayonCercle(double nouveauRayon, typeCercle *ptrCercle);
void afficherCercle(typeCercle *ptrCercle);
float calculerPerimetre(typeCercle *ptrCercle);
#endif // CERCLE_H_INCLUDED

23
C/Premiere annee/cercle/main.c
View File

@ -1,23 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include "cercle.h"
int main()
{
typeCercle *c1;
typeCercle *c2;
c1=creerCercle(3,5,10); // un cercle en (3,5) rayon 10
c2=creerCercle(-2,4,3); // un cercle en (-2,4) rayon 3
afficherCercle(c1);
printf("Le périmètre de C1 = %f\n", calculerPerimetre(c1));
afficherCercle(c2);
printf("Le périmètre de C2 = %f\n", calculerPerimetre(c2));
deplacerCercle(1,2,c1); // le cercle c1 est a present en (1,2)
afficherCercle(c1);
printf("Le périmètre de C1 = %f\n", calculerPerimetre(c1));
changerRayonCercle(6,c2); // le cercle c2 a un nouveau rayon de 6
afficherCercle(c2);
printf("Le périmètre de C2 = %f\n", calculerPerimetre(c2));
return 0;
}

149
C/Premiere annee/conversionRLE/biblio.c
View File

@ -1,149 +0,0 @@
#include "biblio.h"
void testErreur(int retour, int valeurCorrecte, char messageErreur[])
{
if(retour != valeurCorrecte)
{
printf("Erreur lors de : %s.%d\n", messageErreur, errno);
exit(0);
}
}
void decompressBMP(char fichierCompresse[], char fichierGenere[])
{
int i;
enTeteFichierBMP enTeteFichier;
enTeteImageBMP enTeteImage;
rle couple;
couleur palette[NBCOULEURS];
FILE *imageCompress = fopen(fichierCompresse, "r");
FILE *imageGenere = fopen(fichierGenere, "w+");
if(imageCompress == NULL){
printf("Impossible car le premier fichier est invalide.\n");
exit(0);
}
if(imageGenere == NULL){
printf("Impossible car le second fichier est invalide.\n");
exit(0);
}
testErreur(fread(&enTeteFichier, sizeof(enTeteFichier), 1, imageCompress), 1, "copie enTeteFichier");
testErreur(fwrite(&enTeteFichier, sizeof(enTeteFichier), 1, imageGenere), 1, "ecriture enTeteFichier");
testErreur(fread(&enTeteImage, sizeof(enTeteImage), 1, imageCompress), 1, "copie enTeteImage");
enTeteImage.typeCompression = 0;
testErreur(fwrite(&enTeteImage, sizeof(enTeteImage), 1, imageGenere), 1, "ecriture enTeteImage");
testErreur(fread(palette, sizeof(couleur), NBCOULEURS, imageCompress), NBCOULEURS, "copie palette");
testErreur(fwrite(palette, sizeof(couleur), NBCOULEURS, imageGenere), NBCOULEURS, "ecriture palette");
while(fread(&couple, sizeof(rle), 1, imageCompress) == 1)
{
for(i = 0; i < couple.repetition; i++)
{
testErreur(fwrite(&couple.valCouleur, sizeof(char), 1, imageGenere), 1, "ecriture valCouleur");
}
}
fclose(imageCompress);
fclose(imageGenere);
}
void compresBMP(char fichierDecompresse[], char fichierGenere[])
{
char valOctet;
char octetSuivant;
unsigned int ligne;
short int compteur;
char finLigne = 0;
enTeteFichierBMP enTeteFichier;
enTeteImageBMP enTeteImage;
couleur palette[NBCOULEURS];
FILE *imageDecompress = fopen(("%s%s", fichierDecompresse, ".bmp"), "r");
FILE *imageGenere = fopen(fichierGenere, "w+");
if(imageDecompress == NULL){
printf("Impossible car le premier fichier est invalide.\n");
exit(0);
}
if(imageGenere == NULL){
printf("Impossible car le second fichier est invalide.\n");
exit(0);
}
testErreur(fread(&enTeteFichier, sizeof(enTeteFichier), 1, imageDecompress), 1, "copie enTeteFichier");
testErreur(fwrite(&enTeteFichier, sizeof(enTeteFichier), 1, imageGenere), 1, "ecriture enTeteFichier");
testErreur(fread(&enTeteImage, sizeof(enTeteImage), 1, imageDecompress), 1, "copie enTeteImage");
enTeteImage.typeCompression = 1;
testErreur(fwrite(&enTeteImage, sizeof(enTeteImage), 1, imageGenere), 1, "ecriture enTeteImage");
testErreur(fread(palette, sizeof(couleur), NBCOULEURS, imageDecompress), NBCOULEURS, "copie palette");
testErreur(fwrite(palette, sizeof(couleur), NBCOULEURS, imageGenere), NBCOULEURS, "ecriture palette");
testErreur(fread(&valOctet, sizeof(char), 1, imageDecompress), 1, "premier valOctet");
compteur = 0;
ligne = 0;
while(fread(&octetSuivant, sizeof(char), 1, imageDecompress) == 1)
{
if(valOctet == octetSuivant && compteur < 255 && ligne < enTeteImage.largeur)
{
compteur++;
ligne++;
}
else
{
testErreur(fwrite(&compteur, sizeof(char), 1, imageGenere), 1, "ecriture compteur");
testErreur(fwrite(&valOctet, sizeof(char), 1, imageGenere), 1, "ecriture valOctet");
compteur = 0;
valOctet = octetSuivant;
if(ligne >= enTeteImage.largeur)
{
testErreur(fwrite(&finLigne, sizeof(char), 1, imageGenere), 1, "ecriture retourLigne");
testErreur(fwrite(&finLigne, sizeof(char), 1, imageGenere), 1, "ecriture retourLigne");
ligne = 0;
}
}
}
testErreur(fwrite("0", sizeof(char), 1, imageGenere), 1, "ecriture finFichier");
testErreur(fwrite("1", sizeof(char), 1, imageGenere), 1, "ecriture finFichier");
fclose(imageDecompress);
fclose(imageGenere);
}
void compressBMP(char fichierDecompresse[], char fichierGenere[])
{
char octet;
char ch;
char* nomfichier = "RLE.bmp";
strcat(fichierDecompresse, nomfichier);
FILE *imageDecompress = fopen(fichierDecompresse, "r");
FILE *imageGenere = fopen(fichierGenere, "w+");
if(imageDecompress == NULL){
printf("Impossible car le premier fichier est invalide. %s\n", fichierDecompresse);
exit(0);
}
if(imageGenere == NULL){
printf("Impossible car le second fichier est invalide.\n");
exit(0);
}
while(fread(&octet, sizeof(char), 1, imageDecompress) == 1)
{
testErreur(fwrite(&octet, sizeof(char), 1, imageGenere), 1, "ecriture compteur");
}
fclose(imageDecompress);
fclose(imageGenere);
}

52
C/Premiere annee/conversionRLE/biblio.h
View File

@ -1,52 +0,0 @@
#ifndef BIBLIO_H_INCLUDED
#define BIBLIO_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#define NBCOULEURS 256
#define TAILLEMAX 50
#pragma pack(push, 1)
typedef struct
{
unsigned char repetition;
unsigned char valCouleur;
}rle;
typedef struct
{
unsigned char signature[2];
unsigned int tailleFichier;
unsigned int reserve;
unsigned int adresseRelative;
}enTeteFichierBMP;
typedef struct
{
unsigned int tailleEnTete;
unsigned int largeur;
unsigned int hauteur;
unsigned short nbPlan;
unsigned short bitParPixel;
unsigned int typeCompression;
unsigned int tailleImage;
unsigned int resoHorizontale;
unsigned int resoVerticale;
unsigned int nbCouleursUtilisees;
unsigned int nbCouleursImportantes;
}enTeteImageBMP;
typedef struct
{
unsigned char bleu;
unsigned char vert;
unsigned char rouge;
unsigned char alpha;
}couleur;
#endif // BIBLIO_H_INCLUDED

17
C/Premiere annee/conversionRLE/main.c
View File

@ -1,17 +0,0 @@
#include "biblio.h"
int main(int argc, char *argv[])
{
if(argc == 4)
{
if(strcmp(argv[1], "d") == 0)
{
decompressBMP(argv[2], argv[3]);
}
if(strcmp(argv[1], "c") == 0)
{
compressBMP(argv[2], argv[3]);
}
}
}

400
C/Premiere annee/exoVacances.c
View File

@ -1,400 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/timeb.h>
#include <math.h>
#include <ctype.h>
#include <unistd.h>
#include <time.h>
#define TAILLEMAX 50
void formatageDate(int jour, int mois, int annee){
int choixFormatage;
do{
printf("Format d'affichage de votre date de naissance : \n");
printf("1 - jj/mm/aaaa\n");
printf("2 - jj-mm-aaaa\n");
printf("3 - jj:mm:aaaa\n");
printf("4 - jj.mm.aaaa\n");
printf("Choisissez le format d'affichage (1, 2, 3 ou 4) : ");
scanf("%d", &choixFormatage);
switch (choixFormatage){
case 1:
printf("Votre date de naissance est le %d/%d/%d.\n\n", jour, mois, annee);
break;
case 2:
printf("Votre date de naissance est le %d-%d-%d.\n\n", jour, mois, annee);
break;
case 3:
printf("Votre date de naissance est le %d:%d:%d.\n\n", jour, mois, annee);
break;
case 4:
printf("Votre date de naissance est le %d.%d.%d.\n\n", jour, mois, annee);
break;
default:
printf("La valeur entrée est incorrecte, réessayez.\n");
}
}while(choixFormatage < 1 || choixFormatage > 4);
}
int acquisitionJourNaissance(){
int jour;
do{
printf("Jour de naissance : ");
scanf("%d", &jour);
}while(jour < 1 || jour > 31);
printf("Jour correcte.\n");
return jour;
}
int acquisitionMoisNaissance(){
int mois;
do{
printf("Mois de naissance : ");
scanf("%d", &mois);
}while(mois < 1 || mois > 12);
printf("Mois correcte.\n");
return mois;
}
int acquisitionAnneeNaissance(){
int annee;
do{
printf("Année de naissance : ");
scanf("%d", &annee);
}while(annee < 1900 || annee > 2013);
printf("Année correcte.\n");
return annee;
}
void comptageMois(int jour, int mois, int annee, int tabJourMois[]){
int deroulementMois;
int nbMoisPlus30 = 0;
for(deroulementMois = 0; deroulementMois < 12; deroulementMois++){
printf("Le mois numéro %d contient %d jours.\n", deroulementMois+1, tabJourMois[deroulementMois]);
if(tabJourMois[deroulementMois] > 30){
nbMoisPlus30++;
}
}
printf("Il y a %d mois ayant plus de 30 jours dans l'année.\n\n", nbMoisPlus30);
}
void verificationDateNaissance(int jour, int mois, int tabJourMois[]){
if(jour <= tabJourMois[mois-1]){
printf("Votre date de naissance semble correcte car le mois numéro %d ne possède que %d jours.\n\n", mois, tabJourMois[mois-1]);
}else{
printf("Votre date de naissance est impossible car le mois numéro %d ne possède que %d jours.\n\n", mois, tabJourMois[mois-1]);
}
}
void affichageNomMois(int jour, int mois, int annee){
char tabNomMois[12][10] = {"Janvier", "Février", "Mars", "Avril", "Mais", "Juin", "Juillet", "Aout", "Septembre", "Octobre", "Novembre", "Décembre"};
int deroulementMois;
for(deroulementMois = 0; deroulementMois < 12; deroulementMois++){
printf("Le mois numéro %d a pour nom %s.\n", deroulementMois+1, tabNomMois[deroulementMois]);
}
printf("\n");
printf("Votre date de naissance est le %d %s %d.\n", jour, tabNomMois[mois - 1], annee);
}
void msleep(unsigned int maxTime){
struct timespec req;
struct timespec rem;
timer_t secondes = 0;
long nanoSecondes = 0;
if(maxTime>=1000){
do{
secondes++;
maxTime-=1000;
}while(maxTime>=1000);
}
nanoSecondes = maxTime*1000000;
req.tv_sec = secondes;
req.tv_nsec = nanoSecondes;
nanosleep(&req, &rem);
}
unsigned int aleatoire(unsigned int maxAlea){
struct timeb t;
float a, b;
unsigned int nbmilli;
ftime(&t);
nbmilli = t.time * 1000 + t.millitm;
srand(nbmilli);
a = rand();
b = (maxAlea * a) / RAND_MAX;
msleep(250);
return((unsigned int) b);
}
void effacerEcran(){
printf("%c[2J", 0x1B);
printf("\033[50A");
}
int comptageCaractere(char proposition[]){
int nombre;
for(nombre = 0; proposition[nombre] != 0; nombre++){}
return nombre;
}
void ecrireTextePendu(int nbCaractere, char carBon[TAILLEMAX]){
int boucle;
for(boucle = 0; boucle < nbCaractere; boucle++){
if(carBon[boucle] != '\0'){
printf("%c ", carBon[boucle]);
}else{
printf("_ ");
}
}
printf("\n");
}
char verificationPendu(char aDeviner, char proposition, char carBon){
if(aDeviner == proposition){
return aDeviner;
}else{
if(carBon != '\0'){}
else{
return '\0';
}
}
}
void dessinerPendu(int lePendu){
switch (lePendu){
case 1:
printf(" \n \n \n \n \n \n \n \n \n \n");
break;
case 2:
printf(" \n \n \n \n \n \n \n \n \n \n==================");
break;
case 3:
printf(" \n || \n || \n || \n || \n || \n ||\n ||\n ||\n ||\n==================");
break;
case 4:
printf(" \n || \n || \n || \n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 5:
printf(" \n || / \n || / \n ||/ \n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 6:
printf("\n ,==========Y===\n || / \n || / \n ||/ \n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 7:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ \n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 8:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || \n || \n ||\n ||\n /||\n //||\n==================");
break;
case 9:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || |\n || \n ||\n ||\n /||\n //||\n==================");
break;
case 10:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\n || \n ||\n ||\n /||\n //||\n==================");
break;
case 11:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\\\n || \n ||\n ||\n /||\n //||\n==================");
break;
case 12:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\\\n || /\n ||\n ||\n /||\n //||\n==================");
break;
case 13:
printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\\\n || /|\n ||\n ||\n /||\n //||\n==================");
break;
}
printf("\n");
}
void exercice1(){
int jour;
int mois;
int annee;
int tabJourMois[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30 ,31};
char nom[TAILLEMAX];
char prenom[TAILLEMAX];
printf("Bienvenue dans l'exercice de synthèse !\n\n");
annee = acquisitionAnneeNaissance();
mois = acquisitionMoisNaissance();
jour = acquisitionJourNaissance();
printf("\n");
printf("Votre date de naissance est le %d/%d/%d.\n\n", jour, mois, annee);
printf("Votre nom : ");
scanf("%s", nom);
printf("Votre prénom : ");
scanf("%s", prenom);
printf("\n");
printf("Bonjour %s %s.\n", prenom, nom);
if(annee >= 1995){
printf("Désolé, vous êtes trop jeune.");
}else{
printf("Vous êtes autorisé à continuer.");
formatageDate(jour, mois, annee);
comptageMois(jour, mois, annee, tabJourMois);
verificationDateNaissance(jour, mois, tabJourMois);
affichageNomMois(jour, mois, annee);
}
}
void exercice2(){
char proposition[5];
char couleur[5] = {'r', 'r', 'v', 'b', 'b'};
int deroulementCouleur;
int nbPosBon;
int tentative = 0;
printf("Bienvenue dans le jeu MinorMind !\n\n");
printf("Arriverez vous à deviner la couleur ?\n");
do{
tentative++;
printf("Votre proposition (ex: rbvbr) : ");
scanf(" %c%c%c%c%c", &proposition[0], &proposition[1], &proposition[2], &proposition[3], &proposition[4]);
nbPosBon = 0;
if((proposition[0] == 'r' || proposition[0] == 'v' || proposition[0] == 'b')
&& (proposition[1] == 'r' || proposition[1] == 'v' || proposition[1] == 'b')
&& (proposition[2] == 'r' || proposition[2] == 'v' || proposition[2] == 'b')
&& (proposition[3] == 'r' || proposition[3] == 'v' || proposition[3] == 'b')
&& (proposition[4] == 'r' || proposition[4] == 'v' || proposition[4] == 'b')){
for(deroulementCouleur = 0; deroulementCouleur < 5; deroulementCouleur++){
if(proposition[deroulementCouleur] == couleur[deroulementCouleur]){
nbPosBon++;
}
}
printf("%d de vos couleurs sont à la bonne place.\n", nbPosBon);
}else{
printf("Saisie incorrecte.\n");
}
}while(nbPosBon < 5);
printf("Félicitations !\n");
printf("La séquence %c%c%c%c%c était la bonne !\n", couleur[0], couleur[1], couleur[2], couleur[3], couleur[4]);
printf("Vous avez réussi à trouver la bonne séquence en %d tentative(s).\n", tentative);
}
void exercice3(){
char phrasesENA[4][8][255] = {{"Mesdames, mesieurs, ", "Je reste fondamentalement persuadé que ", "Dès lors, sachez que je me battrai pour faire admettre que", "Par ailleurs, c'est en toute connaissance de cause que je peux affirmer aujourd'hui que ", "Je tiens à vous dire ici ma détermination sans faille pour clamer haut et fort que ", "J'ai depuis longtemps (ai-je besoin de vous le rappeler?), défendu l'idée que ", "Et c'est en toute conscience que je déclare avec conviction que ", "Et ce n'est certainement pas vous, mes chers compatriotes, qui me contredirez si je vous dis que "},
{"la conjoncture actuelle ", "la situation d'exclusion que certains d'entre vous connaissent ", "l'acuité des problèmes de la vie quotidienne ", "la volonté farouche de sortir notre pays de la crise ", "l'effort prioritaire en faveur de statut précaire des exclus ", "le particularisme dû à notre histoire unique ", "l'aspiration plus que légitime de chacun au progrès social ", "la nécessité de répondre à votre inquiétude journalière, que vous soyez jeunes ou âgés, ", "Je reste fondamentalement persuadé que "},
{"doit s'intégrer à la finalisation globale ", "oblige à la prise en compte encore plus effective ", "interpelle le citoyen que je suis et nous oblige tous à aller de l'avant dans la voie ", "a pour conséquence obligatoire l'urgente nécessité ", "conforte mon désir incontestable d'aller dans le sens ", "doit nous amener au choix réellement impératif ", "doit prendre en compte les préoccupations de la population de la base dans l'élaboration ", "entraine une mission somme toute des plus exaltantes pour moi : l'élaboration "},
{"d'un projet porteur de véritable espoirs, notamment pour les plus démunis.", "d'un programme plus humain, plus fraternel et plus juste.", "de solutions rapides correspondant aux grands axes sociaux prioritaies.", "d'un plan correspondant véritablement aux exigences légitimes de chacun.", "d'une valorisation sans concession de nors caractères spécifiques.", "d'une restructuration dans laquelle chacun pourra enfin retrouver sa dignité.", "d'un avenir s'orientant vers plus de progrès et plus de justice.", "d'un processus allant vers plus d'égalité."}};
int nbPhrase;
int genererPhrase;
printf("Combien de phrases voulez-vous générer ?");
scanf("%d", &nbPhrase);
for(genererPhrase = 0; genererPhrase < nbPhrase; genererPhrase++){
printf("%d :\n", genererPhrase+1);
printf("%s%s%s%s", phrasesENA[0][aleatoire(7)], phrasesENA[1][aleatoire(7)]
, phrasesENA[2][aleatoire(7)], phrasesENA[3][aleatoire(7)]);
printf("\n");
}
}
void exercice4(){
char proposition;
char carBon[TAILLEMAX];
char comparaisonCarBon[TAILLEMAX];
char aDeviner[TAILLEMAX];
int nbCaractere;
int curseur;
int lePendu = 1;
int comparaison;
printf("Bienvenue dans le jeu du pendu !\n\n");
printf("Saisir le mot à deviner :");
scanf("%s", aDeviner);
effacerEcran();
do{
printf("\nProposer une lettre :");
scanf(" %c", &proposition);
effacerEcran();
for(curseur = 0; curseur < TAILLEMAX; curseur++){
comparaisonCarBon[curseur] = carBon[curseur];
}
nbCaractere = comptageCaractere(aDeviner);
for(curseur = 0; curseur < TAILLEMAX; curseur++){
carBon[curseur] = verificationPendu(aDeviner[curseur], proposition, carBon[curseur]);
}
if(strcmp(comparaisonCarBon, carBon) == 0){
lePendu++;
printf("Votre lettre n'est pas présente dans le mot à deviner.\n");
}else{
printf("Votre lettre est bien dans le mot à deviner.\n");
}
for(curseur = 0; curseur < 50; curseur++){
comparaisonCarBon[curseur] = carBon[curseur];
}
ecrireTextePendu(nbCaractere, carBon);
dessinerPendu(lePendu);
}while((strcmp(carBon, aDeviner) != 0) && (lePendu < 13));
if(lePendu == 13){
effacerEcran();
printf("GAME OVER\n\n");
printf("Vous avez tué notre bon vieux M.Bidochon...\n");
printf("Le mot était %s.\n", aDeviner);
}else{
effacerEcran();
printf("Vous avez gagné, félicitations ! \nVous avez sauvé M.Bidochon de la pendaison.\n");
printf("\nLe mot à deviner était bien %s !\n", aDeviner);
}
}
int main()
{
int numExercice;
do{
printf("Bienvenue dans le programme d'occupation de vacances.\n");
printf("Quel exercice souhaitez-vous essayer ?\n");
printf("1 - Synthèse Septembre Octobre\n");
printf("2 - MinorMind\n");
printf("3 - Générateur de langue de bois\n");
printf("4 - Le pendu\n");
printf("Votre choix : ");
scanf("%d", &numExercice);
switch (numExercice){
case 1:
effacerEcran();
exercice1();
break;
case 2:
effacerEcran();
exercice2();
break;
case 3:
effacerEcran();
exercice3();
break;
case 4:
effacerEcran();
exercice4();
break;
default:
printf("La valeur est incorrecte, réessayez.");
}
}while(numExercice < 1 || numExercice > 4);
}

1
C/Premiere annee/golfPourEtudiants/.~lock.tpctrlGolf_2015.odt#
View File

@ -1 +0,0 @@
,dbernard,b108tu4p4.depinfo.touchard.edu,14.01.2016 08:26,file:///home/USERS/PROFS/dbernard/.config/libreoffice/4;

839
C/Premiere annee/golfPourEtudiants/golf.c
View File

@ -1,839 +0,0 @@
/***************************************************************************
golf.c
***************************************************************************/
#include "golf.h"
/*
* paramètre d'entrées : le nombre actuel d'element(s) du tableau
*
* en entrées :
*
* paramètre de sortie
*
* paramètre d'E/S un tableau de pointeur(s) sur parcours
*
* en sortie :
* valeur retournée : le nouveau nombre de parcours present dans le tableau
*
* DESCRIPTION : creation dynamique d'un parcours, initialisation
* et ajout de ce dernier dans le tableau des parcours
*
*/
int creerParcours( typeParcours *tab[], int nbParcours )
{
int i;
// creation du parcours a l'indice nbParcours
tab[nbParcours] = ( typeParcours* ) malloc( sizeof( typeParcours ) );
printf( "\nnom du parcours " );
scanf( "%s", tab[nbParcours]->nom );
printf( "nombre de trous " );
scanf( "%d", &tab[nbParcours]->nbTrou );
// initialisation des trous
for ( i = 0;i < tab[nbParcours]->nbTrou;i++ )
{
printf( "numero du trou : %d\n", i + 1 );
tab[nbParcours]->listeTrous[i].numero = i + 1;
printf( "distance (en metre) : " );
scanf( "%f", &tab[nbParcours]->listeTrous[i].distance );
printf( "valeur du par : " );
scanf( "%d", &tab[nbParcours]->listeTrous[i].par );
printf( "nombre maximum de coups pour ce trou : " );
scanf( "%d", &tab[nbParcours]->listeTrous[i].nbMaxCoups );
}
return nbParcours + 1;
}
/*
* paramètre d'entrées : un tableau de pointeur(s) sur parcours
le numero d'index du parcours a afficher
*
* en entrées :
*
* paramètre de sortie
*
* paramètre d'E/S
*
* en sortie : affichage de info à l'ecran
* valeur retournée :
*
* DESCRIPTION : afficher les informations d'un parcours particulier
*
*/
void afficherUnParcours( typeParcours *tab[], int nro )
{
int i;
printf( "\nnom du parcours %s\n", tab[nro]->nom );
printf( "nombre de trous %d\n", tab[nro]->nbTrou );
// afficher le detail de chaque trou du parcours
for ( i = 0;i < tab[nro]->nbTrou;i++ )
{
afficherInfoTrou( tab[nro]->listeTrous[i] );
}
}
/*
* paramètre d'entrées : un tableau de pointeur(s) sur parcours
le nombre actuel d'element(s) du tableau
*
* en entrées :
*
* paramètre de sortie
*
* paramètre d'E/S
*
* en sortie : fichier contenant l'ensemble des parcours
* valeur retournée :
*
* DESCRIPTION : sauvegarder les donnees des parcours dans un fichier
*
*/
void sauvegarderParcours( typeParcours *tab[], int nbParcours )
{
FILE *fd;
int i;
int nbEnregistrement;
int retourFclose;
// ouverture du fichier des parcours en ecriture
fd = fopen( FICHIER_PARCOURS, "w+" );
if ( fd == NULL )
{
printf( "%s\n", strerror( errno ) );
exit( errno );
}
//ecriture de chacun des parcours
for ( i = 0; i < nbParcours; i++ )
{
nbEnregistrement=fwrite( tab[i], sizeof( typeParcours ), 1, fd );
if (nbEnregistrement!=1)
{
printf( " pb sauvegarde parcours%s\n", strerror( errno ) );
exit( errno );
}
}
retourFclose=fclose( fd );
if(retourFclose==EOF)
{
printf( " pb fermeture sauvegarde parcours%s\n", strerror( errno ) );
exit( errno );
}
}
/*
* paramètre d'entrées :
*
* en entrées : fichier contenant l'ensemble des parcours
*
* paramètre de sortie : un tableau de pointeur(s) sur parcours
*
* paramètre d'E/S
*
* en sortie :
* valeur retournée : le nombre actuel d'element(s) du tableau des parcours
*
* DESCRIPTION : initialiser le tableau des parcours
* à partir d'un fichier
*
*/
int chargerParcours( typeParcours *tab[] )
{
FILE *fd;
int nbEnregistrement;
int i = 0;
int retourFclose;
// ouverture du fichier des parcours en lecture
fd = fopen( FICHIER_PARCOURS, "r" );
if ( fd == NULL )
{
printf( "%s\n", strerror( errno ) );
exit( errno );
}
// lecture et stockage de tous les parcours
while ( !feof( fd ) )
{
// reservation memoire pour stokcer un parcours
tab[i] = ( typeParcours* ) malloc( sizeof( typeParcours ) );
//lecture d'un parcours
nbEnregistrement=fread( tab[i], sizeof( typeParcours ), 1, fd );
if (nbEnregistrement!=1) // pb de lecture
{
if (!feof(fd))
{
printf( " pb lecture charger parcours%s\n", strerror( errno ) );
exit( errno );
}
else
{
// c'est la fin de fichier
// on a donc réserve une case en trop pour les parcours
// il faut la supprimer
free( tab[i] );
}
}
else
{
// augmentation du nombre de parcours lu
i++;
}
}
retourFclose=fclose( fd );
if(retourFclose==EOF)
{
printf( " pb fermeture charger parcours%s\n", strerror( errno ) );
exit( errno );
}
// je retourne le nombre de parcours maintenant present dans mon tableau
return i;
}
/*
* retourne une valeur entiere E[0..maxAlea[
*/
float aleatoire( float maxAlea )
{
/* struct timeb {
time_t time;
unsigned short millitm;
short timezone;
short dstflag;
};*/
struct timeb t;
//long t;
float a, b ;
unsigned int nbmilli;
ftime( &t );
nbmilli = t.time * 1000 + t.millitm;
srand( nbmilli );
a = rand();
b = ( maxAlea * a ) / RAND_MAX;
return ( b );
}
/*
* retourne un entier entre min et max
*/
float lancement( float min, float max )
{
float lancee;
lancee = min + aleatoire( max - min );
return ( lancee );
}
/*
* paramètre d'entrées : un trou
* la difficulte sur le green
*
*
* en entrées : le choix du club utilise
*
* paramètre de sortie :
*
* paramètre d'E/S
*
* en sortie : affichage de la distance restante
* et du nombre de points
* valeur retournée : le nombre de coups effectue pour arriver au trou
*
* DESCRIPTION : jouer un trou ->
* demander autant de fois que necessaire
* le type de club a utilise
* jusqu'à arriver au trou.
* ->la difficulte est de determiner à partir de
* combien de metres du trou
* une balle est consideree dans le trou.
*
*/
int jouerTrou( typeTrou t, float difficulte )
{
int fin = 1; // la balle n'est pas dans le trou
float dist = t.distance;
int nbCoups = 1;
char choix;
do
{
printf( "=============== coups nro %d\n", nbCoups );
printf( "choix du club : \n[D]river\n[B]ois\n[F]er\n[P]utter\n" );
scanf( " %c", &choix );
choix = toupper( choix );
// en fonction du choix de club, je reduis la distance avec le trou
switch ( choix )
{
case 'D':
dist -= lancement( DRIVER_MIN, DRIVER_MAX );
break;
case 'B':
dist -= lancement( BOIS_MIN, BOIS_MAX );
break;
case 'F':
dist -= lancement( FER_MIN, FER_MAX );
break;
case 'P':
dist -= lancement( PUTTER_MIN, PUTTER_MAX );
break;
}
if ( dist <= 0.0 )
{// si je depasse le trou je remets une distance positive
dist = -dist;
if ( dist > difficulte )
printf( "%svous avez depasse le trou%s\n", RED, GREY );
}
if ( dist <= difficulte && dist >= 0.0 )
{// la balle est dans le trou
fin = 0;
}
if ( nbCoups == t.nbMaxCoups )
{// j'ai atteint le nombre maxi de coups pour le trou
if ( fin != 0 )
{// et en plus la balle n'est toujours pas dans le trou
printf( "%sNombre de coups maxi atteint!! abandon de ce trou%s\n", RED, GREY );
}
fin = 0;
}
if ( fin != 0 )
{// je dois rejouer, j'affiche la distance restante
nbCoups++;
printf( "=================================================\n" );
printf( "il vous reste %.1f metres avant le trou\n", dist );
printf( "=================================================\n" );
}
}
while ( fin != 0 );
printf( "\n\n\n" );
// suivant le nombre de coups joue par rapport au "par" du trou
// j'affiche la designation correspondante
switch ( nbCoups - t.par )
{
case CONDOR:
printf( "%s CONDOR !!!! %d\n%s", YELLOW, CONDOR, GREY );
break;
case ALBATROS:
printf( "%s ALBATROS!!! %d\n%s", YELLOW, ALBATROS, GREY );
break;
case EAGLE:
printf( "%sEAGLE!! %d%s\n", YELLOW, EAGLE, GREY );
break;
case BIRDIE:
printf( "%sBIRDIE! %d%s\n", YELLOW, BIRDIE, GREY );
break;
case PAR:
printf( "PAR %d\n", PAR );
break;
case BOGEY:
printf( "%sBOGEY +%d%s\n", RED, BOGEY, GREY );
break;
case DOUBLE_BOGEY:
printf( "%sDOUBLE_BOGEY +%d%s\n", RED, DOUBLE_BOGEY, GREY );
break;
case TRIPLE_BOGEY:
printf( "%sTRIPLE_BOGEY +%d%s\n", RED, TRIPLE_BOGEY, GREY );
break;
default:
printf( "%s+%d%s\n", RED, nbCoups - t.par, GREY );
}
printf( "\n\n\n" );
// retourne le nombre de coups joue pour ce trou
return ( nbCoups );
}
/*
* paramètre d'entrées : un pointeur sur un score
*
* en entrées :
*
* paramètre de sortie :
*
* paramètre d'E/S
*
* en sortie : affichage du score d'un joueur pour un parcours
* valeur retournée :
*
* DESCRIPTION : affichage du score d'un joueur pour un parcours
*
*/
void afficherScore( typeScore *s )
{
int i, total = 0;
printf( "score de%s %s:%s\n", CYAN, s->nomJoueur, GREY );
printf( "parcours : %s difficulte : ", s->parcoursJoue.nom );
// suivant la valeur de la difficulte, afficher la difficulte en toute lettre
switch ( s->difficulte )
{
case 0:
printf( "infernale\n" );
case 1:
printf( "tres difficile\n" );
case 2:
printf( "difficile\n" );
case 3:
printf( "normale\n" );
case 4:
printf( "facile\n" );
case 5:
printf( "tres facile\n" );
}
// affichage de la grille avec le numero des trous, les valeurs des "par" et le score du joueur
printf( "--------------" );
for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ )
{
printf( "----" );
}
printf( "\n" );
//affichage des numeros de trou
printf( "nro Trou " );
for ( i = 0;i < s->parcoursJoue.nbTrou;i++ )
{
if ( i < 10 )
{
printf( "| %.1d ", i + 1 );
}
else
{
printf( "| %.2d", i + 1 );
}
}
printf( "|TOT" );
printf( "\n" );
printf( "--------------" );
for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ )
{
printf( "----" );
}
printf( "\n" );
//affichage des valeurs de "par" pour chaque trou
printf( "valeur du par " );
for ( i = 0;i < s->parcoursJoue.nbTrou;i++ )
{
printf( "| %.1d ", s->parcoursJoue.listeTrous[i].par );
total += s->parcoursJoue.listeTrous[i].par;
}
printf( "| %.2d", total );
printf( "\n" );
total = 0;
printf( "--------------" );
for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ )
{
printf( "----" );
}
printf( "\n" );
//affichage du score du joueur
printf( "score " );
for ( i = 0;i < s->parcoursJoue.nbTrou;i++ )
{
printf( "| " );
if ( s->points[i] > ( s->parcoursJoue.listeTrous[i].par ) )
printf( "%s", RED );
if ( s->points[i] < ( s->parcoursJoue.listeTrous[i].par ) )
printf( "%s", YELLOW );
printf( "%.1d %s", s->points[i], GREY );
total += s->points[i];
}
printf( "| %.2d", total );
printf( "\n" );
printf( "--------------" );
for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ )
{
printf( "----" );
}
printf( "\n" );
}
/*
* paramètre d'entrées : le nombre de scores present dans le tableau des scores
*
* en entrées :
*
* paramètre de sortie :
*
* paramètre d'E/S tableau de pointeurs sur des scores
*
* en sortie : le tableau des scores trie
* selon la somme des coups par ordre croissant
* valeur retournée :
*
* DESCRIPTION : trier les scores du meilleur au plus mauvais
*
*/
void classement( typeScore *tab[], int nbScore )
{
int i, j, k;
typeScore *tmp;
int sommei = 0, sommej = 0;
for ( i = 0;i < nbScore;i++ )
{
sommei = 0;
// calcul de la somme des points au rang i
for ( k = 0;k < tab[i]->parcoursJoue.nbTrou;k++ )
sommei += tab[i]->points[k];
for ( j = i;j < nbScore;j++ )
{
sommej = 0;
// calcul de la somme des points au rang j
for ( k = 0;k < tab[j]->parcoursJoue.nbTrou;k++ )
sommej += tab[j]->points[k];
// si le score au rang j est plus petit qu'au rang i swapper les pointeurs
if ( sommej < sommei )
{
tmp = tab[i];
tab[i] = tab[j];
tab[j] = tmp;
}
}
}
}
/****************************************************************************************************
****************************************************************************************************
****************************************************************************************************
fonctions a coder/completer
****************************************************************************************************
****************************************************************************************************
****************************************************************************************************/
void afficherMenu(int nbParcours, int nbScores)
{
if(nbParcours > 0)
{
printf("[J] Jouer un parcours\n");
printf("[D] Jouer un parcours avec 2 joueurs\n");
printf("[V] Afficher un parcours\n");
}
if(nbScores > 0)
{
printf("[Z] Classement\n");
}
printf("[C] Creer un parcours\n");
printf("[Q] Quitter\n");
printf("Votre choix :");
}
/*
* paramètre d'entrées : un trou
*
* en entrées :
*
*
* paramètre de sortie :
*
* paramètre d'E/S
*
* en sortie : Affichage des champs du trou
* valeur retournée :
*
* DESCRIPTION : Affichage des caracteristiques d'un trou
*
*
*/
void afficherInfoTrou( typeTrou unTrou)
{
printf("[Trou numero %d |", unTrou.numero);
printf(" Distance %.2f metres |", unTrou.distance);
printf(" Par %d |", unTrou.par);
printf(" %d coups maximum]\n", unTrou.nbMaxCoups);
}
/*
* paramètre d'entrées : tableau de pointeur sur des parcours
nombre de parcours actuellement dans le tableau
*
* en entrées :
*
*
* paramètre de sortie :
*
* paramètre d'E/S
*
* en sortie : affichage de l'index(numero d'indice) de chaque parcours suivi de son nom
* valeur retournée :
*
* DESCRIPTION : Affichage des différents parcours disponibles
*
*
*/
void afficherLesParcours( typeParcours *tab[], int nbParcours )
{
int i;
for(i = 0; i <
nbParcours; i++)
{
printf("%d - %s\n", i, tab[i]->nom);
}
}
/*
* paramètre d'entrées : un pointeur sur le parcours a jouer
*
* en entrées : nom du joueur
* difficulte de la partie
*
* paramètre de sortie :
*
* paramètre d'E/S
*
* en sortie : affichage des differents coups joues
affichage du score
mise à jour du fichier des scores
* valeur retournée : un pointeur sur le score du joueur
*
* DESCRIPTION : creation d'un joueur avec son score,
* joue chaque trou du parcours.
*
*/
typeScore *jouerParcours( typeParcours *p )
{
typeScore *sc;
int i;
float niveau;
// creation d'un nouveau score
sc = ( typeScore* ) malloc( sizeof( typeScore ) );
printf( "votre nom :" );
scanf( "%s", sc->nomJoueur );
printf( "difficulte [0-infernale .. 5-tres facile]" );
scanf( "%d", &sc->difficulte );
niveau = 1.0 + 3.0 * ( float ) sc->difficulte;
// recopie des donnees du parcours fait par le joueur
memcpy( &sc->parcoursJoue, p, sizeof( typeParcours ) );
printf( "parcour %s\n", p->nom );
/*****************************************************************************************/
// pour chaque trou du parcours
// afficher les informations concernant le trou
// jouer le trou et sauvegarder le nombre de coups joue dans le tableau
// des points du joueur
for ( i = 0;i < p->nbTrou;i++ )
{
afficherInfoTrou( p->listeTrous[i] );
sc->points[i] = jouerTrou( p->listeTrous[i], niveau );
}
// afficher le score du joueur pour ce parcours
afficherScore( sc );
// sauvegarder ce score
sauvegarderScore(sc);
/*****************************************************************************************/
return sc;
}
void sauvegarderScore( typeScore *sc )
{
FILE *fd;
int erreurEcriture;
int erreurFClose;
fd = fopen( FICHIER_SCORE, "w+");
erreurEcriture = fwrite(sc, sizeof(typeScore), 1, fd);
if(erreurEcriture != 1)
{
printf("Probleme sauvegarde scores%s\n", strerror(errno));
exit(errno);
}
erreurFClose = fclose(fd);
if(erreurFClose == EOF)
{
printf("Probleme fermeture sauvegarde scores%s\n", strerror(errno));
exit(errno);
}
}
int chargerLesScores( typeScore *tab[] )
{
FILE *fd;
int i = 0;
int erreurLecture;
int erreurFClose;
fd = fopen(FICHIER_SCORE, "r");
if(fd == NULL)
{
printf("%s\n", strerror(errno));
exit(errno);
}
while(!feof(fd))
{
tab[i] = (typeScore*) malloc(sizeof(typeScore));
erreurLecture = fread(tab[i], sizeof(typeScore), 1, fd);
if(erreurLecture != 1)
{
if(!feof(fd))
{
printf("Probleme lecture chargement scores%s\n", strerror(errno));
exit(errno);
}
else
{
free(tab[i]);
}
}
else
{
i++;
}
}
erreurFClose = fclose(fd);
if(erreurFClose == EOF)
{
printf("Probleme fermeture chargement scores%s\n", strerror(errno));
exit(errno);
}
return i;
}
void jouerParcoursADeux( typeParcours *p )
{
typeScore *scP1;
typeScore *scP2;
int i;
float niveauP1;
float niveauP2;
// creation d'un nouveau score
scP1 = ( typeScore* ) malloc( sizeof( typeScore ) );
scP2 = ( typeScore* ) malloc( sizeof( typeScore ) );
printf( "Nom player 1 :" );
scanf( "%s", scP1->nomJoueur );
printf( "difficulte player 1 [0-infernale .. 5-tres facile]" );
scanf( "%d", &scP1->difficulte );
printf( "Nom player 2 :" );
scanf( "%s", scP2->nomJoueur );
printf( "difficulte player 2 [0-infernale .. 5-tres facile]" );
scanf( "%d", &scP2->difficulte );
niveauP1 = 1.0 + 3.0 * ( float ) scP1->difficulte;
niveauP2 = 1.0 + 3.0 * ( float ) scP2->difficulte;
// recopie des donnees du parcours fait par le joueur
memcpy( &scP1->parcoursJoue, p, sizeof( typeParcours ) );
memcpy( &scP2->parcoursJoue, p, sizeof( typeParcours ) );
printf( "parcour %s\n", p->nom );
// pour chaque trou du parcours
// afficher les informations concernant le trou
// jouer le trou et sauvegarder le nombre de coups joue dans le tableau
// des points du joueur
for ( i = 0;i < p->nbTrou;i++ )
{
afficherInfoTrou( p->listeTrous[i] );
printf("%s", scP1->nomJoueur);
scP1->points[i] = jouerTrou( p->listeTrous[i], niveauP1 );
printf("%s", scP2->nomJoueur);
scP2->points[i] = jouerTrou( p->listeTrous[i], niveauP2 );
}
afficherScore( scP1 );
afficherScore( scP2 );
}

Some files were not shown because too many files have changed in this diff Show More