Início / coding / Perguntas / 77706486
Accepted
TwistedBlizzard
Asked: 2023-12-23 10:50:10 +0800 CST

Você pode ter um contêiner de objetos abstratos alocados sem heap em C++?

  • 772

Eu tenho um contêiner de objetos abstratos que desejo renderizar. Normalmente, eu estaria armazenando std::unique_ptr<T>ou std::shared_ptr<T>dentro do meu contêiner, mas não quero alocar todos os elementos, já que essas classes newformam um objeto.

Por exemplo, o polimorfismo é possível sem alocação de heap se todos os elementos não forem proprietários:

plf::hive<Base*> objects;
Derived t;
objects.insert(&t);

Gostaria que meu contêiner possuísse alguns de seus objetos. Minha solução atual é apenas armazenar std::variant<T*, std::unique_ptr<T>>, portanto, todos os objetos proprietários são destruídos adequadamente e a vida útil dos objetos não proprietários não é gerenciada. Mas ainda estou alocando objetos cujo tempo de vida precisa ser gerenciado. O polimorfismo puramente baseado em pilha é possível?

EDIT: Estou bem em alocar espaço de heap para meus objetos serem armazenados. Só não quero que os próprios objetos sejam criados na pilha.

c++

1 respostas

  1. Best Answer

    Sua pergunta gira em torno de alcançar o polimorfismo sem alocar os próprios objetos no heap, e você está explorando alternativas que permitem que alguns objetos sejam propriedade do contêiner, enquanto outros não. Parece que você está procurando uma maneira de ter comportamento polimórfico com objetos que residem na pilha ou em um pool de memória pré-alocado.

    Uma abordagem para esse problema é usar uma técnica chamada "apagamento de tipo", que permite comportamento polimórfico sem necessariamente usar alocação de heap para cada objeto. No entanto, isso muitas vezes ainda envolve alguma alocação de heap para o próprio mecanismo de eliminação de tipo.

    Uma alternativa é usar um buffer contíguo (como um std::array ou um array bruto) como um pool de memória onde você pode colocar seus objetos usando o posicionamento novo. Essa abordagem requer um gerenciamento cuidadoso da vida útil e do alinhamento dos objetos, mas pode evitar a alocação de heap por objeto.

    Aqui está um exemplo conceitual -

    #include <iostream>
#include <array>
#include <new> // for placement new

class Base {
public:
    virtual void doSomething() = 0;
    virtual ~Base() = default;
};

class Derived1 : public Base {
public:
    void doSomething() override {
        std::cout << "Derived1 doing something\n";
    }
};

class Derived2 : public Base {
public:
    void doSomething() override {
        std::cout << "Derived2 doing something\n";
    }
};

template <size_t N>
class ObjectPool {
    std::array<std::byte, N> buffer;
    size_t currentIndex = 0;

public:
    template <typename T, typename... Args>
    T* createObject(Args&&... args) {
        if (currentIndex + sizeof(T) <= N) {
            T* object = new (&buffer[currentIndex]) T(std::forward<Args>(args)...);
            currentIndex += sizeof(T);
            return object;
        } else {
            throw std::bad_alloc();
        }
    }
};

int main() {
    ObjectPool<1024> pool;

    Base* obj1 = pool.createObject<Derived1>();
    Base* obj2 = pool.createObject<Derived2>();

    obj1->doSomething();
    obj2->doSomething();

    // Manually call destructors since we used placement new
    obj1->~Base();
    obj2->~Base();

    return 0;
}
    • 0

relate perguntas