Discussion :

[karl3i]

Bonjour à tous,

devant convertir un programme Fortran en C, je cherche comment faire pour déclarer un tableau à index négatifs.
Par exemple, je dois me servir du tableau montab, dont le premier élément est à l'index -100 et le dernier élément à l'index +100.

Il me semble l'avoir trouvé hier sur un post de developpez.com, malheureusement hier je ne pensais pas en avoir besoin, et aujourd'hui je ne le retrouve plus. La solution consistait en une allocation mémoire, en indiquant l'index du premier élément et l'index du dernier élément, et notamment de contrôler qu'on avait bien index premier élément >= index dernier élément.

Si vous savez comment faire ou pouvez me réorienter sur ce post que je ne trouve plus...

Merci beaucoup,

Guilhem.

[Elijha]

Salut

A essayer selon tes besoins

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
19
20
21
22
23
24
25
#include <alloc.h>
#include <stdio.h>
 
int *sommet,    // Sommet d'un tableau de N éléments
    *tab ;      // Milieu du tableau ci-dessus
 
void main(void)
  { int i ;
 
  sommet = (int*)malloc((1+(2*100))*sizeof(int)) ;
  if(sommet==NULL)
    {
    printf("Erreur allocation\n") ;
    exit(0) ;
    }
  else tab = sommet+101 ;       // On pointe au milieu
 
  for(i=-100; i<100; i++)       // Init avec index négatif
    tab[i] = i ;
 
  for(i=0; i<201; i++)          // Juste pour voir le résultat
    printf("(%d) %d\n", i, *(sommet+i)) ;
 
  free(sommet) ;                // Libération de la mémoire
  }

1. Alloctaion d'un tableau de 201 cases.
2. On pointe au centre [-100][0][+100].
3. On y accède par index négatif.

Voila...

[karl3i]

Elijha, un grand merci.
J'avais commencé à me lancer dans un décalage des indices pour passer du code Fortran en C, mais ca devenait rapidement difficile. Je vais maintenant pouvoir simplement utiliser les fonctions existantes en leur passant ce tableau.

Voici le code final que j'ai pris (pour que ca aille vraiment de -100 à +100 en passant par zéro).

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
19
20
21
22
23
24
25
 
#include <stdlib.h> 
#include <stdio.h> 
 
int *sommet,    // Sommet d'un tableau de N éléments 
    *tab ;      // Milieu du tableau ci-dessus 
 
void main(void) 
  { int i ; 
 
  sommet = (int*)malloc((1+(2*100))*sizeof(int)) ; 
  if(sommet==NULL) 
    { 
    printf("Erreur allocation\n") ; 
    exit(0) ; 
    } 
   else tab = sommet+100 ;       // On pointe au milieu 
 
  for(i=-100; i<=100; i++)       // Init avec index négatif 
  {
    tab[i] = i ; 
	printf("tab[%d]=%d # \n",i,tab[i]);
  }
  free(sommet) ;                // Libération de la mémoire 
}

[Elijha]

Euh, désolé, mais effectivement ma première boucle est fausse, et tu as bien fait de la corriger.

Code :

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

1
2
  for(i=-100; i<=100; i++)       // de -100 à +100 et non pas 99
    tab[i] = i ;

Par contre si tab = sommet + 100, tu vas pointer sur l'élément d'index -1 et non pas 0. C'est pour cela qu'il y a une allocation de 2x100 éléments +1 éléments qui représente l'index 0.

Code :

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

1
2
3
4
        0                       200 --> index par rapport à sommet
       -100      -1  0  1       100 --> index par rapport à tab
       [x.........x][x][x.........x]
sommet--^       tab--^

Enfin je pense, non ?

bye...

[karl3i]

Sommet est bien le pointeur sur l'index -100, non ?
Donc si je lui ajoute 100, j'arrive bien sur l'index 0 ?

D'ailleurs en essayant de faire Sommet + 101, j'ai une erreur de type mémoire ne peut pas être read à la fin de l'éxécution.

Qu'en penses-tu ?

[Elijha]

Le problème vient du fait de la taille du tableau. Si je prend un tableau allant de -5 à +5, j'aurai

Code :

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

[-5][-4][-3][-2][-1][0][+1][+2][+3][+4][+5]

Donc normalement 10 cases !!? Eh bien, non 11 cases, car l'élément à l'index 0 existe vraiment. Euh, t'as compris

Donc

Sommet est bien le pointeur sur l'index -100, non ?

Oui.

Donc si je lui ajoute 100, j'arrive bien sur l'index 0 ?

Non, à -1.

D'ailleurs en essayant de faire Sommet + 101, j'ai une erreur de type mémoire ne peut pas être read à la fin de l'éxécution.

Ah ? Je pense que t'as voulu dire tab+101. Là c'est normale, car tab = [0] = 1 élément. Donc tab+101 = index 0 (donc 1)+101 = 102 résultat dépassement de tableau.

Essaye avec un tableau de -5 à +5, c'est plus vite dessiné qu'un tableau de 200 cases .

Conclusion : Tu n'aurais pas ce problème, si le nombre de cases était impaire, puisque naturellement tu as un point milieu. Dans notre cas le nombre de cases est paire, donc pas de point milieu. On est obligé d'en ajouter un.

[karl3i]

Tu n'aurais pas ce problème, si le nombre de cases était impaire, puisque naturellement tu as un point milieu. Dans notre cas le nombre de cases est paire, donc pas de point milieu. On est obligé d'en ajouter un.

Mais justement on a un nombre impaire de cases non ?
Prenons sur -5, 5 comme tu conseilles judicieusement

Code :

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

1
2
 
[-5][-4][-3][-2][-1][0][+1][+2][+3][+4][+5]

Je compte personnellement 11 cases ou j'ai loupé quelque chose ???

D'autre part, je voulais dire en faisant

Code :

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

tab = sommet+101

cad ce qui devrait être l'initialisation de tab, j'obtiens une erreur read.
Par contre avec

Code :

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

tab = sommet+101

ca s'éxécute bien.


Reprenons :

Sommet est bien le pointeur sur l'index -5, non ?
Tu m'as dit :

Oui.

Donc si je lui ajoute 5, j'arrive bien sur l'index 0 ?
Tu m'as dit :

Non, à -1.

Mais pourtant...

[-5][-4][-3][-2][-1][0][+1][+2][+3][+4][+5]

Sommet pointe sur le premier élément cad [-5]. Et si je compte 5 cases à partir de [-5], moi j'arrive bien à [0].


Bon je suis désolé si je t'embrouille mais je ne vois pas la faille de mon raisonnement. Et j'ai pourtant fait pleins de petits dessins !

[norac]

petit aide sur le comptage

de -5 à 0 il y a : -5 ; -4 ; -3 ; -2 ; -1 ; 0

donc il y a 6 éléments

mais si tu pointe sur -5 et que tu ajoute +5 tu arrive là aussi sur 0

cela dépend si tu compte l'éléments sur le quel tu te trouve.

J'espere que ça va vous aidez !!!

@+

[karl3i]

Salut Norac,

de -5 à 0 il y a : -5 ; -4 ; -3 ; -2 ; -1 ; 0 donc il y a 6 éléments

Et donc de -5 à +5, il y en a 11, c'est bien ca ? Donc un nombre impaire d'éléments.

[Elijha]

Salut

Le problème c'est l'index 0, et comment l'on compte comme l'a précisé norac (merci d'ailleur). Le but du jeux (enfin je crois) c'est que pour des raisons de comptage, tu es autant de cases à droite et à gauche de la case index 0. Sinon, avec tab = sommet+100, tu auras 99 cases à gauche et 100 à droite. Avec tab = sommet+101, tu auras un tableau équilibré (comme une balance ).

Mais pour éviter de trop ce prendre la tête sur ce problème de taille de tableau, et si tu n'est pas trop limite en mémoire, alloue qql cases en plus de ton tableau, de tel façon à ne pas avoir des problèmes d'overflow.

Je suis désolé de t'avoir embrouillé juste pour question d'équilibrage d'un tableau

Bye...

[karl3i]

En fait, je voudrais compter comme compte le compilateur, pas autrement.

En me trouvant sur l'index 0, j'ai "à gauche" les index de -100 à -1, soit 100 éléments et j'ai "à droite" les index de 1 à 100, soit 100 éléments aussi. C'est bien ce qui correspond à ta définition de tableau équilibré, non ?

Non, je ne souhaite pas allouer de cases mémoires en plus, car je veux justement savoir si dans le programme qui suivra le tableau ne se remplit que là où je le souhaite.

Sinon, essaie un petit coup le code suivant, en décommentant une des deux lignes avant le free. Tu auras une erreur read. Donc mon tableau me semble équilibré.

Enfin, t'inquiète pour m'embrouiller, parce que maintenant j'ai bien compris et c'est aussi grâce à toi que je sais comment indexer négativement un tableau maintenant .

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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <stdlib.h> 
#include <stdio.h> 
 
int *sommet,    // Sommet d'un tableau de N éléments 
    *tab ;      // Milieu du tableau ci-dessus 
int count1,count2;
 
void main(void) 
  { int i ; 
 
  sommet = (int*)malloc((1+(2*100))*sizeof(int)) ; 
  if(sommet==NULL) 
    { 
    printf("Erreur allocation\n") ; 
    exit(0) ; 
    } 
   else tab = sommet+100 ;       // On pointe au milieu 
 
  for(i=-100; i<=100; i++)       // Init avec index négatif 
  {
    tab[i] = i ; 
	printf("tab[%d]=%d # \n",i,tab[i]);
  }
 
  count1=0;
  count2=0;
 
printf("Nombre d'elements a gauche de 0\n");
for(i=-100;i<0;i++)
{
	count1++;
}
 
printf("Nombre d'elements a droite de 0\n");
for(i=1;i<101;i++)
{
	count2++;
}
 
if(count2==count1)
printf("Tableau equilibre \n");
 
tab[-100]=1;
tab[100]=1;
//tab[101]=1;
//tab[-101]=2;
  free(sommet) ;                // Libération de la mémoire 
}

[Elijha]

Dans ce cas oui, car tu n'utilise pas l'index 0.

Code :

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

1
2
3
4
5
6
7
8
for(i=-100;i<0;i++) // i vas de -100 à -1 !!!!
{ 
   count1++; 
}
for(i=1;i<101;i++)  // i vas de 1 à 100 !!!
{ 
   count2++; 
}

Donc la case d'index 0 (c.a.d. tab[0]) ne servira pas.

Bon, j'arrête d'insister sur ce problème et bonne continuation.

bye...

[karl3i]

Dans ce cas oui, car tu n'utilise pas l'index 0.

Ce n'est pas que je ne l'utilise pas, c'est que je ne le compte pas : je regardais seulement les éléments "à droite et à gauche" de l'index 0, sans inclure l'index 0.

En mettant mon pointeur sur index 0, j'ai donc autant d'éléments à droite qu'à gauche.
Mais dans mon programme, oui, j'utiliserais l'emplacement d'index 0.

Voilà

[D[r]eadLock]

Sinon, avec tab = sommet+100, tu auras 99 cases à gauche et 100 à droite. Avec tab = sommet+101, tu auras un tableau équilibré (comme une balance ).

De 0 a 99, ca fait 100 cases, la 100 c'est pour le 0 et de 101 a 200, ca fait les 100 a droite. Donc tab = sommet + 100

sommet[0] = tab[-100]
sommet[1] = tab[-99]
...
sommet[99] = tab[-1]
sommet[100] = tab[0]
sommet[101] = tab[1]
...
sommet[200] = tab[100]

Ou encore, si on reprend ton tableau :

Code :

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

1
2
3
4
        0        99 100 101     200 --> index par rapport à sommet 
       -100      -1  0  1       100 --> index par rapport à tab 
       [x.........x][x][x.........x] 
sommet--^       tab--^

[Elijha]

Logique.
Ok je me rend Je ne sais pas comment j'ai fait pour m'embrouiller tous seul ???

Alors, encore désolé

bye....