Allocation fixe std::vector

Question

Je suis un développeur de logiciels embarqués et, en tant que tel, je ne peux pas toujours utiliser toutes les belles fonctionnalités du C++. L'une des choses les plus difficiles est d'éviter l'allocation dynamique de mémoire, car elle est en quelque sorte universelle avec tous les conteneurs STL.

En std::vector est cependant très utile lorsqu'on travaille avec des ensembles de données variables. Le problème, cependant, est que l'allocation (par ex. std::reserve ) n'est pas fait à l'initialisation ou fixé. Cela signifie qu'une fragmentation de la mémoire peut se produire lors d'une copie.

Ce serait bien que chaque vecteur ait un espace mémoire alloué qui soit la taille maximale à laquelle le vecteur peut croître. Cela créerait un comportement déterministe et permettrait de cartographier l'utilisation de la mémoire du microcontrôleur au moment de la compilation. Un appel à push_back lorsque le vecteur est à sa taille maximale créerait une std::bad_alloc .

J'ai lu qu'une version alternative de std::allocator peuvent être écrits pour créer un nouveau comportement d'allocation. Serait-il possible de créer ce type de comportement avec std::allocator ou une autre solution serait-elle plus appropriée ?

J'aimerais vraiment continuer à utiliser les bibliothèques STL et à les modifier au lieu de recréer mon propre vecteur, car je risque davantage de faire des erreurs que leur mise en œuvre.

sidenote #1 :

Je ne peux pas utiliser std::array car 1 : elle n'est pas fournie par mon compilateur et 2 : elle dispose d'une allocation statique mais je dois encore gérer la frontière entre mes données et le tampon à l'intérieur de l'espace de travail de l'utilisateur. std::array . Cela signifie qu'il faut réécrire une std::vector avec mes propriétés d'attribution, ce que j'essaie d'éviter.

Answer 1

Vous pouvez mettre en œuvre ou réutiliser la méthode de boost vecteur statique ; Un conteneur de taille variable avec une capacité fixe.

Answer 2

Vous pouvez toujours utiliser un tableau de style C (le même que celui sous-jacent en std::array ) car les vecteurs ne sont pas censés être statiques.

int arr[5]; // static array of 5 integers

Pour le rendre plus utile, vous pouvez l'envelopper dans un modèle de classe pour masquer le style C. Exemple :

template<class type, std::size_t capacaty>
class StaticVector {
    private:
        type arr[capacaty];
        std::size_t m_size;
    public:
        StaticVector() : m_size(0) {}

        type at(std::size_t index) {
            if (index >=0 && index < m_size) {
                return arr[index];
            }

            return type();
        }

        void remove(std::size_t index) {
            if (index >=0 && index < m_size) {
                for (std::size_t i=index; i < m_size-1; i++) {
                    arr[i] = arr[i+1];
                }
                m_size--;
            }
        }

        void push_back(type val) {
            if (m_size < capacaty) {
                arr[m_size] = val;
                m_size++;
            }
        }

        std::size_t size() {
            return m_size;
        }
};

Exemple avec l'utilisation : https://onlinegdb.com/BkBgSTlZH