# CRO - TD 4

###### tags: `CRO` `S2`

## Q1

Si je déclare un tableau d’entier : int Tab[5], Pourquoi est ce que ce n’est pas une Lvalue, ils est pourtant stocké en mémoire ?

Un tableau n'est pas une Lvalue car il n'a pas qu'une seule adresse en mémoire

## Q2

CFLAGS = -g -Wall -DDEBUG
LDLAGS = -g -Wall -DDEBUG
SOURCE = pointeur1.c pointeur2.c pointeur3.c pointeur1-bis.c
OBJECT = $(SOURCE:.c=.o)
TARGET = $(SOURCE:.c=)

.INTERMEDIATE: $(OBJECT) #pegagogic plugin: if not there, make will use its
			 #own implicit rules to compile the .c files
			 #instead of mine

all:  $(TARGET)

%: %.o
	gcc  $< -o $@

%.o: %.c
	gcc $(TEST) -c $< -o $@
    
tar: 
	cd ..; tar cvf  TD4-code.tar 
    code/pointeur*.c code/Makefile code/produitScalaireSol.c

clean: 
	\rm -rf *.o $(TARGET)  *~

$@ = nom de la cible de la regle
$< = nom de la dernière dépendance

Les regles avec des % sont des règles implicites.
Elles sont éxécutées quand il n'y a pas de règles définies pour une source en particulier.

## Q3

$ ./pointeur1

output :
*p = 3
p = 0x7FFF3C8F9F24

La valeur de p est l'adresse de i

## Q4

pointeur2.c

#include <stdio.h>

int main()
{
  int i = 3, j = 6;
  int *p1, *p2;

  p1 = &i;
  p2 = &j;
  *p1 = *p2;

  printf("i %d \n", i);
  printf("j %d \n", j);
  printf("p1 = 0x%lX \n",(long unsigned int)p1);
  printf("p2 = 0x%lX \n",(long unsigned int)p2);
  printf("*p1 %d \n", *p1);
  printf("*p2 %d \n", *p2);
}

output :

i 6
j 6
p1 = 0x7FFD0C93859C
p2 = 0x7FFD0C938598
*p1 6
*p2 6

pointeur3.c

#include <stdio.h>

int main()
{
  int i = 3, j = 6;
  int *p1, *p2;
  p1 = &i;
  p2 = &j;
  p1 = p2;

  printf("i %d \n", i);
  printf("j %d \n", j);
  printf("p1 = 0x%lX \n",(long unsigned int)p1);
  printf("p2 = 0x%lX \n",(long unsigned int)p2);
  printf("*p1 %d \n", *p1);
  printf("*p2 %d \n", *p2);

}

output

i 3
j 6
p1 = 0x7FFFDB21A7C8
p2 = 0x7FFFDB21A7C8
*p1 6
*p2 6

## Q5

Les valeurs des adresses changent à chaque execution du programme. Elles ne sont pas les memes à chaque fois, il étais plus interessant à la question précédente de voir l'effet des pointeurs p1 et p2 et non pas juste les adresses en elle-meme.

## Q6

printf("p1 - p2 = %lX \n",(long unsigned int)(p1 - p2));

NB : si on fait p2 - p1 il y a un overflow parce que c'est un unsigned int donc on trouve FFFFFFFFFFF.

Sinon l'output p1 - p2 = 1. C'est normal car c'est uniquement l'adresse initiale en mémoire qui est déterminée au lancement du programme. Il s'execute ensuite dans une zone mémoire déterminée mais toujours de la meme facon.

## Q7

int produit_scalaire(int A[N], int B[N])
{
  int i, res, *pa, *pb;
  pa = &A[0];
  pb = &B[0];
  
  res=0;

  for (i=0;i<N;i++)
    {
      *pa++;
      *pb++; 
      res += *pa * *pb;
      // on peut aussi le faire de cette facon (plus propre)
      // res += *(pa+i) * *(pb+i);
    }
  return res;
}

## Q 8

#include <stdio.h>
#include <stdlib.h>

#define N 5

int produit_scalaire(int *pa, int *pb)
{
  int i, res;
  
  res=0;

  for (i=0;i<N;i++)
    { 
      res += *(pa+i) * *(pb+i);
    }
  return res;
}

int main()
{

  int *pa, *pb, i;
  
  pa=(int *)malloc(5*sizeof(int));
  pb=(int *)malloc(5*sizeof(int));

  if (pa==0)
    {
      fprintf(stderr,"Erreur d'allocation\n");
      exit(-1);
    }
  for (i=0;i<5;i++)
    *(pa+i)=1;

  if (pb==0)
    {
      fprintf(stderr,"Erreur d'allocation\n");
      exit(-1);
    }
  for (i=0;i<5;i++)
    *(pb+i)=1;  

  // int A[N]={1,1,1,1,1};
  // int B[N]={1,1,1,1,1};

  printf("le produit scalaire vaut %d\n", produit_scalaire(pa, pb));

  free(pb);
  free(pa);

  return 0;
}

## Q 9

Définition d'une structure de liste chainée

struct model_elem{
  int val;
  struct model_elem *suivant;
};

//typedef permet de definir la structure model_elem 
//comme un nouveau type ELEMLIST
typedef struct model_elem ELEMLIST;

## Q 10

Programme du pack parrain

list.c

#include <stdio.h>
#include <stdlib.h>
#include "list.h"

ELEMLIST *new_list(int val)
{
  ELEMLIST *special_list = (ELEMLIST *)malloc(sizeof(ELEMLIST));
  (*special_list).val = val;
  return special_list;
}

list.h

#ifndef LIST_H
#define LIST_H

struct model_elem
{
  int val;
  struct model_elem *suivant;
};
typedef struct model_elem ELEMLIST;

ELEMLIST *new_list(int val);

#endif

main.c

#include <stdio.h>
#include <stdlib.h>
#include "list.h"

int main()
{
  int val = 5;
  ELEMLIST *ptr = new_list(val);
  printf("%d\n", (*ptr).val);
  return(0);
}

Makefile

CFLAGS = -g -Wall -DDEBUG
LDLAGS = -g -Wall -DDEBUG

all: main

main: main.o list.o
	gcc ${LDFLAGS} main.o list.o -o main

main.o: main.c list.h
	gcc ${CFLAGS} -c main.c -o main.o

clean:
	\rm -rf *.o main  *~

(c) Tim Sampoc