Vetor C++ de pares

Vetor C De Pares



Em C++, um vetor é um contêiner versátil que pode se redimensionar dinamicamente, o que permite a manipulação eficiente de elementos. Embora um par seja um contêiner simples que pode conter dois objetos heterogêneos, o que fornece um meio conveniente de associar e gerenciar os dados relacionados. Quando esses pares são organizados dentro de um vetor, os desenvolvedores ganham a capacidade de criar coleções dinâmicas de pares chave-valor ou qualquer outra combinação de dois elementos distintos.

Essa estrutura de dados é particularmente útil em cenários onde os elementos devem ser armazenados como pares, como ao lidar com pares de valores-chave ou representar relacionamentos entre entidades. Neste artigo, exploraremos o conceito de vetor de pares C++ e exploraremos os vários exemplos para ilustrar suas aplicações práticas.







Exemplo 1: Uso Básico: Iterando sobre um Vetor de Pares

Vamos considerar um exemplo básico onde criamos um vetor de pares que representam os nomes dos alunos e suas idades correspondentes. Iterar sobre um vetor de pares é semelhante a iterar sobre um vetor regular. Pode-se empregar iteradores ou loops “for” baseados em intervalo para recuperar cada par dentro do vetor.



Este exemplo mostra a sintaxe de um “vetor de pares” em um contexto significativo.



#include
#incluir
#include

principal interno ( ) {

std::vetor < std::par < std::string,int >> dados do aluno;

estudanteData.push_back ( std::make_pair ( 'Adão' , vinte ) ) ;
estudanteData.push_back ( std::make_pair ( 'Conta' , 22 ) ) ;
estudanteData.push_back ( std::make_pair ( 'Charlie' , vinte e um ) ) ;

std::cout << 'Dados do aluno: \n ' ;
para ( const automático & aluno: dados do aluno ) {
std::cout << 'Nome: ' << estudante.primeiro << ', Idade: ' << aluno.segundo << std::endl;
}

retornar 0 ;
}


Neste trecho de código C++, começamos incluindo três arquivos de cabeçalho essenciais: “ ” para operações de entrada e saída, “” para utilizar o contêiner de vetor e “” para acessar o “std:: modelo de par”. Esses cabeçalhos nos permitem utilizar as funcionalidades essenciais ao nosso programa.





Seguindo em frente, dentro da função main(), declaramos um vetor chamado “studentData” usando o contêiner “std::vector”. Este vetor é projetado para armazenar os pares onde cada par encapsula o nome de um aluno (representado como “std::string”) e sua idade (um número inteiro “int”). Em seguida, preenchemos o vetor “studentData” com três pares. Utilizando a função “push_back”, pares são adicionados ao final do vetor, ajustando dinamicamente seu tamanho. Um loop então percorre “studentData”, extraindo e imprimindo o nome e a idade de cada aluno. A saída exibe “Dados do Aluno:” que enfatiza a representação estruturada. Os nomes e idades dos alunos são impressos separadamente, apresentando claramente os dados armazenados.



Exemplo 2: Classificando um Vetor de Pares

Classificar um vetor de pares é uma operação comum, especialmente quando se trata de associações de valores-chave. A função “std::sort” do cabeçalho “ ” pode ser usada para este propósito. Vamos ver como ordenar um vetor de pares com base no primeiro e no segundo elementos:

#include
#incluir
#incluir

principal interno ( ) {

std::vetor < std::par < std::string,int >> informações;

info.push_back ( std::make_pair ( 'Peter' , quinze ) ) ;
info.push_back ( std::make_pair ( 'Dora' , 29 ) ) ;
info.push_back ( std::make_pair ( 'Hana' , vinte ) ) ;

std::cout << 'Informações Originais: \n ' ;
para ( const automático & entrada: informações ) {
std::cout << 'Nome: ' << entrada.primeiro << ', Idade: ' << entrada.segundo << std::endl;
}


std::classificar ( info.begin ( ) , info.end ( ) ) ;

std::cout << ' \n Informações classificadas: \n ' ;
para ( const automático & entrada: informações ) {
std::cout << 'Idade: ' << entrada.segundo << ', Nome: ' << entrada.primeiro << std::endl;
}

retornar 0 ;
}


Neste exemplo de código C++, estamos trabalhando com um vetor de pares para armazenar e manipular os dados relacionados aos indivíduos, especificamente seus nomes e idades. Inicializamos um vetor chamado “info of pairs” dentro da função main(). Posteriormente, preenchemos este vetor com três pares, cada um contendo o nome e a idade de uma pessoa distinta, utilizando a função “push_back” e “std::make_pair” para criação eficiente de pares.

Enviamos as “Informações Originais” para o console. Isso envolve iterar através do vetor “info” e imprimir os componentes de cada par. Em seguida, utilizamos o algoritmo “std::sort” para reorganizar o vetor “info” com base no operador de comparação padrão para pares que compara o primeiro elemento de cada par (neste caso, os nomes). Após a operação de classificação, iteramos novamente pelo vetor “info” modificado, imprimindo as informações classificadas. Desta vez, o resultado enfatiza a ordenação por idade, ilustrando o resultado do processo de classificação.

Exemplo 3: Combinando os Vetores de Diferentes Tipos

Você pode encontrar algumas situações em que deve combinar informações de dois vetores. Um vetor de pares pode ajudar a manter a associação entre os elementos dos dois vetores.

#include
#incluir

principal interno ( ) {
std::vetor < std::string > cidades = { 'Nova Iorque' , 'Paris' , 'Tóquio' } ;
std::vetor < interno > populações = { 8175133 , 2140526 , 37435191 } ;

std::vetor < std::par < std::string,int >> cityPopulationPairs;

para ( tamanho_t eu = 0 ; eu < std::min ( cidades.tamanho ( ) , populações.tamanho ( ) ) ; ++eu ) {
cityPopulationPairs.push_back ( { cidades [ eu ] , populações [ eu ] } ) ;
}

std::cout << 'Pares Cidade-População:' << std::endl;
para ( const automático & par: cityPopulationPairs ) {
std::cout << 'Cidade: ' << par.primeiro << ', População: ' << par.segundo << std::endl;
}

retornar 0 ;
}


Na função “principal” do código, dois vetores são declarados: “cidades” para armazenar os nomes das cidades e “populações” para armazenar os valores populacionais correspondentes.

Um terceiro vetor, “cityPopulationPairs”, é definido para armazenar os pares de cidades e suas respectivas populações. Cada par é “std::pair” onde “std::string” representa o nome da cidade e “int” representa a população. Em seguida, usamos uma iteração de loop “for” sobre os vetores (cidades e populações) usando “std::min” para garantir que o loop não acesse os elementos além do menor dos dois tamanhos de vetor. Dentro do loop, pares de informações cidade-população são criados e anexados ao vetor “cityPopulationPairs”.

Após combinar as informações, outro loop “for” é usado para iterar pelos pares que estão armazenados em “cityPopulationPairs”. Os dados combinados são então exibidos na saída padrão usando “std::cout”, representando claramente cada cidade e sua população correspondente.

Exemplo 4: Encontrando os Valores Máximo e Mínimo

Identificar os valores mínimos e máximos em um conjunto de dados é um requisito comum em operações algorítmicas e estatísticas. Podemos usar um vetor de pares para acompanhar os valores máximo e mínimo em uma sequência:

#include
#incluir
#incluir

principal interno ( ) {
std::vetor < interno > números = { 5 , 12 , 18 , 3 , 7 , 4 , 33 } ;

std::vetor < std::par < você, você >> minMaxPairs;

std::classificar ( números.begin ( ) , números.fim ( ) ) ;

minMaxPairs.push_back ( { números.front ( ) , números.voltar ( ) } ) ;

std::cout << 'Pares Mín-Máx:' << std::endl;
para ( const automático & par: minMaxPairs ) {
std::cout << 'Min:' << par.primeiro << ', Máx.:' << par.segundo << std::endl;
}

retornar 0 ;
}


O código C++ fornecido demonstra o processo de encontrar os valores mínimo e máximo em um vetor de números inteiros e, em seguida, armazenar esses valores em um vetor de pares. Um vetor denominado “números” é inicialmente declarado e inicializado com um conjunto de inteiros. Para identificar com eficiência os valores mínimos e máximos no conjunto de dados, o programa utiliza a função “std::sort” da biblioteca de algoritmos.

Esta função visa organizar os elementos em ordem crescente, simplificando o processo de identificação dos valores mínimos e máximos do conjunto de dados. A operação de classificação é aplicada ao vetor “números” usando numbers.begin() e numbers.end() como parâmetros de intervalo. Após a etapa de classificação, o programa cria um vetor de pares, “minMaxPairs”, para armazenar os valores mínimo e máximo calculados. A função “push_back” é então empregada para adicionar um único par que contém o primeiro (mínimo) e o último (máximo) elementos do vetor de números classificados. Finalmente, o programa gera o resultado iterando através do vetor “minMaxPairs” e exibindo os valores mínimo e máximo.

Conclusão

Concluindo, o vetor de pares C++ surge como uma estrutura de dados poderosa e flexível, adicionando uma camada de versatilidade às tarefas de programação. Através de uma exploração detalhada de sua sintaxe e aplicações práticas, vimos como esse contêiner ajuda a organizar as associações de valores-chave, combinar as informações de diferentes vetores e rastrear os valores mínimos e máximos.