Discussion :

[Cbenlfun]

Bonjour

J'aimerais créer une fonction pour obtenir la taille d'un tableau dynamique.

Je sais que l'opérateur sizeof sur un pointeur renvoie la taille de celui-ci et non la taille total des éléments pointés.
J'ai lu qu'il existe des fonctions pour cette tâche (_msize sous windows par exemple).

Logiquement, la taille d'un tableau alloué avec new[] est gardée en mémoire quelque part puisque l'opérateur delete[] sait combien d'éléments libérer.

J'aimerais une explication ou un exemple de l'implémentation d'une tel fonction, car la majorité de mes classes n'utilisent aucune bibliothéque autre que celles que j'ai créés et j'aimerais continuer comme ça (c'est bon pour mon aprentissage).

Merci d'utiliser de votre temps pour me répondre.

[zais_ethael]

En dépis du fait que ça peut sembler complètement stupide, c'est impossible. Bon, en fait il y a une explication plausible: je crois que dans le cas des types primitifs, et avec certains systèmes de gestion du tas, stocker ce nombre n'est pas nécessaire et, en plus, une plus grande quantitié de mémoire sera réellement réservée. Au final, il n'y a aucun moyen prévu dans le standard pour retrouver cette taille.

En dehors de ça, je ne peux que m'outrer en lisant pareille bétise:

la majorité de mes classes n'utilisent aucune bibliothéque autre que celles que j'ai créés et j'aimerais continuer comme ça (c'est bon pour mon aprentissage).

Quel que soit le langage de programmation c'est une très mauvaise idée. Comprends bien que si, pour je ne sais quelle raison saugrenue, on se limitait tous à des +, -, *, / ça nous prendrait toujours trois semaines pour faire un démineur.
D'après mon expérience, ce qui distingue un programmeur experimenté d'un débutant, ce n'est pas de savoir programmer en C++ ou en Java, c'est d'avoir le réflexe de chercher des solutions existantes pour chaque besoin générique au lieu de réinventer la roue.
Alors fais les choses bien et va donc apprendre à te servir de la classe vector !

[Cbenlfun]

Merci pour ta réponse malgré qu'elle est un peu insultante...
Je vais tenter de mieux m'expliquer.

Tu as raison, les bibliothèques sont indispensables pour tout programmeurs et je n'ai pas peur de les utiliser dans mes programmes.
Ce que j'aurais du préciser c que depuis que j'ai commencé à apprendre le C++ je m'amuse à faire ma propre bibliothèque standard et autre (peut-être est-ce ridicule, peut-être est-ce inutile).
Même si elle est très loin d'égaler les "vrai" bibliothèques utilisées et améliorées par des milliers de programmeurs depuis des décénies, j'aime bien me dire "cette roue, c'est moi qui l'a inventée" même si les autres roues de mon chariot ont été inventées pas d'autres...

"N'a tu jamais démonté un appareil électronique par curiosité ou tenté de jouer l'oeuvre d'un grand compositeur pour le plaisir?"

J'ai fait ma propre classe string avec une variable membre pour contenir la taille de la chaine et je suis très satisfait du résultat.
La seule chose qui me dérange c'est que les chaine de caractères qu'ont lui affecte doivent se terminer par un '\0' car sinon son comportement est imprévisible.
Bien que je n'ai pas encore eu de problème à cause de ça, j'aimerais que la taille des chaines qui viennent de l'extérieur soit vérifiée pour plus de sécurité.

C'est sur que c'est possible mais peut-être faut-il connaitre en détails l'implémentation du système d'exploitation (si c'est le cas, j'abandonne, je vais accepter les fonction prévues à cet effet en étant très heureux qu'elles existes), mais si c'était possible de le faire avec des connaissances moyennes ma curiosité prendrait le dessus.

En bref...
Si je dois apprendre l'algèbre en hiéroglyphes pour implémenter de telles fonctions, je vais immédiatement marquer cette conversation comme résolue et utiliser _msize, mais sinon j'aimerais qu'on m'explique comment faire.

[JolyLoic]

je vais immédiatement marquer cette conversation comme résolue et utiliser _msize, mais sinon j'aimerais qu'on m'explique comment faire.

Sauf que _mzise ne marchera pas... Il y a plein de façons d'avoir un pointeur qui est passé à ta fonction. Essaie par exemple ce 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
 
#include <malloc.h>
#include <iostream>
 
using namespace std;
 
 
void f(char *titi)
{
	char *toto = new char[15];
	char *tutu = (char*)_alloca(42);
	char *tata = toto+1;
	cout << _msize(toto) << endl;
	cout << _msize(titi) << endl;
	cout << _msize(tutu) << endl;
	cout << _msize(tata) << endl;
}
 
int main()
{
	char titi[] = "Salut !";
	f(titi);
	return 0;
}

Et non, rien n'existe en standard pour connaître la taille d'un bloc mémoire.

[Cbenlfun]

Donc si je comprend bien, même les fonctions définies dans une quel conque bibliothèque ne peuvent régler mon problème et toute les classes string de tout le monde se fient sur le caractère '\0' pour repérer le dernier élément d'un tableau passé par un paramètre de type pointeur sur char?

[Obsidian]

Je ne peux que m'outrer en lisant une pareille bêtise :

En dehors de ça, je ne peux que m'outrer en lisant pareille bétise.

Quand on débute, on essaie surtout de comprendre comment ça marche, de la même manière que l'on apprend d'abord à écrire avant d'utiliser une machine à écrire. Nombreux sont les exercices où le recours aux bibliothèques extérieures toutes faites est interdit. Essayer de réinventer soi-même quelque chose, quand c'est pour l'exercice, est toujours bénéfique.

À côté, tu t'apercevras très vite toi-même que « réemployer l'existant » a un coût. Il faut chercher la bonne bibliothèque, se l'approprier, s'y investir complètement pour maîtriser son API, qui bien souvent est mal documentée, et tout cela pour utiliser un produit dont tu n'as même pas la certitude qu'il est mieux écrit que ce que tu aurais toi-même fait. Il faut composer avec les bugs cachés puis, bien souvent, mettre en place des adaptateurs pour composer avec le fait que telle ou telle fonction n'est pas implémentée comme ton programme l'attend, si ce n'est pas implémentée du tout. Et en plus, tu ne peux pas répondre à l'avance de la pérénité dans le temps de cette bibliothèque.

Après, impliquer une bibliothèque entière pour n'utiliser qu'un seul de ses modules ou de ses classes est aussi une hérésie. C'est une chose à laquelle on assiste de plus en plus souvent parce que les couches sont de plus en plus nombreuses, que l'utilisateur a de moins en moins le contrôle sur sa machine et parce que la course à la puissance (qui reste un bienfait par ailleurs) estompe les différences entre les implémentations à l'efficacité variable. Peu de gens savent encore si l'instance de leur objet dans la pile fait 256 octets ou 256 kilo-octets. Quand le projet gagne en importance, les dépendances s'accumulent et ça fait autant de ressources externes qu'il faut importer et installer avec ton projet. À l'inverse, une application d'importance moyenne capable de de n'utiliser que la bibliothèque standard et les appels systèmes facilitera énormément le travail des intégrateurs et des administrateurs systèmes, spécialement au niveau de la politique de sécurité.

En général, je me définis une masse critique, au delà de laquelle je décide de recourir à une bibliothèque particulière et à partir de ce stade, j'essaie de l'utiliser massivement.

[Arzar]

Donc si je comprend bien, même les fonctions définies dans une quel conque bibliothèque ne peuvent régler mon problème et toute les classes string de tout le monde se fient sur le caractère '\0' pour repérer le dernier élément d'un tableau passé par un paramètre de type pointeur sur char?

Ben oui.
C'est décevant, hein ? Aucune magie.

D'ailleurs, je viens de vérifier et la première chose que fait le constructeur de std::string(char* s) c'est un strlen sur s. (avec VS2008)

[droggo]

Feo,

Ben oui.
C'est décevant, hein ? Aucune magie.

D'ailleurs, je viens de vérifier et la première chose que fait le constructeur de std::string(char* s) c'est un strlen sur s. (avec VS2008)

Ben oui, avec un char *, c'est le seul moyen. Comment voudrais-tu donc faire autrement ?

Et tant que quelque part on utilise un char *, il faudra en passer par là.

[Cbenlfun]

Dans ce cas, je vais laisser ma classe string comme elle est et passer à autres choses, mais par pure curiosité, quelqu'un pourrait-il m'expliquer grossièrement (si cela est possible) comment les fonctions de désallocation dynamique (comme l'opérateur delete[] par exemple) font pour libéré la bonne quantité de mémoire.

[ram-0000]

Tout d'abord, les opérateur new() et delete() sous le capot font appel à malloc() et free().

A la différence de malloc() et free(), pour new() et delete(), le compilateur rajoute automatiquement un appel aux constructeur et destructeur.

Les blocs de mémoire alloués par malloc sont en général gérés dans une liste chainée gérée par le gestionnaire d'allocation (dans la librairie C ?).

Quand tu demandes 16 octets à malloc(), celui ci en alloue 32 (par exemple). Il se garde les 16 premiers octets du bloc pour lui sa gestion interne et te donne un pointeur sur le 17eme octet (que tu crois être le 1er de la zone allouée). Parmi c'est 16 octets réservés au système (j'ai dit 16 pour fixer les idées mais cela peut être une autre valeur), on peut trouver la taille demandée, la taille allouée, le prochain bloc alloué, le précédent, un nombre magique permettant d'identifier le bloc, etc.

Quand tu libères un bloc, tu donnes le pointeur à libérer, le système retranche les 16 octets pour retrouver le vrai bloc et retrouve les informations de gestion de la liste chainée.

C'est pour cela qu'il ne faut jamais libèrer un pointeur non alloué par malloc ou alors modifier la valeur du pointeur à libérer (incrémenter le pointeur de 1 ou 2 par exemple). Dans ce cas, le système ne peut plus retrouver sa structure et dans le meilleur des cas, annonce une erreur ou alors se plante.

Connaitre la taille du bnloc alloué est alors possible, il suffit de connaitre comment le système ajoute les informations de gestion qui sont avant le bloc de mémoire "utilisateur". Bien sûr cette méthode n'est pas portable d'un OS à l'autre et peut même évoluer entre les différentes versions d'un même OS.

Donc c'est intéressant à regarder pour information personnelle mais il ne faut pas l'utiliser dans un vrai programme.

[Médinoc]

Par exemple, voici une explication de comment ça se passe dans la bibliothèque C++ de Microsoft:
http://blogs.msdn.com/oldnewthing/ar.../03/66660.aspx

Mais je reconnais que cette absence de méthode standard pour connaître la taille allouée est vraiment rageante, car ça t'oblige à rajouter ta propre gestion de la taille alors que la taille est déjà gérée au niveau inférieur. Résultat, ça fait une gestion redondante et tu te retrouves avec deux (ou plus)zones mémoire contenant la taille...

[loufoque]

Tout d'abord, les opérateur new() et delete() sous le capot font appel à malloc() et free().

C'est faux.
Ils font appels à operator new et operator delete, respectivement.

[Goten]

Qui font eux même appels à malloc() et free() (selon les implémentations, sous gcc c'est le cas).

[Alp]

Qui font eux même appels à malloc() et free() selon les implémentations, sous gcc c'est le cas).

Oui, selon les implémentations, justement.

Sinon, la technique utilisée si tu fais une classe String, c'est de maintenir à jour la taille toi-même, à grands coups de strlen, d'addition, de soustraction...

[ram-0000]

Qui font eux même appels à malloc() et free() (selon les implémentations, sous gcc c'est le cas).

Le code de l'opérateur ::new () dans la librarie C de Visual Studio 2005 fait lui aussi appel à malloc().

Code Operateur global ::new() :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
        {       // try to allocate size bytes
        void *p;
        while ((p = malloc(size)) == 0)
                if (_callnewh(size) == 0)
                {       // report no memory
                static const std::bad_alloc nomem;
                _RAISE(nomem);
                }
 
        return (p);
        }

Oui, selon les implémentations, justement.

Par contre, je suis bien d'accord c'est lié à l'implémentation.

[Alp]

Souvent il est fait appel à malloc() et free() respectivement, mais vous pouvez lire la norme vous ne trouverez rien sur le fait qu'il faut faire appel à malloc() et free()

[Goten]

Il n'a jamais été question du contraire d'ailleurs... j'ai bien précisé (et tu l'as souligné en rouge SELON les implémentations).

[zais_ethael]

Mais je reconnais que cette absence de méthode standard pour connaître la taille allouée est vraiment rageante, car ça t'oblige à rajouter ta propre gestion de la taille alors que la taille est déjà gérée au niveau inférieur. Résultat, ça fait une gestion redondante et tu te retrouves avec deux (ou plus)zones mémoire contenant la taille...

Pas forcément dans le cas des types primitifs (voir peut-être dans le cas de certaines structures), ils n'ont pas de destructeur. Dans le cas où une plus grande quantité de mémoire que demandé est réservée le gestionnaire de mémoire n'a pas besoin de mémoriser le nombre initial.

[loufoque]

operator new, ça se surcharge hein...

[3DArchi]

Souvent il est fait appel à malloc() et free() respectivement, mais vous pouvez lire la norme vous ne trouverez rien sur le fait qu'il faut faire appel à malloc() et free()

D'autant que tu peux avoir une gestion mémoire complètement différente : sur des systèmes embarqués, il y a souvent plusieurs pool mémoires, chacun gérant des blocs de taille fixe. L'allocation consiste alors à 'marquer' (derrière ce terme, tout ce que vous voulez) un bloc comme 'occupé' et la libération à le marquer comme disponible. Là, il n'y a plus d'intérêt à connaitre la taille de l'allocation demandée au moment de la libération.

Tout ça pour dire que ca reste de la cuisine interne de l'implémentation de la gestion de la mémoire.