C++ Supprimer l'initialisation automatique et la destruction

Question

Comment supprimer l'initialisation automatique et la destruction d'un type? Alors qu'il est merveilleux que T buffer[100] initialise automatiquement tous les éléments de buffer, et les détruit quand ils tombent hors de portée, ce n'est pas le comportement que je veux.

#include <iostream> 

static int created = 0, 
      destroyed = 0; 

struct S 
{ 
    S() 
    { 
     ++created; 
    } 
    ~S() 
    { 
     ++destroyed; 
    } 
}; 

template <typename T, size_t KCount> 
class fixed_vector 
{ 
private: 
    T m_buffer[KCount]; 
public: 
    fixed_vector() 
    { 
     // some way to suppress the automatic initialization of m_buffer 
    } 

    ~fixed_vector() 
    { 
     // some way to suppress the automatic destruction of m_buffer 
    } 
}; 

int main() 
{ 
    { 
     fixed_vector<S, 100> arr; 
    } 

    std::cout << "Created:\t" << created << std::endl; 
    std::cout << "Destroyed:\t" << destroyed << std::endl; 
    return 0; 
} 

La sortie de ce programme est:

Created: 100 
Destroyed: 100 

Je voudrais que ce soit:

Created: 0 
Destroyed: 0 

Ma seule idée est de faire m_buffer un certain type trivialement construit et destructed comme char et puis compter sur operator[] pour envelopper le calculateur de pointeur pour moi, bien que cela ressemble à une solution horriblement piraté. Une autre solution serait d'utiliser malloc et free, mais cela donne un niveau d'indirection que je ne veux pas.

---

La raison pour laquelle je veux que c'est parce que je fais un récipient et je ne veux pas payer pour les frais généraux d'initialisation des choses que je ne vais pas utiliser. Par exemple, si ma fonction main était:

int main() 
{ 
    { 
     std::vector<S> vec; 
     vec.reserve(50); 
    } 

    std::cout << "Created:\t" << created << std::endl; 
    std::cout << "Destroyed:\t" << destroyed << std::endl; 
    return 0; 
} 

La sortie serait correct:

Created: 0 
Destroyed: 0 

Answer 1

Vous pouvez créer la matrice sous la forme char s, puis utiliser placement new pour créer les éléments en cas de besoin.

template <typename T, size_t KCount> 
class Array 
{ 
private: 
    char m_buffer[KCount*sizeof(T)]; // TODO make sure it's aligned correctly 

    T operator[](int i) { 
     return reinterpret_cast<T&>(m_buffer[i*sizeof(T)]); 
    } 

---

Après re-lecture de votre question, il semble que vous voulez un tableau clairsemé, cela va parfois sous le nom de carte; o) (bien sûr les caractéristiques de performance sont différentes ...)

template <typename T, size_t KCount> 
class SparseArray { 
    std::map<size_t, T> m_map; 
public: 
    T& operator[](size_t i) { 
     if (i > KCount) 
      throw "out of bounds"; 
     return m_map[i]; 
    } 

Answer 2

Vous pouvez jeter un oeil à la façon dont il est fait avec les conteneurs STL, mais je doute que vous pouvez épargner vous malloc s et free de

Answer 3

Ce code:

#include <iostream> 
#include <vector> 
using namespace std; 

int created = 0, destroyed = 0; 

struct S 
{ 
    S() 
    { 
     ++created; 
    } 
    S(const S & s) { 
     ++created; 
    } 
    ~S() 
    { 
     ++destroyed; 
    } 
}; 

int main() 
{ 
    { 
     std::vector<S> vec; 
     vec.reserve(50); 
    } 

    std::cout << "Created:\t" << created << std::endl; 
    std::cout << "Destroyed:\t" << destroyed << std::endl; 
    return 0; 
} 

a exactement la sortie que vous voulez - je ne suis pas sûr de savoir quelle est votre question.

Answer 4

Vous pouvez regarder dans boost::optional

template <typename> struct tovoid { typedef void type; }; 

template <typename T, size_t KCount, typename = void> 
struct ArrayStorage { 
    typedef T type; 
    static T &get(T &t) { return t; } 
}; 

template <typename T, size_t KCount> 
struct ArrayStorage<T, KCount, typename tovoid<int T::*>::type> { 
    typedef boost::optional<T> type; 
    static T &get(boost::optional<T> &t) { 
    if(!t) t = boost::in_place(); 
    return *t; 
    } 
}; 

template <typename T, size_t KCount> 
class Array 
{ 
public: 
    T &operator[](std::ptrdiff_t i) { 
     return ArrayStorage<T, KCount>::get(m_buffer_[i]); 
    } 

    T const &operator[](std::ptrdiff_t i) const { 
     return ArrayStorage<T, KCount>::get(m_buffer_[i]); 
    } 

    mutable typename ArrayStorage<T, KCount>::type m_buffer_[KCount]; 
}; 

Une spécialisation est effectuée pour le type de classe qui les enveloppe dans un optional, appelant ainsi le constructeur/destructeur paresseusement. Pour les types hors classe, nous n'avons pas besoin de ce wrapping. Ne pas les encapsuler signifie que nous pouvons traiter &a[0] comme une zone mémoire contiguë et transmettre cette adresse aux fonctions C qui veulent un tableau. boost::in_place créera les types de classe sur place, sans utiliser un T temporaire ou son constructeur de copie.

Ne pas utiliser l'héritage ou les membres privés permettent la classe de rester un agrégat, ce qui permet une forme pratique d'initialisation

// only two strings are constructed 
Array<std::string, 10> array = { a, b }; 

Answer 5

Si vous voulez être comme vecteur, vous devez faire quelque chose comme ceci:

template <typename T> 
class my_vector 
{ 
    T* ptr; // this is your "array" 
    // ... 
    public: 

    void reserve(size_t n) 
    { 
     // allocate memory without initializing, you could as well use malloc() here 
     ptr = ::operator new (n*sizeof(T)); 
    } 

    ~my_vector() 
    { 
     ::operator delete(ptr); // and this is how you free your memory 
    } 

    void set_element(size_t at, const T& element = T()) 
    { 
     // initializes single element 
     new (&ptr[at]) T(element); // placement new, copies the passed element at the specified position in the array 
    } 

    void destroy_element(size_t at) 
    { 
     ptr[at].~T(); // explicitly call destructor 
    } 
}; 

Ce code est évidemment uniquement pour la démonstration, j'ai omis le constructeur de copie de my_vector et tout suivi sur ce qui est créé et non (appeler un destructeur sur un emplacement que vous n'avez pas appelé constructeur est probablement un comportement indéfini). De plus, les allocations et désallocations vector de STL sont supprimées par l'utilisation d'allocateurs (le deuxième argument de modèle vector).

Espérons que ça aide