Discussion :

[genetin]

Bonjour,

J'utilise Visual C++.
Je voudrais savoir s'il est possible de connaitre la taille restante (ou la taille occupée) de la pile des variables locales ?

Merci de votre aide

[Bktero]

Bonjour,

https://stackoverflow.com/questions/...747499#1747499 pourrait répondre à ta question

[bacelar]

https://stackoverflow.com/questions/...-visual-studio

[Bousk]

Pour quoi ?

[genetin]

Merci beaucoup.
La granularité du résultat n'est pas très fin ... mais ça me suffit pour ce dont j'ai besoin.

J'ai besoin de cette info pour du débug. Je suis en train d'essayer de faire une classe de chaine de caractères, avec surcharge de l'opérateur "new", et je veux m'assurer que la mémoire est bien prise dans la pile et non dans le tas.
(... mais j'ai un peu de mal à faire ce que je veux !!! Je viendrai peut-être poster une autre question dans ce forum si je n'y arrive pas ...)

[Christophe]

JE fais pas de C++, mais comme new fait des allocations mémoires, ça doit plutôt aller dans le tas non ?

[koala01]

Salut,

JE fais pas de C++, mais comme new fait des allocations mémoires, ça doit plutôt aller dans le tas non ?

En fait, new (new[])est un opérateur (une fonction) que l'on peut surcharger pour faire ce que l'on appelle du placement new.

L"idée de la technique est que l'on peut prévoir -- par exemple au début du programme -- une "certaine quantité" de mémoire dans laquelle nous irons "piocher" en cas de besoin et dans laquelle nous placerons toutes les données que nous voudrions créer (y compris des données de taille dynamique).

Cela permet -- entre autres -- d'éviter les appels systèmes induits par new, car les appels systèmes font partie des instructions les plus lentes que l'on trouve (et des instructions qui ont le plus de chances d'échouer )

Si bien que, ne théorie, tu as raison (new alloue de la mémoire sur le tas, en théorie), mais, en pratique, tu as tort: new peut prendre la mémoire exactement là où tu le souhaites

D'ailleurs, c'est bien simple : le dernier paramètre template de la plupart des collections de la STL (ainsi que de std::basic_string) représente l'allocateur: le système qui permet d'obtenir de la mémoire supplémentaire au besoin.

Par défaut, cet allocateur utilise le new classique, mais il est tout à fait possible de fournir un "pool de mémoire" dans lequel aller piocher ce dont on a besoin

Cependant, je serais surpris de savoir pourquoi @genetin souhaite que son implémentation d'une chaine de caractères prenne sa mémoire sur la pile, car il faut dire ce qui est : cet espace est particulièrement limité, et que leur mise sur la pile pose de sérieux problème, entre autres, lorsqu'il est question de renvoyer une chaine de caractères à la fin de la fonction

[genetin]

Merci koala pour toutes ces explications.

Voici ce qui me pousse à vouloir créer une classe de chaîne de caractères dans la pile :

Je construis des chaînes de caractères par concaténation de diverses informations. Ces chaines ont une taille maximale bornée (par exemple 50, 100, voire quelques centaines de caractères max) et elles sont temporaires car, une fois construites, je les recopie dans des structures de données plus complexes.
Comme je construis beaucoup de ces chaines, je voudrais créer une classe qui optimise la construction de texte par concaténation. Cette classe aurait deux attributs : int longueur; char texte[];
Ainsi, pour concaténer un bout de texte, je l'ajoute directement à (texte+longueur) et j'augmente longueur. C'est plus efficace qu'un strcat qui repart du début du texte à chaque fois. Et c'est moins lourd qu'un String.
Et comme les chaines sont de taille limitée, je pourrais les mettre dans la pile, ce qui évite de faire un appel système d'allocation dynamique de mémoire (qui prend du temps).

... mais j'ai un peu de mal à le faire !... et je ne sais même pas si c'est réellement possible.

[jo_link_noir]

Le compilateur fait beaucoup d'optimisation sur les fonctions C de chaîne de caractère, je ne serais pas étonné s'il garde la longueur entre 2 strcat.

Mais cette histoire de new sur pile me turlupine. Je comprends l'idée, mais pourquoi ne pas simplement utiliser un tableau sur la pile comme buffer ?

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
#include <iterator>
#include <string>
#include <string_view>
 
#include <cassert>
#include <cstring>
 
struct local_string
{
  local_string& operator+=(std::string_view s)
  {
     assert(std::size(buf) - len >= s.size());
     memcpy(buf + len, s.data(), s.size());
     len += s.size();
     return *this;
  }
 
  char* c_str()
  {
    assert(len < std::size(buf));
    buf[len] = '\0';
    return buf;
  }
 
  std::string str() const
  {
    return {buf, len};
  }
 
private:
  char buf[500];
  unsigned len = 0;
};
 
#include <iostream>
 
int main()
{
  local_string s;
  s += "abc";
  s += "def";
  std::cout << s.str() << std::endl;
}

[genetin]

Merci Jo_link_noir pour ta réponse.

Ton exemple est exactement ce que j'ai commencé à faire.
Mais, en plus, j'aurais voulu donner la taille max de la chaîne au moment de la définition de la variable locale (pour que ce ne soit pas toujours 500).
Et j'ai pensé qu'il fallait pour cela redéfinir l'opérateur new.

[jo_link_noir]

Tu peux mettre en template la taille du buffer.

Code :

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

1
2
3
4
5
6
template<std::size_t MaxSize>
struct local_sting
{
  ...
  char buf[MaxSize];
};

[genetin]

Bien sûr ! C'est ce qu'il faut faire !
Merci beaucoup Jo_link_noir.

Je n'avais jamais, jusqu'à présent, défini des templates. Du coup je ne savais pas exactement comment ça marchait, et je n'y avais pas pensé pour mes chaines de caractères.

Mais j'imagine que le compilateur va dupliquer le code de chaque méthode de la classe à chaque fois que je l'instancie avec un "MaxSize" différent. Est-ce bien ça ?
(Dans mon cas particulier des chaines de caractères ce ne serait pas gênant, car les méthodes étant très simples, leur code sera "inliné".)

[jo_link_noir]

j'imagine que le compilateur va dupliquer le code de chaque méthode de la classe à chaque fois que je l'instancie avec un "MaxSize" différent. Est-ce bien ça ?

Oui. C'est le principe d'un template: un type différent à chaque fois qu'un paramètre diffère.

[genetin]

Merci à vous tous pour vos réponses. C'est très sympa d'avoir passé du temps pour m'expliquer tout ça !