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

_static/src/C/S3-src/argv-env.c

+/**************************************
+ * arg-env.c
+ *
+ * Arguments et variables d'environnement
+ *
+ **************************************/
+
+///AAA
+#include <stdio.h>
+#include <stdlib.h>
+
+// affiche la valeur de la variable d'environnement var
+void print_var(char *var) {
+  char *val=getenv(var);
+  if(val!=NULL)
+    printf("La variable %s a la valeur : %s\n",var,val);
+  else
+    printf("La variable %s n'a pas été assignée\n",var);
+}
+
+int main(int argc, char *argv[]) {
+
+  char *old_path=getenv("PATH");
+
+  print_var("PATH");
+
+  if(unsetenv("PATH")!=0) {
+    fprintf(stderr,"Erreur unsetenv\n");
+    exit(EXIT_FAILURE);
+  }
+
+  print_var("PATH");
+
+  if(setenv("PATH",old_path,1)!=0) {
+    fprintf(stderr,"Erreur setenv\n");
+    exit(EXIT_FAILURE);
+  }
+
+  print_var("PATH");
+
+  return(EXIT_SUCCESS);
+}

_static/src/C/S3-src/callocperf.c

+/**************************************
+ * callocperf.c
+ *
+ * Programme mesurant les performances
+ * de calloc
+ *
+ **************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#define LOOP 2
+
+void error(char *msg) {
+  fprintf(stderr,"Erreur :%s\n",msg);
+  exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[]) {
+  int size=1;
+  if(argc==2)
+    size=atoi(argv[1]);
+
+  for(int j=1;j<LOOP+1;j++) {
+    int *vector;
+    vector=(int *)calloc(size,sizeof(int));
+
+    int count=0;
+    for(int i=0;i<size;i++) {
+      if( *(vector+i)!=0)
+	count++;
+      else
+	*(vector+i)=j;
+    }
+    printf("Nombre d'entiers non initialisés à zéro : %d\n",count);
+    free(vector);
+  }
+  return(EXIT_SUCCESS);
+}

_static/src/C/S3-src/const.c

+/**************************************
+ * const.c
+ *
+ * Programme d'exemple de constantes
+ *
+ **************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+///AAA
+// extrait de <math.h>
+#define M_PI   3.14159265358979323846264338327950288;
+
+const double pi=3.14159265358979323846264338327950288;
+
+const struct fraction {
+  int num;
+  int denom;
+}  demi={1,2};
+///BBB
+int main(int argc, char *argv[]) {
+  // demi.num=0; invalid
+  printf("%d/%d\n",demi.num,demi.denom);
+  printf("Adresse de pi :%p\n",&pi);
+  printf("Adresse de demi :%p\n",&demi);
+
+  return(EXIT_SUCCESS);
+}

_static/src/C/S3-src/dataseg.c

+/**************************************
+ * initvar.c
+ *
+ * Programme d'exemple sur le segment
+ * de données
+ *
+ **************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+///AAA
+#define MSG_LEN 10
+int g;   // initialisé par le compilateur
+int g_init=1252;
+const int un=1;
+int tab[3]={1,2,3};
+int array[10000];
+char cours[]="SINF1252";
+char msg[MSG_LEN]; // initialisé par le compilateur
+
+int main(int argc, char *argv[]) {
+  int i;
+  printf("g est à l'adresse %p et initialisée à %d\n",&g,g);
+  printf("msg est à l'adresse %p contient les caractères :",msg);
+  for(i=0;i<MSG_LEN;i++)
+    printf(" %x",msg[i]);
+  printf("\n");
+  printf("Cours est à l'adresse %p et contient : %s\n",&cours,cours);
+  return(EXIT_SUCCESS);
+}
+///BBB

_static/src/C/S3-src/dataseg.out

+g est à l'adresse 0x60aeac et initialisée à 0
+msg est à l'adresse 0x60aea0 contient les caractères : 0 0 0 0 0 0 0 0 0 0
+Cours est à l'adresse 0x601220 et contient : SINF1252

_static/src/C/S3-src/empty.c

+/**************************************
+ * static.c
+ *
+ * Programme d'exemple de variables static
+éé
+ *
+ **************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+   // affiche sur la sortie standard
+   printf("Hello, world!\n");
+
+   return(EXIT_SUCCESS);
+}

_static/src/C/S3-src/enum.c

+/**************************************
+ * enum.c
+ *
+ * Programme d'exemple de enum
+ *
+ **************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+///AAA
+// les jours de la semaine
+typedef enum  {
+      monday, tuesday, wednesday, thursday, friday, saturday, sunday
+   } day;
+
+// jeu de carte
+typedef enum {
+  coeur, carreau, trefle, pique
+} carte;
+
+// bits
+typedef enum {
+        BITRESET = 0,
+        BITSET = 1
+} bit_t;
+
+///BBB
+
+
+int main(int argc, char *argv[]) {
+  ///CCC
+  bit_t bit=BITRESET;
+  day jour=monday;
+  if(jour==saturday||jour==sunday)
+    printf("Congé\n");
+  ///DDD
+  printf("jour: %d\n",jour);
+  printf("sizeof(day) %ld\n",sizeof(day));
+  printf("sizeof(bit_t) %ld\n",sizeof(bit_t));
+
+
+  return(EXIT_SUCCESS);
+}

_static/src/C/S3-src/exhaust-stack.c

+/**************************************
+ * exhaust-stack.c
+ *
+ * Programme qui sature le stack
+ *
+ **************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/resource.h>
+
+///AAA
+
+#define ARRAY_SIZE 10000
+
+int sumn(int i) {
+  int array[ARRAY_SIZE];
+  printf("Computing sumn(%d)\n",i);
+  for(int j=0;j<ARRAY_SIZE;j++){
+    array[j]=i;
+  }
+  if(i>0)
+    return (i+sumn(i-1));
+  else
+    return i;
+}
+
+///BBB
+int main(int argc, char *argv[]) {
+  int n;
+  if(argc==2) {
+    n=atoi(argv[1]);
+  }
+  else
+    n=5;
+  struct rlimit r;
+
+  int err=getrlimit(RLIMIT_STACK,&r);
+  if(err!=0) {
+    printf("Error\n");
+    return(EXIT_FAILURE);
+  }
+  printf("Softlimit %ld, hard limit %ld\n",(rlim_t) r.rlim_cur,(rlim_t)r.rlim_max);
+  printf("La somme des %d premiers entiers est : %d\n",n,sumn(n));
+
+  return(EXIT_SUCCESS);
+}

_static/src/C/S3-src/fact.c

+/**************************************
+ * fact.c
+ *
+ * Programme de calcul de factorielle
+ *
+ **************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+///BBB
+// retourne i*j
+int times(int i, int j) {
+  int m;
+  m=i*j;
+  printf("\t[times(%d,%d)] : return(%d)\n",i,j,m);
+  return m;
+}
+// calcul récursif de factorielle
+// n>0
+int fact(int n) {
+  printf("[fact(%d)]: Valeur de n:%d, adresse: %p\n",n,n,&n);
+  int f;
+  if(n==1) {
+    printf("[fact(%d)]: return(1)\n",n);
+    return(n);
+  }
+  printf("[fact(%d)]: appel à fact(%d)\n",n,n-1);
+  f=fact(n-1);
+  printf("[fact(%d)]: calcul de times(%d,%d)\n",n,n,f);
+  f=times(n,f);
+  printf("[fact(%d)]: return(%d)\n",n,f);
+  return(f);
+}
+
+void compute() {
+  int nombre=3;
+  int f;
+  printf("La fonction fact est à l'adresse : %p\n",fact);
+  printf("La fonction times est à l'adresse : %p\n",times);
+  printf("La variable nombre vaut %d et est à l'adresse %p\n",nombre,&nombre);
+  f=fact(nombre);
+  printf("La factorielle de %d vaut %d\n",nombre,f);
+}
+///AAA
+
+
+#define MSG_LEN 80
+char msg[MSG_LEN];
+float matrix1[4];
+float matrix3[2]={1.3,2.4};
+struct fraction {
+  float den;
+  float num;
+} fract;
+const int nombre=7;
+
+int max(int i, int j) {
+  if(i>j)
+    return(i);
+  else
+    return(j);
+}
+
+int main(int argc, char *argv[]) {
+
+  int f=1252; // variable locale
+
+  printf("La variable nombre est à l'adresse : %p\n",(void *) &nombre);
+  printf("Le tableau msg est à l'adresse : %p\n",(void *)msg);
+  printf("La variable locale f est à l'adresse : %p\n",(void *) &f);
+
+  printf("La fonction main est à l'adresse : %p\n",main);
+  printf("La fonction max est à l'adresse : %p\n",max);
+
+  /// ...
+  ///BBB
+  printf("///FACT\n");
+  compute();
+
+  return(EXIT_SUCCESS);
+}
+

_static/src/C/S3-src/fact.out

+La variable nombre est à l'adresse : 0x100000e68
+Le tableau msg est à l'adresse : 0x1000010a0
+La variable locale f est à l'adresse : 0x7fff5fbfe1dc
+La fonction main est à l'adresse : 0x100000b6b
+La fonction max est à l'adresse : 0x100000b46
+///FACT
+La fonction fact est à l'adresse : 0x100000a0f
+La fonction times est à l'adresse : 0x1000009d8
+La variable nombre vaut 3 et est à l'adresse 0x7fff5fbfe1ac
+[fact(3)]: Valeur de n:3, adresse: 0x7fff5fbfe17c
+[fact(3)]: appel à fact(2)
+[fact(2)]: Valeur de n:2, adresse: 0x7fff5fbfe14c
+[fact(2)]: appel à fact(1)
+[fact(1)]: Valeur de n:1, adresse: 0x7fff5fbfe11c
+[fact(1)]: return(1)
+[fact(2)]: calcul de times(2,1)
+	[times(2,1)] : return(2)
+[fact(2)]: return(2)
+[fact(3)]: calcul de times(3,2)
+	[times(3,2)] : return(6)
+[fact(3)]: return(6)
+La factorielle de 3 vaut 6

_static/src/C/S3-src/getpid.c

+/**************************************
+ * getpid.c
+ *
+ * Programme d'exemple pour getpid
+ *
+ **************************************/
+///AAA
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int main(int argc, char *argv[]) {
+
+  unsigned int sec=30;
+  int pid=(int) getpid();
+
+  printf("Processus : %d\n",pid);
+  printf("[pid=%d] Sleep : %d secondes\n",pid, sec);
+  sec=sleep(sec);
+  if(sec==0) {
+    printf("[pid=%d] Fin du processus\n",pid );
+    return(EXIT_SUCCESS);
+  }
+  else {
+    printf("[pid=%d] Interrompu alors qu'il restait %d secondes\n",pid,sec);
+    return(EXIT_FAILURE);
+  }
+}

_static/src/C/S3-src/initvar.c

+/**************************************
+ * initvar.c
+ *
+ * Programme d'exemple sur l'initialisation
+ * des variables
+ *
+ **************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+///AAA
+
+#define ARRAY_SIZE 1000
+
+// initialise un tableau local
+void init(void) {
+  long a[ARRAY_SIZE];
+  for(int i=0;i<ARRAY_SIZE;i++) {
+    a[i]=i;
+  }
+}
+
+// retourne la somme des éléments
+// d'un tableau local
+long read(void) {
+  long b[ARRAY_SIZE];
+  long sum=0;
+  for(int i=0;i<ARRAY_SIZE;i++) {
+    sum+=b[i];
+  }
+  return sum;
+}
+
+
+///BBB
+int main(int argc, char *argv[]) {
+  unsigned int n=5;
+
+  if(argc==2) {
+    n=atoi(argv[1]);
+  }
+
+  ///CCC
+  printf("Résultat de read() avant init(): %ld\n",read());
+  init();
+  printf("Résultat de read() après init() : %ld\n",read());
+  ///DDD
+  return(EXIT_SUCCESS);
+}

_static/src/C/S3-src/initvar.out

+Résultat de read() avant init(): 7392321044987950589
+Résultat de read() après init() : 499500

_static/src/C/S3-src/malloc.c

+/**************************************
+ * malloc.c
+ *
+ * Programme illustrant malloc
+ *
+ **************************************/
+///AAA
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+
+typedef struct fraction {
+  int num;
+  int den;
+} Fraction;
+
+void error(char *msg) {
+  fprintf(stderr,"Erreur :%s\n",msg);
+  exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[]) {
+  int size=1;
+  if(argc==2)
+    size=atoi(argv[1]);
+
+  char * string;
+  printf("Valeur du pointeur string avant malloc : %p\n",string);
+  string=(char *) malloc((size+1)*sizeof(char));
+  if(string==NULL)
+    error("malloc(string)");
+
+  printf("Valeur du pointeur string après malloc : %p\n",string);
+  int *vector;
+  vector=(int *)malloc(size*sizeof(int));
+  if(vector==NULL)
+    error("malloc(vector)");
+
+  Fraction * fract_vect;
+  fract_vect=(Fraction *) malloc(size*sizeof(Fraction));
+  if(fract_vect==NULL)
+    error("malloc(fract_vect)");
+
+  free(string);
+  printf("Valeur du pointeur string après free   : %p\n",string);
+  string=NULL;
+  free(vector);
+  vector=NULL;
+  free(fract_vect);
+  fract_vect=NULL;
+
+  return(EXIT_SUCCESS);
+}
+///BBB

_static/src/C/S3-src/malloc.out

+Valeur du pointeur string avant malloc : 0x7fff5fbfe1d8
+Valeur du pointeur string après malloc : 0x100100080
+Valeur du pointeur string après free   : 0x100100080

_static/src/C/S3-src/mallocinit.c

+/**************************************
+ * mallocinit.c
+ *
+ * Malloc et les données non-initialisées
+ *
+ **************************************/
+#include <stdio.h>
+#include <stdlib.h>
+///AAA
+#define LEN 1024
+
+int main(int argc, char *argv[]) {
+
+  int *v1;
+  int *v2;
+  int sum=0;
+  v1=(int *)malloc(sizeof(int)*LEN);
+  for(int i=0;i<LEN;i++) {
+    sum+=*(v1+i);
+    *(v1+i)=1252;
+  }
+  printf("Somme des éléments de v1 : %d\n", sum);
+  sum=0;
+  free(v1);
+  v2=(int *)malloc(sizeof(int)*LEN);
+  for(int i=0;i<LEN;i++) {
+    sum+=*(v2+i);
+  }
+
+  printf("Somme des éléments de v2 : %d\n", sum);
+  free(v2);
+
+  return(EXIT_SUCCESS);
+}

_static/src/C/S3-src/mallocinit.out

+Somme des éléments de v1 : 0
+Somme des éléments de v2 : 1282048

_static/src/C/S3-src/mallocperf.c

+/**************************************
+ * mallocperf.c
+ *
+ * Programme mesurant les performances
+ * de malloc
+ *
+ **************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+
+#define LOOP 10
+#define SIZE 1000000000
+
+void error(char *msg) {
+  fprintf(stderr,"Erreur :%s\n",msg);
+  exit(EXIT_FAILURE);
+}
+
+/* Return t2-t1 in microseconds */
+long timeval_diff(struct timeval *t2, struct timeval *t1)
+{
+  long diff = (t2->tv_usec + 1000000 * t2->tv_sec) - (t1->tv_usec + 1000000 * t1->tv_sec);
+  return (diff);
+}
+
+int main(int argc, char *argv[]) {
+
+  int *vector;
+  long mesures[LOOP], sum;
+
+  struct timeval tvStart, tvEnd;
+  int err;
+
+  vector=(int *)malloc(SIZE*sizeof(int));
+  free(vector);
+
+  for(int i=0;i<LOOP+1;i++) {
+    err=gettimeofday(&tvStart, NULL);
+    if(err!=0)
+      exit(EXIT_FAILURE);
+
+     vector=(int *)calloc(SIZE,sizeof(int));
+     //vector=(int *)malloc(SIZE*sizeof(int));
+    err=gettimeofday(&tvEnd, NULL);
+    if(err!=0)
+      exit(EXIT_FAILURE);
+
+    mesures[i]=timeval_diff(&tvEnd, &tvStart);
+    sum+=mesures[i];
+    free(vector);
+  }
+  printf("Durée moyenne : %ld\n",sum/LOOP);
+
+  return(EXIT_SUCCESS);
+}

_static/src/C/S3-src/nofree.c

+/**************************************
+ * nofree.c
+ *
+ * malloc sans free
+ *
+ **************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+///AAA
+#define LEN 1024
+int main(int argc, char *argv[]) {
+
+  char *str=(char *) malloc(sizeof(char)*LEN);
+  for(int i=0;i<LEN-1;i++) {
+    *(str+i)='A';
+  }
+  *(str+LEN)='\0';  // fin de chaîne
+  return(EXIT_SUCCESS);
+}
+

_static/src/C/S3-src/portee.c

+/**************************************
+ * portee.c
+ *
+ * Programme d'exemple pour la portée de
+ * variables
+ **************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+///AAA
+
+int g1;
+int g2=1;
+
+void f(int i) {
+  int loc;    //def1a
+  int loc2=2; //def2a
+  int g2=-i*i;
+  g1++;
+
+  printf("[f-%da] \t\t %d \t %d \t %d \t %d\n",i,g1,g2,loc,loc2);
+  loc=i*i;
+  g1++;
+  g2++;
+  printf("[f-%db] \t\t %d \t %d \t %d \t %d\n",i,g1,g2,loc,loc2);
+
+}
+
+
+int main(int argc, char *argv[]) {
+  int loc; //def1b
+  int loc2=1; //def2b
+
+  printf("Valeurs de : \t g1 \t g2\t loc\t loc2\n");
+  printf("===================================================\n");
+
+  printf("[main1] \t %d \t %d \t %d \t %d\n",g1,g2,loc,loc2);
+
+  loc=1252;
+  loc2=1234;
+  g1=g1+1;
+  g1=g1+2;
+
+  printf("[main2] \t %d \t %d \t %d \t %d\n",g1,g2,loc,loc2);
+
+  for(int i=1;i<3;i++) {
+    int loc=i; //def1c
+    int g2=-i;
+    loc++;
+    g1=g1*2;
+    f(i);
+    printf("[main-for-%d] \t %d \t %d \t %d \t %d\n",i,g1,g2,loc,loc2);
+  }
+  f(7);
+  g1=g1*3;
+  g2=g2+2;
+  printf("[main3] \t %d \t %d \t %d \t %d\n",g1,g2,loc,loc2);
+
+  return(EXIT_SUCCESS);
+}
+///BBB