Como ter um vetor de byvalue e usar um vetor de ponteiros em conjunto?

Question

Eu tenho alguns vetores de objetos classe A:

 std::vector<A> *V1;
 std::vector<A> *V2;

etc

existe uma função com um vetor de ponteiros de A:

 std::vector<A *> *arranged;

o que eu preciso fazer é colocar os vetores de V1, V2 etc dentro arranjado sem destruí-los no final, então eu pensei que um vetor de ponteiros para os objetos ... isso é possível? Se sim, você pode me dar um exemplo de uma iteração com V1 variável e adicionar ponteiros desses objetos em arranjado?

imagine que você, temporariamente, necessidade de classificar 3 vetores de objetos em um vetor, mas você não quer estragar a memória dos 3 vetores.

ty,

Joe

Answer 1

Você pode escrever seu próprio comparador. Neste caso, o comparador iria trabalhar em A*. Um exemplo simples usando o tipo int:

void fun(vector<int*>* vec)
{
  /////////
}

bool comp(int* lhs, int* rhs)
{
    return *lhs < *rhs;
}

int main()
{
    vector<int> first, second;
    vector<int*> vec;

    for(vector<int>::size_type i = 0; i < first.size(); ++i)
        vec.push_back(&first[i]);
    for(vector<int>::size_type i = 0; i < second.size(); ++i)
        vec.push_back(&second[i]);

    // write your own comparator! provided above: comp
    sort(vec.begin(), vec.end(), comp);

    fun(&vec);

    return 0;
}

Answer 2

Se eu entendi corretamente - você tem vários vetores que contêm algum tipo de objeto (A), e você deseja criar um novo vetor que contém a composição de todos os membros dos outros vetores w / o realmente copiar os objetos ao redor, ou de outra forma perturbar seus PROPRIEDADE-vetores de alguma forma?

Primeiro: faz a vida do novo vector composta definitivamente existe tal que nenhum de seus source-vetores vai mudar? Ou seja:. Você não pode apenas ter ponteiros crus na fonte-vetores de seu vetor composto se os ponteiros serão invalidadas dentro do tempo de vida de sua composição

Se a resposta para isso é outra coisa senão "definitivamente, ponteiros permanecerá válido", então você precisa considerar o uso de ponteiros compartilhados, ou algo semelhante, de modo que alterando a fonte-vetores não vai deixar seu vetor composto em um estado inválido (ou seja, não deixá-lo apontando para random memory).

Assumindo que a fonte-vetores permanecerá inalterada em termos de seus próprios conteúdos para a vida útil do seu composto, então a resposta é simples "Sim"

vector<A> source1;
vector<A> source2;
vector<A> source3;

vector<const A*> composite; // this is a sorted vector of the above vectors' contents (by pointer)

Para o vetor composto, você precisa colocar o conteúdo (por cópia) do source1-3 para ele, e, em seguida, classificá-lo (ou você poderia usar um recipiente ordenada, e classificar como você inserir os elementos). Você precisa definir o seu próprio operador de triagem, que dereferences os ponteiros e aplica qualquer outro tipo algoritmo no alvo próprios objetos.

Isso ajuda você?