Discussion :

[Amnael]

Bonjour, bonsoir

Je ne comprends pas ce qui se passe, je fais une fonction qui va me remplir un tableau

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* stockAdresse()
{
	int  nb;
	int *adresse=malloc(sizeof(int));/*on considère que l'on a au moins une adresse à lire*/
	int cpt=0;
 
	while(fscanf(stdin,"%d",&nb) != EOF)
     {
       adresse[cpt++]=nb; 
       adresse=realloc(adresse,(cpt+1)*sizeof(int)); 
     }
 
	return adresse;
}

Je récupère le tableau et je veux donc aussi récupérer sa taille, mais je n'obtiens pas la bonne taille !!!

Code :

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

1
2
adresse=stockAdresse();
	nbAdresse=sizeof(adresse);

Du coup je récupère toujours quelques valeurs de trop...

[Bktero]

Tu n'obtiendrais pas toujours 4 ?

As -tu essayé d'afficher la valeur donnée par sizeof(int*) ?

[Sve@r]

Je récupère le tableau et je veux donc aussi récupérer sa taille, mais je n'obtiens pas la bonne taille !!!

Code :

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

1
2
adresse=stockAdresse();
	nbAdresse=sizeof(adresse);

Du coup je récupère toujours quelques valeurs de trop...

Bonjour
adresse c'est un char* donc un pointeur donc une adresse donc un truc valant 4 octets...

[Amnael]

J'ai bien déclaré adresse comme un int* dans mon main !



Par exemple si sur mon entrée standard je dois lire ceci

21
32
25
12
15
44
27

en théorie mon nbAdresse devrait valoir 7

Hors il vaut 8 en réalité en faisant sizeof de mon tableau


Mais si sur mon entrée je n'ai que 6 valeur nbAdresse doit alors valoir 6 et il a toujours 8 en valeur.



Je vois bien que ça vien de cette histoire de 4 octet mais je ne vois pas comment régler le problème....diviser par la taille d'un int m'amènerait sur une taille de 2 et c'est pas ce que je veux.

[Sve@r]

en théorie mon nbAdresse devrait valoir 7

Hors il vaut 8 en réalité en faisant sizeof de mon tableau


Mais si sur mon entrée je n'ai que 6 valeur nbAdresse doit alors valoir 6 et il a toujours 8 en valeur.

Tu n'as pas bien saisi: la taille d'une adresse c'est toujours 4 octets (ou 8 en architecture 64 bits), que l'adresse pointe sur une zone allouée à 1, 10, 100, 1000 ou 10000 octets. Le C ne connait que l'adresse de début de la zone et rien d'autre. C'est d'ailleurs pour ça qu'il ne peut rien te dire quand tu dépasses. Donc c'est à toi de gérer ta taille toi-même.

De plus, la réallocation "à la demande" nécessite une gestion un peu plus fine. En effet, pour ne pas faire du realloc à chaque item (lourd), on fait généralement de la reallocation "par blocs". On a donc besoin de gérer la taille allouée et aussi la taille utilisée. Donc pour éviter de se trimballer toutes ces variables, on encapsule tout ça dans une jolie structure.

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
36
37
38
39
40
41
typedef struct {
	int *data;
	size_t sz_alloc;
	size_t sz_util;
} t_alloc;   
 
int* stockAdresse(t_alloc *zone)
{
	int  nb;
	int *tmp;
 
	while(fscanf(stdin,"%d",&nb) != EOF)
	{
		// Si la taille utilisée atteint la taille allouée (ce qui arrive fatalement à la première itération puisque les valeurs sont à 0)
		if (zone->sz_util == zone->sz_alloc)
		{
			// On agrandit la zone de X éléments
			zone->sz_alloc+=X;						// A toi de définir X (à 10, 100, 1000, même à 1 si tu veux faire du realloc ajusté)
 
			// On fait une reallocation/allocation
			tmp=realloc(zone->data, zone->sz_alloc * sizeof(int));				// Si zone->data vaut NULL (ce qui arrive fatalement à la première itération), realloc se comporte comme malloc
 
			// Si l'allocation/reallocation a échoué on arrête tout (mais on n'oublie pas de libérer ce qui a été alloué)
			if (tmp ==NULL)
			{
				free(zone->data);
				zone->data=NULL;
				return NULL;
			}
 
			// L'allocation/reallocation a réussi - On la sauvegarde
			zone->data=tmp;
		}
 
		// Ici on a de la place pour stocker le nb lu et on incrémente le compteur des éléments stockés
		zone->data[zone->sz_util++]=nb;
	}
 
	// La fonction a terminé - On lui fait renvoyer une valeur non nulle
	return zone->data;
}

Suffit que tu déclares une variable "toto" de type t_alloc, que tu initialises tous ses éléments à 0 (hyper important car l'algo se base là dessus) puis que tu passes &toto à la fonction. Déroule là à la main. Tu verras que quand celle-ci se termine toto.data contient les éléments saisis, toto.sz_util contient le nb d'élements saisis (et toto.sz_alloc contient la taille allouée)...

[Amnael]

Ok, j'aurais pensé qu'il y avait un moyen plus simple d'obtenir la taille; je vais donc adopter ta solution, à moins que je ne mette directement le code dans mon main pour pas m’embêter, après tout, faire une fonction qui ne sert qu'une fois c'est un peu moyen...

[Sve@r]

après tout, faire une fonction qui ne sert qu'une fois c'est un peu moyen...

Oui mais comme cette fonction s'adapte très facilement, si tu la mets à part tu peux facilement la recopier pour la réutiliser ailleurs. Tu verras à l'usage que même qu'une seule fois, les fonctions dédiées ont du bon...