Comment « réallouer » en C++ ?

Question

Comment puis-je realloc en C++ ? Il semble manquer dans la langue - il y a new et delete mais pas resize !

J'en ai besoin parce que comme mon programme lit plus de données, je dois réallouer le tampon pour le maintenir. Je ne pense pas que deleteing l'ancien pointeur et newing un nouveau, plus grand, soit la bonne option.

Answer 1

Use : :std : :vector !

Type* t = (Type*)malloc(sizeof(Type)*n) 
memset(t, 0, sizeof(Type)*m)

devient

::std::vector<Type> t(n, 0);

Puis

t = (Type*)realloc(t, sizeof(Type) * n2);

devient

t.resize(n2);

Si vous voulez passer le pointeur dans la fonction, au lieu de

Foo(t)

utilisation

Foo(&t[0])

C'est un code C++ absolument correct, parce que vector est un C-array intelligent.

Answer 2

Voici un exemple std : :move implémentant un vecteur simple avec une réallocation (*2 à chaque fois que nous atteignons la limite). S'il y a un moyen de faire mieux que la copie que j'ai ci-dessous, faites-le moi savoir.

Compiler en tant que :

  g++ -std=c++2a -O2 -Wall -pedantic foo.cpp

Code :

#include <iostream>
#include <algorithm>

template<class T> class MyVector {
private:
    T *data;
    size_t maxlen;
    size_t currlen;
public:
    MyVector<T> () : data (nullptr), maxlen(0), currlen(0) { }
    MyVector<T> (int maxlen) : data (new T [maxlen]), maxlen(maxlen), currlen(0) { }

    MyVector<T> (const MyVector& o) {
        std::cout << "copy ctor called" << std::endl;
        data = new T [o.maxlen];
        maxlen = o.maxlen;
        currlen = o.currlen;
        std::copy(o.data, o.data + o.maxlen, data);
    }

    MyVector<T> (const MyVector<T>&& o) {
        std::cout << "move ctor called" << std::endl;
        data = o.data;
        maxlen = o.maxlen;
        currlen = o.currlen;
    }

    void push_back (const T& i) {
        if (currlen >= maxlen) {
            maxlen *= 2;
            auto newdata = new T [maxlen];
            std::copy(data, data + currlen, newdata);
            if (data) {
                delete[] data;
            }
            data = newdata;
        }
        data[currlen++] = i;
    }

    friend std::ostream& operator<<(std::ostream &os, const MyVector<T>& o) {
        auto s = o.data;
        auto e = o.data + o.currlen;;
        while (s < e) {
            os << "[" << *s << "]";
            s++;
        }
        return os;
    }
};

int main() {
    auto c = new MyVector<int>(1);
    c->push_back(10);
    c->push_back(11);
}