Bonjour, afin de gagner en rapidité pour la création de petit objets, j'ai créé une petite classe (elle n'est que très très basique pour l'instant). Il me semble que boost propose une classe similaire. Cependant, ici le but est didactique.

La voici :

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 <iostream>
#include <cstdlib>
 
 
class Reservoir
{
    private :
        void*pt;
        unsigned int size_pt;
        void* pt_pos;
    public :
        Reservoir()
        {
            pt=malloc(1*1000*1000);//1 MégaOctet par défaut. Valeur purement arbitraire
            size_pt=1*1000*1000;
            pt_pos=pt;
            if(pt==NULL)
                std::cout<<"malloc_error";
        }
        Reservoir(unsigned int reserve)
        {
            pt=malloc(reserve);
            size_pt=reserve;
            pt_pos=pt;
            if(pt==NULL)
                std::cout<<"malloc_error";
        }
        template<typename T, typename ...Args>
        T*make_new(Args...arg)
        {
            //Que mettre ?
            T*pt_tmp=(T*)pt_pos;
            (*pt_tmp)=T(arg...);//Très moche : on créé un objet temporaire pour rien.
            pt_pos+=sizeof(T);
            return pt_tmp;
        }
        ~Reservoir()
        {
            free(pt);
        }
 
};
 
using namespace std;
 
int main()
{
    Reservoir r;
    int*pt=r.make_new<int>(1);
    std::cout<<*pt;
    *pt=3;
    std::cout<<*pt;
    return 0;
}
Ce code utilise c++0x pour les constructeurs (template variadiques).
Ce code ne gère pas (encore) le dépassement de la classe réservoir.
Ce code est très imparfait.
Mes questions :

Y a t-il un moyen de faire quelque chose de plus propre ici :

(*pt_tmp)=T(arg...);//Très moche : on créé un objet temporaire pour rien.

?

Le compilateur saura-t-il optimiser la ligne de code ci-dessus ?

Comment lors de la création de conteneurs (de la STL par exemple), dire au conteneur d'allouer les nouveaux éléments dans le réservoir ? Est-ce possible ?

Le gain est-il important pour un vector de taille modifiable contenant env 10 000 000 int ?