Comment savoir la taille d'une variable

Bonjour à tous,

J'aimerai savoir si il existe un moyen de savoir la taille d'un objet non-fixe.
Par exemple, j'ai un tableau à 2 dimensions de style tab[nbPoints][3] et j'aimerai savoir la taille qu'il prends en memoire.
j'ai essayé de faire

Code:

---

sizeof(**tab)

---

mets ca me retourne une taille de 8 octets pour plus de 330 000 points.

J'aimerai aussi savoir cette methode pour savoir la taille d'un objet lui aussi dependant du nombre de points que j'utilise comme une boite noire, cad je l'utilise mais je ne sais pas ce qu'il y a derriere.

Merci d'avance de vos reponses

PS : je developpe sous VC++ 6.0

Utilise un vector.
http://c.developpez.com/faq/cpp/?pag...taille_tableau

Malheureusement je ne peux pas car le tableau mon tableau à 2 dimensions et ensuite un parametre de la fonction "boite noire" que j'utilise apres donc je ne peux pas utiliser un vector pour créer mon tableau :arf:

petit precision, quand je parle de taille, je veux dire la taille en octet pris en memoire, pas le nombre d'elements du tableau

Bonjour,

Dans un exemple comme celui-ci:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <stdio.h> #include <stdlib.h> #include <iostream.h> #include <conio.h>     int main() {   unsigned char TableauFixe[24]; unsigned char *TableauVariable = NULL;   TableauVariable = (unsigned char*)malloc(15*sizeof(unsigned char));   cout << "Taille du tableau fixe" << sizeof(TableauFixe)/(sizeof(unsigned char)) << endl;   cout << "Taille du tableau variable" << sizeof(TableauVariable)/(sizeof(unsigned char)) << endl;   cin.ignore();   }

---

Il n'y a que la déclaration statique qui permet de calculer la taille.

C'est le problème des tableaux ouverts, il faut toujours conserver leur taille, sinon l'information est perdue.

Salut,

et une petite presicion sur sizeof, dans le cas d'un pointeur membre de ta classe (un buffer par exemple de 50000 valeurs)

si tu fais sizeof(MaClass) la taille du pointeur a l'interieur de ton objet sera juste 1 car c'est la taille d'un int (une adresse, celle de ton pointeur en l'occurence) donc sizeof ne tiens pas compte de la memoire alloué pour ton pointeur il te retourne juste la taille d'un int pour chaque pointeur.

XXiemeciel

xxiemeciel :

Citation:

---

...la taille du pointeur a l'interieur de ton objet sera juste 1 car c'est la taille d'un int....

---

Non , la taille d'un pointeur. En général, c'est supérieur à 1 (et pour un int aussi)

Citation:

---

... donc sizeof ne tiens pas compte de la memoire alloué pour ton pointeur il te retourne juste la taille d'un int pour chaque pointeur.

---

Si on demande la taille d'un pointeur, il renvoie ... la taille d'un pointeur , pas d'un int et pas de l'objet pointé

ahah oui c'est une faute de ma part effectivement le sizeof d'un int c'est plus que 1.

je pense c'est 4 pour les adresse car c'est de int 32 bits.

sorry j'avais la tete ailleurs quand j'ai ecrit ca... mais le principe est bon :lol:

XXiemeciel

Non, il n'y a aucune relation a priori entre taille d'un int et taille d'un pointeur.

On peut très bien imaginer parexemple des machines 64 bits, avec des adresses sur 64 bits mais des int qui restent sur 32 bits.

Bon decidement je m'exprime mal,

ce que je voulais dire c'est que sizeof va donner la taille de l'adresse et non de la memoire allouer pour le pointeur

XXiemeciel

Citation:

---

Envoyé par killerjeff

j'ai essayé de faire

Code:

---

sizeof(**tab)

---

mets ca me retourne une taille de 8 octets pour plus de 330 000 points.

---

Je crois qu'il y a une petite erreur, c'est que **tab renvoie la valeur du premier élément (tab[0][0]), et non celle du tableau tout entier. Dans l'idéal il faudrait boucler dans ton tableau mais la fin est indéterminée donc tu finiras par en sortir ce qui faussera le calcul.

Donc, en fait, pas de solution pour moi :?

Citation:

---

Envoyé par JolyLoic

Non, il n'y a aucune relation a priori entre taille d'un int et taille d'un pointeur.

On peut très bien imaginer parexemple des machines 64 bits, avec des adresses sur 64 bits mais des int qui restent sur 32 bits.

---

À priori, c'est justement le cas sous Win64...

Citation:

---

Envoyé par JolyLoic

Non, il n'y a aucune relation a priori entre taille d'un int et taille d'un pointeur.

On peut très bien imaginer parexemple des machines 64 bits, avec des adresses sur 64 bits mais des int qui restent sur 32 bits.

---

Pour résumer ce qui est imposé:

• 1 char fait au moins 8 bits
• sizeof(char) == 1
• sizeof(long) >= sizeof(int) >= sizeof(short) >= sizeof(char)

En pratique, tant qu'on ne travaille pas dans l'embarqué et ni avec des antiquités, on peut compter sur

• 1 char fait 8 bits
• sizeof(short) = 2
• sizeof(int) = 4

Avec des systèmes 32 bits, on a aussi

• sizeof(long) == 4
• sizof(type*) == 4

En 64 bits, on a

• sizeof(long) == 8 sauf, d'après ce que j'ai compris, sous Windows ou sizeof(long) == 4
• sizeof(type*) == 8

Je crois que peux rajouter:
sizeof(size_t) >= sizeof(type*)

Edit: Tu sais, de base, un pointeur était sur 16bits, sur 386. Un pointeur far était sur 32.

Citation:

---

Envoyé par Médinoc

Je crois que peux rajouter:
sizeof(size_t) >= sizeof(type*)

---

Non. (Exemple, les compilateurs C pour 8086 avaient un mode ou les pointeurs avaient une taille de 32 bits mais les objets avaient une taille maximale de 65535 et donc size_t etait sur 16 bits).

Merci a tous et en particulier a kwakanar pour vos reponses.

Je laisse le sujet ouvert au cas où quelqu'un aurai un coup de genie pour calculer la taille en memoire (vu que ca a l'air impossible il faut bien en coup de genie pour trouver :wink: )

Merci encore

Tu as compris mon exemple?

D'ailleurs, c'est pour cette raison que des fonctions C, comme srtcpy, memcpy et cie, demandent toujours la taille du destinataire ou le nombre d'octet à copier.

Il est impossible à ces fonctions de déduire la taille de la zone mémoire destination en se basant sur la taille du pointeur destination.

J'ai bien compris ce que tu as expliqué mais le probleme que j'ai, est de savoir quelle taille mon tableau occupe dans la RAM chose qui malheureusement a l'air impossible.

Salut,

A moins de conserver la taille quelquepart au moment de l'allocation de memoire.

XXiemeciel

tu pourrai developper un peu plus ton idée xxiemeciel ?
Car moi j'utilise une fonction

Code:

---

AllocTab(int nbPoint, int nbCoord)

---

qui me retourne le tableau. Le type du tableau et le code d'AllocTab sont intégré dans une DLL donc je ne peux pas le savoir

Ce n'est pas aussi simple.

Car ce n'est pas:

Citation:

---

Taille = sizeof(int)*nbPoint + sizeof(int)*nbCoord;

---

Mais

Citation:

---

sizeof(unsigned char)*nbPoint *sizeof(unsigned char)*nbCoord;

---

A cause de l'alignement mémoire, entre autre. Par contre, je ne suis pas sûr que ce soit fiable à 100%, il faut tester.

Que te retourne AllocTable un :

Code:

---

unsigned char*

---

ou un

Code:

---

unsigned char**

---

si c'est un unsigned char** que nbPoints et le nombre de ligne de ton tableau et nbCoord le nombre de coloones.

alors :

Code:

---

1 2	tailleMemoire = sizeof(unsigned char*)*sizeof(unsigned char)*nbPoints*nbCoord ;

---

XXiemeciel

ca retourne un tableau a 2 dimensions donc selon moi un

Code:

---

double **

---

je pense que c'est plus des doubles que des unsigned char mais le principe reste le meme. Par contre, je pensais plus que la taille serai le resultat d'un calcul du genre

Code:

---

sizeof(double)*dim*nbPts

---

car c'est bien un tableau 2 dimensions avec nbPts comme nombre de ligne et nbCoord en nombre de colonne.

Par contre en prenant ton exemple (avec des doubles a la place des unsigned char) je ne comprends pas a quoi correspond le sizeof(double*)

Citation:

---

tailleMemoire = sizeof(double*) * sizeof(double) * nbPoints * nbCoord ;

---

Citation:

---

Envoyé par killerjeff

ca retourne un tableau a 2 dimensions donc selon moi un

Code:

---

double **

---

---

Ce n'est pas une regle absolu, d'ailleur la plupart du temps les allocations memoire ce font dans un tableau a une dimension et on calcul l'offset a partir de x,y de la facon suivante :

offset = x + y*xsize

XXiemeciel

Citation:

---

Envoyé par killerjeff

ca retourne un tableau a 2 dimensions donc selon moi un

Code:

---

double **

---

---

Non. double** c'est un pointeur vers pointeur vers double, donc éventuellement un pointeur vers un tableau de pointeurs vers des tableaux
de doubles.

Un tableau à deux dimensions serait un double (*)[DIM] où la seconde dimension serait DIM. On ne peut pas avoir en C++ de tableaux à deux dimensions variables. (On peut facilement faire des classes qui se comportent comme tel, mais on a l'air ici de rester dans les fonctions de tellement bas niveau qu'on se demande si on n'est pas dans le groupe du C :-).

Il se peut que ta fonction d'allocation te retourne un tableau de taille dim*nPts et donc un double*, ou alors qu'elle te retourne bien un double** correctement initialisé.

Citation:

---

je pense que c'est plus des doubles que des unsigned char mais le principe reste le meme. Par contre, je pensais plus que la taille serai le resultat d'un calcul du genre

Code:

---

sizeof(double)*dim*nbPts

---

car c'est bien un tableau 2 dimensions avec nbPts comme nombre de ligne et nbCoord en nombre de colonne.

---

C'est la taille miminale que va allouer la fonction si elle retourne un double*. Si elle retourne un double**, elle doit allouer en plus

Code:

---

sizeof(double*)*dim

---

pour stocker les pointeurs. Donc on arrive à

Code:

---

sizeof(double)*dim*nbPts+sizeof(double*)*dim

---

.

Citation:

---

Par contre en prenant ton exemple (avec des doubles a la place des unsigned char) je ne comprends pas a quoi correspond le sizeof(double*)

Citation:

---

tailleMemoire = sizeof(double*) * sizeof(double) * nbPoints * nbCoord ;

---

---

Je ne comprends pas non plus ce calcul.

faute de frappe y'a une etoile en trop je pense

XXiemeciel

Pour information complementaire,

Code:

---

1 2 3 4 5

TabPoint = AllocTab(int nbPoint, int nbCoord); //acces au coordonnée du ième point (considerant dim = 3, le cas le plus courant) double x = TabPoint[i][0]; double y = TabPoint[i][1]; double z = TabPoint[i][2];

---

Voila l'utilisation que j'en fait en retour. Mais a l'interieur de la fonction et des classes, se serai codé en C dans la DLL, ca m'etonnerai qu'a moitié

je remonte ce post car on me demande de calculer la taille mémoire prise.
Hors pour moi la taille serai :

Code:

---

sizeof(double)*dim*nbPts

---

car il y a au total dim*nbPts double de stocké

Mais Jean-Marc.Bourguet indiqué comme taille :

Code:

---

sizeof(double)*dim*nbPts+sizeof(double*)*dim

---

ce qui fait une différence que j'aimerai comprendre.

Merci de vos explications, vous etes :ccool:

Edit : autre petite question, est ce qu'il existe une fonction en C++ ou avec visual, pour savoir la taille de toute le programme à un moment donné ? Je pense que la réponse est non mais ca coute rien de demander

desole de le upper mais personne n'aurai une petite reponse ? :oops:

Pour la taille en mémoire de tout le programme, ça déoend du système.

Si tu es sous Windows (je ne me souviens plus), va faire un tour sur msdn, tu seras surpris des fonctionnalitès du sujet :)

Code:

---

1 2 3 4 5

TabPoint = AllocTab(int nbPoint, int nbCoord); //acces au coordonnée du ième point (considerant dim = 3, le cas le plus courant) double x = TabPoint[i][0]; double y = TabPoint[i][1]; double z = TabPoint[i][2];

---

Si ce code est correct et qu'on peut écrire TabPoint[i][0]; alors, la valeur de retour est en double ** ( une déclaration en double (*)[n] impose la deuxième dimension qui a l'air d'être nbcoord donc variable) et il ya un tableau de pointeurs sur double de la taille de la première dimension (soit nbpoint, je suppose). Tu dois d'ailleurs savoir le type de la valeur retournée par AllocTab.
On a donc un tableau de nbpoint pointeurs sur double occupant

Citation:

---

nbpoint*sizeof(double*)

---

plus un ou plusieurs tableaux de double (pour l'instant, on ne peut pas savoir) dont la taille totale est

Citation:

---

nbpoint*nbCoord*sizeof(double)

---

Soit un total de

Citation:

---

nbpoint* (sizeof(double*)+nbCoord*sizeof(double))

---

merci Diogene de tes explications, je viens de comprendre comment calculer la taille grace a toi.

et merci a Caine aussi, car je ne savais pas qu'il y avait de telles fonctions sous visual et elles vont bien m'aider

pour vous tous : :lahola:

et encore :merci: