Discussion :

[Delnir]

Bonjour,
Voila le but de l'exercice est de faire la somme des éléments d'un tableau à 2 dimensions avec 2 méthodes:
-l'une utilisant uniquement les tableau
-l'autre utilisant uniquement les pointeurs

1ére méthode: (celle la fonctione)

Code C :

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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include<stdio.h>
#include<stdlib.h>
 
 
float somme(float t1[][4], int n){
  int i,j;
  float cpt;
  cpt=0;
  for (i=0;i<n;i++){
    for (j=0;j<4;j++){
      cpt+=t1[i] [j];
    }
  }
  return cpt;  
}
 
void remplir(float t1[][4],int n){
  int i,j;
  float x;
  x=0;
  for (i=0;i<n;i++){
    for (j=0;j<4;j++){
      t1[i][j]=x; 
      x++;
    }
  }
}
 
 
int main(){
  float t1[3][4];
  remplir(t1,3);
  printf("la somme des elements est:%f",somme(t1,3));
  return 0;
}

2iéme méthode avec juste que des pointeurs
je sait que t[i] est équivalent à *(t+i) mais à quoi est égale t[i][j] *(t+(i+j))?

Code C :

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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include<stdio.h>
#include<stdlib.h>
 
 
float somme(float *t1, int n, int m){
  int i,j;
  float cpt;
  cpt=0;
  for (i=0;i<n;i++){
    for (j=0;j<m;j++){
      cpt+=*(t1+(i+j));
    }
  }
  return cpt;  
}
 
void remplir(float *t1,int n, int m){
  int i,j;
  float x;
  x=0;
  for (i=0;i<n;i++){
    for (j=0;j<m;j++){
      *(t1+(i+j))=x; 
      x++;
    }
  }
}
 
 
int main(){
  float t1[3][4];
  remplir(t1,3,4);
  printf("la somme des elements est:%f",somme(&t1[0][0]));
  return 0;
}

donc quel est l'équivalent en pointeur de t[i][j] et aussi en général en dimension n?

[souviron34]

donc quel est l'équivalent en pointeur de t[i][j] et aussi en général en dimension n?

si n est le nombre de lignes et m le nombre de colonnes, la position (i,j) dans un tableau (n,m) est (i*m+j) (i : 0 à (n-1) j : 0 à (m-1))

[Sve@r]

donc quel est l'équivalent en pointeur de t[i][j] et aussi en général en dimension n?

Faut bien que tu comprennes que, du point de vue de la mémoire, ton tableau n'est qu'une suite de cases (en une dimension).
Donc la case t[i][j] est, comme l'a dit Souviron, la case située à la position i * m + j.
A partir de là t'as deux façon de programmer
- soit tu travailles en 2D à bases de t[i][j]
- soit tu travailles en 1D et chaque fois que t'as besoin d'aller à la case [i][j] tu calcules toi-même la position réelle dans ta longue ligne

je sait que t[i] est équivalent à *(t+i) mais à quoi est égale t[i][j] *(t+(i+j))?

S'il y avait égalité parfaite et générale entre pointeur et tableau, alors t[i][j] serait égal à *(*(t + i) + j).
Le problème c'est que cette équivalence sont tu parles ne s'applique qu'aux tableaux en une dimension (toujours parce que la mémoire ne travaille qu'en 1D).
Ainsi si t'as un int t[100] et que tu passes "t" à une fonction fct(), celle-ci peut être indiféremment déclarée

• fct(int t[100]);
• fct(int t[]);
• fct(int *t);

Quelle que soit la déclaration, tu pourras utiliser t[i] ou *(t + i) sans problème.

Maintenant si t'as un int t[10][100] et que tu passes de nouveau "t" à une fonction fct, celle-ci ne peut être déclarée que de cette façon

• fct(int t[10][100]);
• fct(int t[][100]);
• fct(int (*t)[100]);

Et surtout pas "fct(int **t)" car le C aura toujours besoin d'avoir la valeur de la dernière dimension (100) pour calculer la position [i][j].
Et dans la fonction, tu pourras utiliser t[i][j]. Je pense que tu pourras aussi utiliser (*(t + i))[j] (à vérifier) mais en aucun cas tu pourras t'amuser à faire *(*(t + i) + j)

Et plus généralement, si t'as un tableau à n dimensions, tu n'as le droit d'appliquer l'équivalence "* <=> []" que sur la première dimension et tu dois spécifier explicitement toutes les autres.

[diogene]

Sve@r :

S'il y avait égalité parfaite et générale entre pointeur et tableau, alors t[i][j] serait égal à *(*(t + i) + j).
Le problème c'est que cette équivalence sont tu parles ne s'applique qu'aux tableaux en une dimension (toujours parce que la mémoire ne travaille qu'en 1D).

L'équivalence t[i] avec *(t+i) s'applique toujours quelque soit le type des éléments de t (y compris des tableaux)
On peut considérer t[i] comme un sucre syntaxique qui remplace avantageusement l'écriture *(t+i)
En conséquence, on a toujours t[i][j] équivalent à *(*(t + i) + j) (et on perçoit là l'avantage du sucre syntaxique)

Maintenant si t'as un int t[10][100] et que tu passes de nouveau "t" à une fonction fct, celle-ci ne peut être déclarée que de cette façon
fct(int t[10][100]);
fct(int t[][100]);
fct(int (*t)[100]);
Et surtout pas "fct(int **t)" car le C aura toujours besoin d'avoir la valeur de la dernière dimension (100) pour calculer la position [i][j].

C'est surtout que le type int ** est faux

Et dans la fonction, tu pourras utiliser t[i][j]. Je pense que tu pourras aussi utiliser (*(t + i))[j] (à vérifier) mais en aucun cas tu pourras t'amuser à faire *(*(t + i) + j)

On peut utiliser les trois possibilités

Et plus généralement, si t'as un tableau à n dimensions, tu n'as le droit d'appliquer l'équivalence "* <=> []" que sur la première dimension et tu dois spécifier explicitement toutes les autres.

ceci est donc également inexact

[Sve@r]

Sve@r :
L'équivalence t[i] avec *(t+i) s'applique toujours quelque soit le type des éléments de t (y compris des tableaux)
On peut considérer t[i] comme un sucre syntaxique qui remplace avantageusement l'écriture *(t+i)
En conséquence, on a toujours t[i][j] équivalent à *(*(t + i) + j) (et on perçoit là l'avantage du sucre syntaxique)


C'est surtout que le type int ** est faux
On peut utiliser les trois possibilités
ceci est donc également inexact

Hé oui, bien sûr. Un tableau étant lui-aussi un type, l'arithmétique des pointeurs fonctionne aussi pour lui. Ainsi, dans le cas de mon "int t[10][100]", si j'écris "t + i" j'irai sur l'adresse située à t + i * 100 * sizeof(int). Et de cette adresse je pourrai aller sur la case "j" située à t + (i * 100 + j) * sizeof(int).
Effectivement, l'écriture *(*(t + i) + j) fonctionne (et aussi l'écriture qui en découle à savoir *(t[i] + j). Je me demande pourquoi j'ai pensé le contraire. Peut-être parce que j'ai trop lu à divers endroits de ce fofo qu'un tableau n'était pas un pointeur et que si, pour un tableau "int t[10]" passé à une fonction on peut remplacer "int t[10]" par "int *t", on ne peut pas exporter ce remplacement aux autres dimensions (à savoir remplacer "int t[10][100]" par "int **t")