Discussion :

[dtrack]

Bonjour, je debute en C et j'ai plusieurs questions:

- Existe-t-il des logiciels qui permettent d'executer pas a pas un programme en affichant le tas, c'est a dire ou l'on peut visualiser graphiquement nos pointeurs et vers quoi ils pointent ??

- Je cherche a afficher l'adresse de la case memoire ou pointe mon pointeur comment dois-je faire?
j'ai essaye ceci :

Code :

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

printf("adresse : %s",&ram)

(mon pointeur s'appelant ram)
Le resultat est comme je pensais une erreur : ca me dit que le type ne correspond pas. Donc quel est le type d'une adresse?

Merci d'avance.
Jeremy


PS : une derniere question : une fonction peut-elle renvoyée plusieurs resultats? par exemple si je fais un algorithme de parcours dans une matrice peut -elle me renvoyer 2 entiers i et j qui me disent a quelle case je me situe ou faut-il que j'ecrive une fonction pour i et une pour j ?

[Cemos]

Code :

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

1
2
3
4
5
6
7
8
9
 
 
#include <stdio.h>
 
void main()
{
      int i=0;
      printf("%p\n", &i);
}

le %p donne l'affichage d'un pointeur d'argument.
le %X le donne en hexadécimal.

En ce qui concerne la seconde question, bien sur que non.

Une fonction ne renvoit une et une seule valeur.
Si tu veux retourner deux valeurs, tu dois raisonner en terme de passage de parametre par adresse et non plus par valeur.

Pour illustrer cette phrase :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
void cube(int *nombre)
{
       *nombre=*nombre * *nombre * *nombre;
}
 
void main()
{
       int i=3;
       cube(&i);
       printf("%d", i);
}

printf() retournera 27.

Tu vois ici, j'utilise une procédure, donc aucun retour de valeur, pourtant, ma valeur de i a été modifiée dans la procédure.

par valeur :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
int cube(int nombre)
{
       nombre=nombre * nombre * nombre;
       return nombre;
}
 
void main()
{
       int i=3;
       i=cube(i);
       printf("%d", i);
}

Dans ton cas, tu dois retourner deux valeurs, donc impossible de faire par valeur. Tu dois donc travailler par adresse.

[Emmanuel Delahaye]

Code :

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

1
2
3
4
5
6
7
8
 
#include <stdio.h>
 
void main()
{
      int i=0;
      printf("%p\n", &i);
}

le %p donne l'affichage d'un pointeur d'argument.
le %X le donne en hexadécimal.

Beaucoup d'approximations en si peu de lignes...

• Le type retourné par main() est int. Toujours.
• %p attend un type void*
• %X attend un unsigned int et non une valeur de pointeur (adresse).

Code :

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

1
2
3
4
5
6
7
8
9
 
#include <stdio.h>
 
int main(void)
{
    int i;
   printf("&i = %p\n", (void *) &i);
   return 0;
}

[Emmanuel Delahaye]

PS : une derniere question : une fonction peut-elle renvoyée plusieurs resultats? par exemple si je fais un algorithme de parcours dans une matrice peut -elle me renvoyer 2 entiers i et j qui me disent a quelle case je me situe ou faut-il que j'ecrive une fonction pour i et une pour j ?

Non. Les structures sont utiles pour ça...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
struct xy
{
   int x;
   int y;
};
 
 
...
{
   struct xy pos = {0, 0};
 
   get_pos (&pos);
}

avec

Code :

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

void get_pos (struct xy *p);

exemple basique. Dans la réalité, il y a probablement d'autres paramètres.

[dtrack]

Merci beaucoup pour votre aide mais je n'arrive toujours pas a afficher la valeur de l'adresse de ram, voici mon code :
(j'ai oté toutes les fonctions precedents le int main() pour simplifier.

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
int main(){
 
/***************************************Declaration des variables*********************************************************/
       struct cluster_spe *ram_full=NULL;     //declaration d'un pointeur sur le premier cluster de la RAM
       struct cluster *ram=NULL;              //declaration d'un pointeur sur le cluster suivant de la RAM
       struct cluster *hdd=NULL;              //declaration d'un pointeur sur le cluster du HDD
       int i;
/***************************************Fin de declaration des variables**************************************************/
 
/******************************Mise en place de la structure de la RAM************************************
   Pour simplifier le deplacement dans la RAM on a le pointeur ram_full qui pointe sur la RAM entiere
   (le cluster special de pile et les clusters cases memoires qui suivent) et le pointeur ram qui pointe
    directement sur la premiere case memoire.                                                           */
       ram_full=structure_ram();     //appel a la fonction qui structure la RAM (cf commentaire de la fonction structure_ram)
       ram=ram_full->down;           //le pointeur ram pointe sur la premiere case memoire de la RAM (donc sur le 2e cluster)
/******************************Fin de la mise en place de la RAM******************************************/
 
printf("adresse de depart de la ram: %p\n",&ram);
       return 0;
}

Ce code me renvoie en texte "adresse de depart de la ram" avec rien comme valeur.

Ma fonction structure_ram est bonne car mon deboggeur en mode pas a pas me montre les adresses de mes pointeurs au fur et a mesure et j'ai pu verifier...

Que dois-je ecrire dans mon printf pour reussir a avoir l'adresse de mon pointeur svp?
Merci d'avance

[Emmanuel Delahaye]

Merci beaucoup pour votre aide mais je n'arrive toujours pas a afficher la valeur de l'adresse de ram, voici mon code :
(j'ai oté toutes les fonctions precedents le int main() pour simplifier.

Crois-tu vraiment que la valeur de l'adresse a une signification quelconque ?

Si tu y tiens, la valeur s'affiche avec "%p" et le cast (void*)

Ce code, même mieux présenté, n'est pas complet :

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
 
#include <stdio.h>
 
int main (void)
{
/* declaration d'un pointeur sur le premier cluster de la RAM */
   struct cluster_spe *ram_full = NULL; 
/* declaration d'un pointeur sur le cluster suivant de la RAM */
   struct cluster *ram = NULL;  
/* declaration d'un pointeur sur le cluster du HDD */
   struct cluster *hdd = NULL;  
   int i;
 
 
/*
   Pour simplifier le deplacement dans la RAM on a le pointeur ram_full qui 
   pointe sur la RAM entiere (le cluster special de pile et les clusters cases 
   memoires qui suivent) et le pointeur ram qui pointe directement sur la 
   premiere case memoire.
*/
 
/* appel a la fonction qui structure la RAM (cf commentaire de la fonction 
   structure_ram) */
   ram_full = structure_ram (); 
 
/* le pointeur ram pointe sur la premiere case memoire de la RAM 
   (donc sur le 2e cluster) */
   ram = ram_full->down;        
 
   printf ("adresse de depart de la ram: %p\n", (void *) &ram);
   return 0;
}

Tu cherches à visualiser l'adresse d'un pointeur. C'est voulu ? Quel intérêt ?

Tu veux peut être l'adresse du bloc :

Code :

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

   printf ("adresse de depart de la ram: %p\n", (void *) ram);

[publicStaticVoidMain]

Concernant la 1ere question, si t'es sur linux, je te conseille gdb. C'est un très bon outil pour faire du déboguage.

[dtrack]

Merci beaucoup Emmanuel ca marche avec ta reponse, bien que je ne comprenne pas le sens du (void *).
En fait je voulais visualiser les adresses ou pointaient mes pointeurs juste pour verifier que mes algorithmes de parcours ne sont pas buggues, par exemple lorsque jarrive a la derniere case de ma liste il doit poinrer sur NULL et lorsque jessaye daller encore plus loin je dois avoir une erreur.

Merci encore, et pour la suggestion sous linux de publicStaticVoidMain ce compilateur permet de visualiser graphiquement les listes chainees par exemple??
Joyeux noel tardif
Jeremy

[Pierre Maurette]

Merci beaucoup Emmanuel ca marche avec ta reponse, bien que je ne comprenne pas le sens du (void *).

Le dernier cast (void*) est me semble-t-il inutile, donc dangeureux.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
	const char* test[] = {"Pierre"};
	struct debil {
	    int i;
	};
	struct debil* ram = NULL;
	struct debil r = {0};
	ram = &r;
	printf("1 - %p %p %p %s\n", test, &test[0], test[0], test[0]);
	printf("2 - %p %p\n", (void*)i, &i);
	printf ("3 - %p\n", ram);
	printf ("4 - %p\n", (void*)ram);
	printf ("5 - %p\n", (void*)(ram->i));
	printf ("6 - %p\n", &ram->i);

En 1, on se passe de (void*), et tout va bien. En 2, on transtype volontairement un entier en (void*), pour faire accepter cette opération par le compilateur. Le comportement est "implementation defined", mais l'opération peut être tout à fait utile. En 3, on affiche normalement un pointeur. En 4, on utilise un cast inutile, mais qui ne fait rien de mal. En 5, on affiche la valeur du champ i (un int) de *ram transtypé en (void*). Pas de message du compilateur, mais est-ce bien ce que nous voulions ? N'était-ce pas plutôt ce qui est en 6 ?

Merci encore, et pour la suggestion sous linux de publicStaticVoidMain ce compilateur permet de visualiser graphiquement les listes chainees par exemple??

Ce que vous cherchez est un débogueur (debugger ?) graphique. Sous Linux, ce sera un[e tentative de] front-end devant gdb. Il existe peut-être une alternative chez Intel.
Vous pouvez utiliser gdb en console, mais il n'est pas indispensable de souffrir pour apprendre. Il existe donc un truc qui s'appelle DDD, je l'ai essayé une fois puis viré, ce n'était pas stable à cette époque. Aujourd'hui, je préfère (c'est personnel) l'intégration dans Eclipse / CDT à celle de Code::Blocks. KDbg, installé avec KDevelop, semble bien fichu, et peut se lancer seul en tant qu'outil indépendant. Anjuta doit avoir aussi son intégration de gdb, mais je ne connais pas.
Je ne suis pas sûr que "afficher le tas" ait du sens. Vous allez surveiller, inspecter, la mémoire réservée éventuellement dans le tas. Par le nom des variables, adresses renvoyées par malloc() comprises.

[Pierre Maurette]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
void cube(int *nombre)
{
       *nombre=*nombre * *nombre * *nombre;
}
 
void main()
{
       int i=3;
       cube(&i);
       printf("%d", i);
}

printf() retournera 27.

Pas 2, plutôt ?

[dtrack]

Merci beaucoup Pierre,
En fait je demande tout ca parce que je cherche un moyen simple de verifier mes algo.
Par exemple je viens de faire un algorithme qui construit une sorte de matrice (n,m) ou chaque element de la matrice contient des informations, un pointeur a droite et un pointeur en bas.
Sur la premiere ligne de la matrice chaque element pointe sur son suivant a droite, et sur son suivant en bas.
Ensuite sur les lignes suivants les elements pointent juste vers le bas.

Mon souci est juste de realiser des tests pour verifier la structure. Puis plus tard pour verifier que mon algorithme de parcours pointera bien vers le bon element.
Merci encore ...

[Pierre Maurette]

Merci beaucoup Pierre,
En fait je demande tout ca parce que je cherche un moyen simple de verifier mes algo.
Par exemple je viens de faire un algorithme qui construit une sorte de matrice (n,m) ou chaque element de la matrice contient des informations, un pointeur a droite et un pointeur en bas.
Sur la premiere ligne de la matrice chaque element pointe sur son suivant a droite, et sur son suivant en bas.
Ensuite sur les lignes suivants les elements pointent juste vers le bas.

Mon souci est juste de realiser des tests pour verifier la structure. Puis plus tard pour verifier que mon algorithme de parcours pointera bien vers le bon element.
Merci encore ...

J'aime bien les débogueurs, comme en général tous les outils. Mais dans votre cas je ne suis pas certain que ce soit utile, je pense même le contraire. En tout cas ce n'est pas "un moyen simple".
Ce que vous pourriez faire, c'est écrire un module de tests et de validation en même temps que vos fonctions. Et ne pas faire comme je l'ai fait trop souvent, l'écrire avec le code principal et l'effacer trop rapidement. Gardez-le sous la main, pour y revenir en cas de doute ou de modifications dans le code. Ça demande un peu d'imagination, mais c'est payant. Un truc idiot: si vous générez de grandes quantité d'indications en sortie, redirigez vers un fichier texte et utilisez les outils du shell ou de votre éditeur pour faciliter l'analyse des résultats.
Vous pourrez également voir du coté des outils comme valgrind, mais de toutes façons ça marche au départ de concert avec des bouts de test.
Bon copurage...

[dtrack]

Merci beaucoup,
J'ai reussi a tester toutes mes fonctions mais dans la procedure principale je ne vois pas trop ou vous voulez en venir quand vous dites :

Ce que vous pourriez faire, c'est écrire un module de tests et de validation en même temps que vos fonctions.

??

Sinon j'ai encore une question:
Je ne sais pas trop comment poser la question donc je vais mettre mon code:

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
50
51
52
53
54
#include <stdio.h>
#include <stdlib.h>
 
/***************************************DECLARATION DES VARIABLES GLOBALES******************************************************/
       struct cluster_spe *ram_full=NULL;     //declaration d'un pointeur sur le premier cluster de la RAM
       struct cluster *ram=NULL;              //declaration d'un pointeur sur le cluster suivant de la RAM
       struct cluster *hdd=NULL;              //declaration d'un pointeur sur le premier cluster du HDD
/***************************************FIN DE DECLARATION DES VARIABLES GLOBALES***********************************************/
 
 
/****************************************Debut de la foncion qui mesure l'espace libre de la RAM ou du HDD/***************/
int espace_libre(struct cluster *ptr){
    int i=0;
    struct cluster *temp=NULL;
    temp=ptr;    
    while (ptr!=NULL){
          while (temp!=NULL){
                if (temp->processus==NULL) i++;
                temp=temp->down;
                }
          ptr=ptr->right;
          temp=ptr;
          }
    return i;
};
/****************************************Fin de la foncion qui mesure l'espace libre de la RAM ou du HDD******************/
 
 
 
 
/****************************************Debut de la foncion qui mesure l'espace libre total******************************/
int espace_total(){
    int i,j;
    i=espace_libre(ram);
    j=espace_libre(hdd);
    i=i+j;
    return i;
};    
/****************************************Fin de la foncion qui mesure l'espace libre total********************************/
 
 
 
 
 
/****************************************DEBUT DE LA PROCEDURE PRINCIPALE*************************************************/
int main(){
       int i,j;
       i=espace_libre(ram);
       j=espace_libre(hdd);
       printf("Espace libre dans la RAM: %d mo; dans le HDD: %d mo.\n",i,j);
       i=espace_total;
       printf("Espace libre total: %d mo.\n",i);
       return 0;
}

Bon j'ai passé tout le code inutile: Lorsque j'affiche le resultat de mes fonctions espaces libres j'ai 20 mo et 200 mo donc l'espace total vaut 220 mo.
Lorsque j'affiche le resultat de espace_total j'obtiens une valeur completement absurde du genre 3214859 mo.

Precision: - ram pointe sur une liste chainee de 20 struct clusters et HDD pointe sur une liste de 20*10 elements soient 200 elements.
- J'ai 2 fonctions structure_ram et structure_hdd qui s'occupent de structurer HDD et RAM, cependant ces 2 fonctions sont executees dans le main.

Ma question : pourquoi est-ce que ma fonction espace_total ne retourne pas 220 puisque cest la somme de espace_libre(ram) et espace_libre(hdd) qui valent 20 et 200.
Merci

[coyotte507]

parceque tu as oublié des parenthèses.

[dtrack]

merci :-D
C'est dingue commet un petit détail peut faire une si grande absurdité sans générer d'erreur ...