manipulation de pointeur

Version imprimable

21/09/2009, 21h39
sandball22

1 pièce(s) jointe(s)

manipulation de pointeur
Bonjour,

j'ai un tableau de pointeurs qui pointent sur des structures (cf image).

J'ai un pointeur p_current qui pointe sur une adresse de ce tableau.

j'aimerais parser le tableau. quand ce pointeur sera différent de NULL je dois un faire un traitement.

Est ce que les 2algo suivants sont bons?
le 1er consiste à parser le tableau tant que p_current est différent NULL(sachant que le p_curent du départ n'est pas NULL).
Code:

1 2 3 4 5 6 7 8 9 10 p_temp =p_current; while (p_temp!=NULL) { if (p_temp !=NULL) treat(p_temp); p_temp++; }
Pour le 2eme j'aimerais parser le tableau en commençant à l'adresse p_current
jusqu'à revenir jusqu' à l'adresse p_curent.

Comment dois je faire?
Merci de votre aide.
21/09/2009, 21h49
Grulim

Ton premier algo est pas tout à fait exact...
la condition du if est toujours vrai, sinon on est déjà sorti de la boucle while !

Si je comprends bien, dans ton premier algo, tu dois parcourir tout les pointeurs contenus dans ton tableau et pour ceux qui sont différents de NULL, tu dois exécuter un traitement, exact ?

Et dans ton deuxième algo, tu dois parcourir ton tableau comme s'il était circulaire ?
21/09/2009, 21h55
sandball22

oui c'est tout à fait ça.
Peux tu m'aider à les faire?
Merci
21/09/2009, 22h04
Grulim

Pour faire les 2 algos, tu dois avoir un pointeur sur le 1er élément du tableau.
21/09/2009, 22h06
sandball22

Je ne vois pas trop pourquoi car il faut que je parte du p_current qui peux être n'importe où.
Tu peux me détailler le code que tu ferais?
21/09/2009, 22h08
Grulim

Pour calculer la borne supérieure de ton tableau et donc savoir quand t'arrêter (pour le 1er algo) et quand retourner au 1er élément (pour ton 2ième algo).

Tu coderais ça comment? Car je ne suis pas très à l'aise avec les pointeurs.
Code:

1 2 3 4 5 6 7 8 9 p_temp =p_current; while (p_temp!=p_debut) { if (p_temp !=NULL) treat(p_temp); p_temp++; }

21/09/2009, 22h22
Grulim

presque...

si p_debut est un pointeur sur le 1er élément
si p_current est pointeur sur l'élément de départ
si N est le nombre d'éléments de ton tableau
si type est le type d'élément contenu dans ton tableau.
alors le code devrait ressembler à :
p_max = p_debut + N * sizeof(type);
for( p_temp = p_current; p_temp != p_max; ++p_temp )
{

}

Presque...

N = nombre d'éléments dans ton tableau.

Code:

1
2
3
4
5
6
p_max = p_debut + N;
for( p_temp = p_current; p_temp != p_max; ++p_temp )
{
   if (p_temp != NULL)
        treat(p_temp);
}

21/09/2009, 22h32
sandball22

et c'est pour le cas 1 ou 2?

En gros p_debut c'est le 1er élément et p_max le denier élément.
p_currrent va se balader entre le début et la fin? Ai je bien compris?
Par conte comment je peux faire pointer p_debut sur le 1er element?
Et si p_current ne pointe pas au début (ce qui peu être le cas ici) je n'aurais pas parser tout.
21/09/2009, 22h36
Grulim

c'est pour le 1er algo...

p_temp va se balader entre p_current (inclu) et p_max (exclu).

pour le 2ième, il faut changer la condition de sortie :
Ce n'est plus atteindre la borne max mais que p_temp soit égale à p_current une 2ième fois.
21/09/2009, 22h43
sandball22
1er cas: OK
2eme cas:
Code:

1 2 3 4 5 6 7 //p_max = p_debut + N; for( p_temp = p_current; p_temp != p_temp; ++p_temp ) { if (p_temp != NULL) treat(p_temp); }
Comment je peux faire pour dire que c'est la 2ème fois?

3ème case :et si ma condition de sortie est que lorsque qu'on parse le tableau tout est à NULL comment dois je faire?

Citation:
Envoyé par sandball22
2eme cas:
Code:

1 2 3 4 5 6 7 //p_max = p_debut + N; for( p_temp = p_current; p_temp != p_temp; ++p_temp ) { if (p_temp != NULL) treat(p_temp); }
Comment je peux faire pour dire que c'est la 2ème fois?
Attention ;) en C pas de commentaire //
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 int b_fois = 1; p_max = p_debut + N; p_temp = p_current; while( b_fois < 2 ) { if (p_temp != NULL) treat(p_temp); /* on avance sans dépasser la borne max */ if( ++p_temp == p_max ) p_temp = p_debut; /* on compte le nombre de fois qu'on passe devant p_current */ if( p_temp == p_current ) ++b_fois; }
[/quote]

Citation:

Envoyé par sandball22

3ème case :et si ma condition de sortie est que lorsque qu'on parse le tableau tout est à NULL comment dois je faire?

tu veux dire qu'on a jamais appelé treat() ?
Je pencherais pour un flag initialisé à 0 qu'on met à 1 quand on appelle la fonction : à la sortie de la boucle, il suffit de vérifier ce flag...

21/09/2009, 23h03
sandball22

pour le cas 2 je vois un peu mieux maintenant.

Pour le cas 3, ce que je veux faire c'est parser tout le temps le tableau. Et sortir une fois que tous les adresses sont a null mais en gardant le traitement quand c'est différent de null
21/09/2009, 23h06
sandball22

On est bien d'accord que pour le N c'est p_max = p_debut + N * sizeof(type)?
21/09/2009, 23h07
Grulim

Citation:

Envoyé par sandball22

On est bien d'accord que pour le N c'est p_max = p_debut + N * sizeof(type)?

Non, c'était une erreur de ma part : p_max = p_debut + N

Tu me fais faire un TD ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int b_appel = 0;
 
p_max = p_debut + N;
p_temp = p_current;
do
{
   if (p_temp != NULL)
   {
        treat(p_temp);
   }
   else
   {
        ++b_appel;
   }
 
   /* on avance sans dépasser la borne max */
   if( ++p_temp == p_max )
        p_temp = p_debut;
 
   /* Raz à chaque fois qu'on passe devant p_current */
   if( p_temp == p_current )
      b_appel = 0;
} while( b_appel < N );

21/09/2009, 23h19
sandball22

non je ne te fais pas faire un TD. J'ai une appli à faire et je pense aller soit sur le choix 2 ou 3.
Par contre je comprends pas trop la condition de sortie du 3"me cas.
21/09/2009, 23h27
sandball22

En gros il faut que je sorte quadn on a fait un tour et que tous le p_temp apres incrémentation sont null
21/09/2009, 23h50
sandball22

Conditions de sorties : il faut que le pointeur p_temp apres incrémentaion et après avoir fait un tour soit toujours null.
dans le cas contraire (p_temp!=NULL) on fait le traitement et je continue de parser à partir de ce nouvelle position de pointeur jusqu'à avoir fait un tour entier et que tous les pointeurs soient null et ainsi de suite..
Si quelqu'un pouvait m'aider pour cela? Merci d'avance
22/09/2009, 01h07
orfix

Citation:

Envoyé par Grulim

Attention ;) en C pas de commentaire //

Je n'aime pas non plus mais c'est bien du C :

Citation:

Envoyé par 6.4.9 Comments

Except within a character constant, a string literal, or a comment, the characters //
introduce a comment that includes all multibyte characters up to, but not including, the
next new-line character. The contents of such a comment are examined only to identify
multibyte characters and to find the terminating new-line character.

Voici un petit exemple de ce qui peut être fait.
J'ai fait ça avec int, mais pour d'autres types (struct) il suffit de quelques adaptations.

Code:

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
50
51
52
53
void treat(int* p)
{
	printf( "[%p] valeur=%d\n", p, *p );
}
 
void algo3()
{
	int ii, nb, annul;
	int** pdebut, ** pfin, ** pcur;
	int entiers[] = { 10, 20, 30, 40 };
	const int nb_elements = sizeof(entiers)/sizeof(entiers[0]);
	int* pointeurs[nb_elements];
 
	/* init du tableau de pointeurs */
	for( ii = 0; ii < nb_elements; ++ii )
	{
		pointeurs[ii] = &entiers[ii];
	}
 
	/* init des bornes du tableau */
	pdebut = &pointeurs[0];
	pfin = &pointeurs[nb_elements];
	pcur = &pointeurs[2];
 
	annul = 1;
	nb = 0;
	printf("DEBUT\n");
	while( nb < nb_elements )
	{
		if( *pcur != NULL )
		{
			treat( *pcur );
			/* raz compteur */
			nb = 0;
		}
		else
		{
			/* increment compteur de ptr NULL */
			++nb;
		}
 
		/* avancer sans dépasser la borne de fin */
		if( ++pcur == pfin )
		{
			pcur = pdebut;
			/* on NULLifie les pointeurs petit à petit */
			/* pour que la boucle se termine un jour */
			pointeurs[annul] = NULL;
			annul = (annul + 1) % nb_elements;
		}
	}
	printf("FIN\n");
}

22/09/2009, 18h22
sandball22

J'ai opté pour le cas 2 (on parcourt une fois jusqu'à revenir au p_current).
Comment je peux savoir ce que vaut p_debut?

Ok j'ai trouvé comment faire pour le 1er element.
Par contre j'aimerais parser mon tableua à partir de p_current mais exclu. En gros je voudrais que p_temp ne soit plus egal a p_current mais à p_current incrémenté. Est ce bon?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 int b_fois = 0; p_max = p_debut + N; p_temp = p_current+1; while( b_fois < 1 ) { if (p_temp != NULL) treat(p_temp); /* on avance sans dépasser la borne max */ if( ++p_temp == p_max ) p_temp = p_debut; /* on compte le nombre de fois qu'on passe devant p_current */ if( p_temp == p_current ) ++b_fois; }

23/09/2009, 09h49
Grulim

C'est pas suffisant :
Si p_current parcourt l'intervalle [p_debut;p_max[
alors p_current+1 peut être égale à p_max... et donc dépasser la borne max du tableau !
23/09/2009, 10h24
sandball22

concrêtement il faut que je fasse quoi alors?
23/09/2009, 10h34
Grulim

Faire en sorte que la valeur d'initialisation de p_debut ne puissent pas égaler p_max.
Une solution inélégante serait de remplacer :

Code:

p_temp = p_current+1;

par

Code:

p_temp = p_current+1 == p_max ? p_debut: p_current+1;

Je te laisse le soin de trouver une meilleure solution ;)

j'ai rajouté la condition suivante

Code:

1
2
3
4
5
6
7
8
9
 
	  if(p_Current == p_Fin)
	  	{
	  		 p_Temp=p_Debut+ 1 ;
	  	}
	  else
	  	{
	  	  p_Temp=a_hwlpc_Context->p_CurrentSession+ 1 ;
	  	}

et ensuite:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
while( b_fois < 1 )
{
   if (p_temp != NULL)
        treat(p_temp);
 
   /* on avance sans dépasser la borne max */
   if( ++p_temp == p_max )
        p_temp = p_debut;
 
   /* on compte le nombre de fois qu'on passe devant p_current */
   if( p_temp == p_current )
        ++b_fois;
}

Est ce bon?

23/09/2009, 10h51
Grulim

p_Fin est équivalent à p_max ?
Si oui, ton test

Code:

if(p_Current == p_Fin)

ne sera jamais vérifié puisque p_Current est compris dans l'ensemblre [p_Debut;p_Fin[ (p_Fin est exclu) et donc p_Current ne peut jamais être égal à p_Fin.
Par contre p_Current + 1, oui !

Et d'ou vient ce

Code:

a_hwlpc_Context->p_CurrentSession

?
C'est quoi ?

OUPS!

Code:

1
2
3
4
5
6
7
8
9
10
 
 
	  if(p_Current+1 == p_Max)
	  	{
	  		 p_Temp=p_Debut+ 1 ;
	  	}
	  else
	  	{
	  	  p_Temp= p_Current+ 1 ;
	  	}

Là est ce bon?

23/09/2009, 11h10
Grulim

ça me semble juste.

J'aimerais récupérer l'indice de mon tableau avant ma fonction de treat. Est se possible? sachant que p_debut =a_Tab[0] et p_max=a_Tab[N].
A savoir:

Code:

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
 
	  if(p_Current+1 == p_Max)
	  	{
	  		 p_Temp=p_Debut+ 1 ;
	  	}
	  else
	  	{
	  	  p_Temp= p_Current+ 1 ;
	  	}
 

while( b_fois < 1 )
{
   if (p_temp != NULL)
      { 
        for(int i=0; i<N; i++)
          { 
             if ( p_Temp ==  a_Tab[i]) 
                       treat(i);
          } 
      }
   /* on avance sans dépasser la borne max */
   if( ++p_temp == p_max )
        p_temp = p_debut;
 
   /* on compte le nombre de fois qu'on passe devant p_current */
   if( p_temp == p_current )
        ++b_fois;
}

Est ce bon? Ou y a t'il plus simple.?

24/09/2009, 09h35
Grulim

Il y a plus simple :

Code:

index = (p_Temp - p_Debut) / sizeof(p_Debut[0])