HOWTO · C++

Acesso às Funções de Membro Desde o Apontador a um Vector em C++

Aprenda a chamar os membros de std::vector através de um ponteiro em C++, a passar o ponteiro do vetor para uma função e a iterar sobre os seus elementos.

Nesta página

Para chamar um membro de um vetor C++ por meio de um ponteiro, use ptr->member; a forma equivalente é (*ptr).member. O ponteiro deve apontar para o próprio objeto vetor. Obtenha o endereço desse objeto com & e use uma das duas expressões para acessar membros como size() e at(). O exemplo abaixo também passa o ponteiro para uma função e lê cada valor por meio dele.

Usar -> para acessar um vetor por meio de um ponteiro

Declare um ponteiro colocando * após o tipo do vetor. Para um vetor de inteiros, esse tipo é std::vector<int>*. Se values for um vetor existente, &values será o endereço dele; atribuí-lo ao ponteiro faz com que o ponteiro passe a se referir ao vetor. Isso não copia o vetor nem cria uma coleção separada.

O operador de seta combina a desreferenciação do ponteiro com a seleção de um membro. Assim, ptr->size() chama size() no vetor apontado por ptr. Você também pode passar esse ponteiro para uma função cujo parâmetro tenha um tipo de ponteiro compatível. No exemplo completo, report_size recebe um ponteiro para um vetor constante, pois apenas lê o vetor. A qualificação const impede que a função modifique o vetor por meio desse parâmetro; ela não altera a maneira como o ponteiro é passado.

Execute este exemplo:

#include <cstddef>
#include <iostream>
#include <vector>

void report_size(const std::vector<int>* ptr) {
    std::cout << "Count: " << ptr->size() << '\n';
}

int main() {
    std::vector<int> values{10, 20, 30};
    const std::vector<int>* ptr = &values;

    report_size(ptr);
    for (std::size_t i = 0; i < ptr->size(); ++i) {
        std::cout << (*ptr).at(i) << '\n';
    }
}
Count: 3
10
20
30

A execução mostra o tamanho do vetor, seguido de cada valor em uma linha separada. O vetor é uma variável local automática, e o ponteiro só é usado enquanto esse vetor permanece no escopo. No seu programa, garanta que o ponteiro não continue sendo usado depois que o objeto cujo endereço ele armazena deixar de existir.

Usar (*ptr).member para acessar um vetor por meio de um ponteiro

A expressão (*ptr).member primeiro desreferencia ptr, obtendo o objeto vetor, e depois seleciona um dos membros desse objeto com .. Os parênteses são importantes: sem eles, o operador ponto seria aplicado a ptr antes da desreferenciação, o que não é a operação desejada. Para um membro do vetor, (*ptr).size() e ptr->size() significam a mesma coisa. A forma com seta é mais curta; a forma com desreferenciação e ponto deixa explícitas as duas operações.

No exemplo acima, (*ptr).at(i) acessa um elemento pelo índice depois de desreferenciar o ponteiro para o vetor. A chamada ao membro ainda é feita no vetor, enquanto at(i) retorna o inteiro selecionado. Essa distinção é útil ao ler o código: ptr tem tipo ponteiro para vetor, mas (*ptr).at(i) se refere ao valor de um elemento. Se uma função precisar trabalhar com o vetor, passe um ponteiro para o vetor; se precisar de um único elemento, use uma referência ao elemento ou um ponteiro apropriado para ele.

Percorrer os elementos por meio de um ponteiro para um vetor

O laço usa ptr->size() como condição de parada e acessa cada valor com (*ptr).at(i). As duas operações passam pelo ponteiro para o vetor. Você também poderia escrever a chamada indexada ao membro com a forma de seta, como ptr->at(i); ela seleciona o mesmo membro do vetor. std::size_t, incluído por <cstddef>, é um tipo sem sinal adequado para representar o tamanho e os índices do vetor.

Um ponteiro para vetor é diferente de um iterador do vetor e de um ponteiro para um elemento individual. Neste exemplo, o ponteiro se refere ao objeto std::vector<int> inteiro. Um iterador representa uma posição fornecida pelo contêiner para percorrer seus elementos, enquanto um ponteiro para elemento se refere a um valor armazenado. O laço indexado mantém essas funções distintas e é útil quando você precisa do índice. Se a tarefa exigir apenas visitar todos os valores, também é possível usar um laço baseado em intervalo sobre *ptr, mas ele percorre o vetor sem demonstrar o acesso a membros por meio do ponteiro em cada etapa.

Como o exemplo não altera o vetor durante a iteração, o acesso por índice é direto. Em um programa que insere ou remove elementos durante a travessia, reavalie o laço: essas operações podem alterar o tamanho do vetor e invalidar referências, ponteiros ou iteradores para seus elementos. Um ponteiro para o objeto vetor continua apontando para esse objeto, mas não mantém estáveis as posições dos elementos. Mantenha o vetor vivo durante todo uso do ponteiro e escolha uma lógica de iteração que leve em conta as alterações feitas pelo programa.