Discussion :

[nass956]

bonjour j ai un exercice sur les pointeur a faire en c et je voulais savoir si mon code etait conforme a la consigne et a la note.
merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<stdlib.h>
#include<stdio.h>
#define N 10
int main(void)
{
    int a[N]= {-3,4,0,-7,3,8,0,-1,4,-9};
    int b[N];
    int *p;
    int i;
    for(i=0; i<N; i++)
    {
        p=&a[i];
        b[N-1-i]=*p;
 
    }
 
   return EXIT_SUCCESS ;
}

[Jamatronic]

Pour respecter totalement la consigne il me semble qu'il faut aussi parcourir B à l'aide d'un pointeur.

Et si l'auteur de l'exercice est vicieux, il s'attend peut-être à avoir quelque chose comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
int* p = A;
for (int i = 0; i < N; i++, p++)
{
 ...
}

Ou pire : pas besoin d'un compteur de boucle comme i... on calcule l'adresse du dernier élément et
on itère directement sur p... mais là on est dans le plaisir de s'amuser avec les pointeurs pour s'amuser
avec les pointeurs...

[nass956]

Pour respecter totalement la consigne il me semble qu'il faut aussi parcourir B à l'aide d'un pointeur.

Et si l'auteur de l'exercice est vicieux, il s'attend peut-être à avoir quelque chose comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
int* p = A;
for (int i = 0; i < N; i++, p++)
{
 ...
}

Ou pire : pas besoin d'un compteur de boucle comme i... on calcule l'adresse du dernier élément et
on itère directement sur p... mais là on est dans le plaisir de s'amuser avec les pointeurs pour s'amuser
avec les pointeurs...

d accord merci par rapport a ton code je vois vraiment pas ce qu on pourrait mettre dans la boucle for

[dalfab]

On peut aussi faire parcourir 2 pointeurs, un qui monte, l'autre qui descend

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
const int* p = A;
for (int* q = &B[N-1] ; q >= B ; p++,q-- )
{
 ...  une seule ligne à remplir ici ...
}

[Matt_Houston]

Tu peux facilement améliorer la clarté de ton programme et démontrer ta compréhension de l'énoncé en isolant le code de traitement du code de présentation :

• écrire une fonction qui prend deux adresses et un nombre d'éléments en paramètres et réalise le traitement :
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  1
  2
  3
  4
  void rev(int *restrict dst, const int *restrict src, size_t count) {
      for (size_t i = 0; i < count; ++i)
          dst[count - 1 - i] = src[i];
  }

• utiliser une fonction qui affiche joliment le contenu d'un tableau d'int (puisque tu as déjà inclus stdio.h) ;
• faire de main un module de test unitaire pour la fonction de traitement en affichant les contenus des tableaux d'entrée avant et après le traitement.

À part cela, la « bonne » manière de faire est celle que tu as implémentée. Je ne sais pas trop ce qu'attend l'examinateur, peut-être que tu démontres que tu es particulièrement à l'aise avec l'arithmétique des pointeurs..?


Avec ton algo, on peut aussi écrire (restrict car les buffers ne doivent pas se chevaucher) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void revi(int *restrict dst, const int *restrict src, size_t count) {
    const int *s = src + count;
 
    while (s > src)
        *dst++ = *--s;
}

..ou en version générique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <string.h> // memcpy
 
typedef unsigned char byte_t;
 
void rev(void *restrict dst, const void *restrict src, size_t size, size_t count) {
          byte_t *d = (byte_t *)dst;
    const byte_t *s = (byte_t *)src + size * count;
 
    while (s > (byte_t *)src) {
        s -= size;
        memcpy(d, s, size);
        d += size;
    }
}

Et avec un algorithme un peu différent :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void revim(int *restrict dst, const int *restrict src, size_t count) {
    const size_t half =   count / 2,
                 even = !(count % 2) && count > 0;
          int *dst_lo = dst + half - even,
              *dst_hi = dst + half;
    const int *src_lo = src + half - even,
              *src_hi = src + half;
 
    while (src_hi < src + count) {
        *dst_hi++ = *src_lo--;
        *dst_lo-- = *src_hi++;
    }
}

..etc, etc...

[nass956]

On peut aussi faire parcourir 2 pointeurs, un qui monte, l'autre qui descend

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
const int* p = A;
for (int* q = &B[N-1] ; q >= B ; p++,q-- )
{
 ...  une seule ligne à remplir ici ...
}

j ai essayer ca

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdlib.h>
#include<stdio.h>
#define N 10
int main(void)
{
    int a[N]= {-3,4,0,-7,3,8,0,-1,4,-9};
    int b[N];
 
    const int* p = a;
for (int* q = &b[N-1] ; q >= b ; p++,q-- )
{
  q = a[q];
}
 
 
   return EXIT_SUCCESS ;
}

[nass956]

Tu peux facilement améliorer la clarté de ton programme et démontrer ta compréhension de l'énoncé en isolant le code de traitement du code de présentation :

• écrire une fonction qui prend deux adresses et un nombre d'éléments en paramètres et réalise le traitement :
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  1
  2
  3
  4
  void rev(int *restrict dst, const int *restrict src, size_t count) {
      for (size_t i = 0; i < count; ++i)
          dst[count - 1 - i] = src[i];
  }

• utiliser une fonction qui affiche joliment le contenu d'un tableau d'int (puisque tu as déjà inclus stdio.h) ;
• faire de main un module de test unitaire pour la fonction de traitement en affichant les contenus des tableaux d'entrée avant et après le traitement.

À part cela, la « bonne » manière de faire est celle que tu as implémentée. Je ne sais pas trop ce qu'attend l'examinateur, peut-être que tu démontres que tu es particulièrement à l'aise avec l'arithmétique des pointeurs..?


Avec ton algo, on peut aussi écrire (restrict car les buffers ne doivent pas se chevaucher) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void revi(int *restrict dst, const int *restrict src, size_t count) {
    const int *s = src + count;
 
    while (s > src)
        *dst++ = *--s;
}

..ou en version générique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <string.h> // memcpy
 
typedef unsigned char byte_t;
 
void rev(void *restrict dst, const void *restrict src, size_t size, size_t count) {
          byte_t *d = (byte_t *)dst;
    const byte_t *s = (byte_t *)src + size * count;
 
    while (s > (byte_t *)src) {
        s -= size;
        memcpy(d, s, size);
        d += size;
    }
}

Et avec un algorithme un peu différent :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void revim(int *restrict dst, const int *restrict src, size_t count) {
    const size_t half =   count / 2,
                 even = !(count % 2) && count > 0;
          int *dst_lo = dst + half - even,
              *dst_hi = dst + half;
    const int *src_lo = src + half - even,
              *src_hi = src + half;
 
    while (src_hi < src + count) {
        *dst_hi++ = *src_lo--;
        *dst_lo-- = *src_hi++;
    }
}

..etc, etc...

merci bcp mais c est un peux trop "élevé"par rapport a ce qu'on fait en c

[dalfab]

Essaie (et comprends) plutôt cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
const int* p = a;
for (int* q = &b[N-1] ; q >= b ; p++,q-- )
{
  *q = *p; // copier ce qui est pointé par p, dans ce qui est pointé par q
}

[nass956]

Essaie (et comprends) plutôt cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
const int* p = a;
for (int* q = &b[N-1] ; q >= b ; p++,q-- )
{
  *q = *p; // copier ce qui est pointé par p, dans ce qui est pointé par q
}

okey merci mais je comprend pas a quoi sert l incrementation sur p

[dalfab]

p va successivement pointer sur a[0], a[1], ...., a[n-1] (incrémenter fait pointer sur le suivant)
pendant que q va successivement pointer sur b[n-1], b[n-2], ..., b[0] (décrémenter fait pointer sur le précédent)
on va donc copier a[0] vers b[n-1], .... , a[n-1] vers b[0]

[nass956]

p va successivement pointer sur a[0], a[1], ...., a[n-1] (incrémenter fait pointer sur le suivant)
pendant que q va successivement pointer sur b[n-1], b[n-2], ..., b[0] (décrémenter fait pointer sur le précédent)
on va donc copier a[0] vers b[n-1], .... , a[n-1] vers b[0]

d accord j ai compris merci mais des que je compile j ai un probleme " for loop initial déclarations are only allowed in C99 or C11 mode"

[dalfab]

d accord j ai compris merci mais des que je compile j ai un probleme " for loop initial déclarations are only allowed in C99 or C11 mode"

Depuis très récemment (c-a-d depuis 1999) on peut déclarer des variables dans les parenthèses du for. Ton compilateur est en mode C de 1989!, il faut le mettre en mode C99 ou C11 (la méthode dépend du compilateur c'est souvent l'option -std=C11) ou bien mettre la déclaration de int*q avant au lieu de dedans le for().

[Matt_Houston]

merci bcp mais c est un peux trop "élevé"par rapport a ce qu'on fait en c

Les exemples donnés relèvent plus de l'exercice de style puisque comme nous - Jamatronic le premier - l'avons fait remarquer, ton implémentation initiale apporte déjà une réponse satisfaisante au problème posé.

La première partie de mon message est en revanche à ton niveau, à commencer par la fonction d'affichage sans laquelle on ne peut aisément vérifier que le programme fonctionne.