Funciones del par C ++

En esta guía, examinaremos los contenedores de pares en C ++ y sus aplicaciones. En el lenguaje de programación C ++, un contenedor de pares funciona de manera similar a una tupla. Sin embargo, un par solo podría contener dos elementos, mientras que una tupla puede contener muchos elementos. Los dos componentes podrían tener múltiples tipos de datos o tipos de datos similares como una tupla. El par es un contenedor dado por el módulo y se declara en el lenguaje de programación C ++ utilizando el término 'par'. Entonces, en esencia, se utiliza un par para combinar dos componentes o enteros dentro de uno. Esto permite el almacenamiento de elementos heterogéneos o múltiples tipos de datos como una sola entidad.

Solo se pueden almacenar dos componentes dentro del contenedor de par. El primero de los cuales solo podría ser referido por "primero" y el segundo de los cuales solo podría almacenarse en "segundo". También podemos usar operadores como = con pares. Podemos intercambiar el contenido de un par con otro par usando la función swap (). Además, la función Make Par () tiene una función que nos permite generar pares de valor sin especificar los tipos de datos exactos. En cambio, solo podemos escribir los valores.

Tipos de operadores

Usar operadores para conjuntos sigue siendo una opción.

A tal par de elementos, igual (=) crea un nuevo elemento u objeto. Esto potencialmente le da un valor al nuevo texto del objeto de par. Mientras que el segundo valor obtiene el segundo valor. El primer valor obtiene el primer valor de PR. Podemos usar el operador de comparación (==) con el par C ++. Solo usa el no igual (!=) Operador para el par: suponiendo que el par1 y el par2 se suministran, el!= El operador contrasta los primeros valores de los dos pares.

Específicamente, contrasta el primer valor de los dos conjuntos, Par1 y Par2. Una combinación de operadores lógicos (> =, =): los operadores = y> también se pueden emplear con pares, como Par1 y Par2. Simplemente evalúa el primer valor del par y devuelve 0 o 1. El par debe devolver 0 para combinaciones (ya que solo prueba la primera variable y, aunque son iguales), pero no lo hace. El par verifica el segundo elemento y devuelve 1 si califica al emplear los operadores relacionales> o simplemente para que el primer elemento sea equivalente.

Sintaxis de cómo declarar un par

El par podría haberse utilizado como la clase de plantilla STD :: Par para demostrar cómo o cuándo implementar el par como tupla en C ++ ya que STL (Biblioteca de plantilla estándar) hace uso del espacio de nombres "STD". Y el par es de hecho una clase de contenedores en stl.

La sintaxis del par puede explicarse ampliamente de la siguiente manera:

Pare (DT1, DT2) PareName;

Parámetros:

• Los tipos de datos para el primer y segundo elemento son DT1 para el componente principal y DT2, respectivamente.
• Los nombres de los pares se utilizan para identificar los componentes del primer y segundo de un par de objetos.

Veremos un ejemplo que define un contenedor de pares y utiliza el archivo de encabezado.

Ejemplo 1

En este programa, veríamos que hemos incluido el archivo de encabezado utilizando contenedores de pares y el archivo de encabezado para imprimir mensajes o entrada o salida. La sintaxis para utilizar el espacio de nombres STD en los códigos mencionados anteriormente es la siguiente:

# std :: pair parname;

Podemos usar cualquier tipo de datos para la variable definida. Se toman los siguientes pasos para definir, acceder o inicializar los valores para cada elemento dentro del contenedor de par:

• Primero se puede usar para especificar o recuperar el primer elemento.
• El segundo puede recuperar o especificar el segundo elemento.

Tenga en cuenta que aunque establecer y especificar el par, no podemos alterar el orden o el tipo de datos de las variables.

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

std :: pair parname;
nombre.primero = 23;
nombre.segundo = 16;
std :: cout << "The first value: " << pairname.first << std::endl;
std :: cout << "The second value: " << pairname.second << std::endl;
regresar 0;

Presentaríamos el archivo de encabezado y . Utilizaremos el espacio de nombres estándar como 'STD'. Luego, utilizaríamos la función principal (). A continuación, aplicaremos el método de par. Dentro de esta función, proporcionaríamos dos argumentos para este método. Luego, usamos el atributo 'parname'. A continuación, declararíamos el atributo 'primer' del 'PareName' e indicaríamos el valor de este atributo.

Del mismo modo, inicializaremos el atributo 'segundo' del 'PareName'. Después de todo esto, aplicaríamos la función de salida estándar de 'Cout'. Al usar esto, mostramos el primer valor. A continuación, una vez más emplearíamos el comando 'Cout'. Usando este método, mostraríamos el segundo valor. Al final, emplearíamos el comando 'return 0'.

Ejemplo 2

Aquí, todavía no estamos utilizando el encabezado como en el primer ejemplo.

#incluir
usando el espacio de nombres STD;
int main ()

std :: pair parname;
nombre.primero = "información";
nombre.segundo = 78.45;
std :: cout << "The first item: " << pairname.first << std::endl;
std :: cout << "The second item: " << pairname.second << std::endl;
regresar 0;

Integraríamos el archivo de encabezado al comienzo del programa. El espacio de nombres que usaremos se denomina "STD."En ese punto, se llamaría al método Main (). La técnica de par se utilizará a continuación. Daríamos dos parámetros a este método desde este método. 'Float' y 'String' se encuentran entre los parámetros. Usaremos el atributo "PareName" después de eso.

Después de eso, declararemos y especificaremos el valor del "primer" componente del "nombre de par."Para el primer parámetro, utilizaremos el valor" Información.El "segundo" atributo del "PareName" se inicializará adecuadamente. En este punto, se proporciona el valor de este parámetro. Para el "segundo" argumento, proporcionaríamos el valor de punto flotante. Con eso, estaríamos usando la salida estándar de la función de cout. Entonces, una vez más usaríamos el comando "Cout". Este método nos permitiría mostrar el segundo elemento. Al finalizar, utilizaremos el comando "Return 0."

Dentro de este programa, podemos ver que definimos dos variables, una con el tipo de datos "Cadena" y otra con el tipo de datos "Flotación". Usamos "PareName.Primero "para inicializar el valor para quizás el primer elemento cuando nos referimos a él como de tipo" cadena ".

Ejemplo 3

Junto con contenedores de pares, operadores como =, ==, y otros pueden hacer algo para obtener resultados. También mostremos cómo utilizar la función Make Par (), que se puede utilizar para ejecutar el programa en el siguiente ejemplo incluso cuando no se especifican los tipos de datos.

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

pairpair_1 = make_pair (456, 198);
pairpair_2 = make_pair (697, 843);
cout<< "Use of opertaors:\n";
cout << (pair_1 <= pair_2) << endl;
cout <= pair_2) << endl;
cout < pair_2) << endl;
cout << (pair_1 < pair_2) << endl;
cout << (pair_1 == pair_2) << endl;
cout << (pair_1 != pair_2) << endl;
cout << "Use of swap function:\n";
cout << "Before swapping:\n" ;
cout << "Values of first pair = " << pair_1.first << " " << pair_1.second << "\n";
cout << "Values of second pair = " << pair_2.first << " " << pair_2.second << "\n";
Pare_1.intercambio (par_2);
cout << "\nAfter swapping:\n";
cout << "Values of first pair = " << pair_1.first << " " << pair_1.second << "\n " ;
cout << "Values of second pair = " << pair_2.first << " " << pair_2.second << "\n" ;
regresar 0;

Aquí, integraremos los archivos de encabezado y . Además, utilizaríamos el espacio de nombres estándar como 'STD'. Utilizamos la función de par. Primero, proporcionamos los argumentos. Los argumentos incluyen dos enteros. Especificamos el nombre del primer par como 'par_1'. Hemos estado usando el método make_pair () para crear un par. Daremos dos valores aleatorios para hacer un par. Para crear un segundo par, utilizaríamos el método de par. Establecemos el nombre del segundo par como 'par_2'. Crearemos un par de dos valores mediante el uso del método make_pair ().

Luego, el comando 'cout' se usará para mostrar el resultado 'uso del operador'. En el siguiente paso, aplicaríamos la declaración 'Cout'. Dentro de este comando, empleamos diferentes operadores en los dos pares definidos. Primero, aplicaremos el operador '=' para verificar si los elementos del primer par serán mayores o iguales a los elementos del segundo par o no.

A continuación, usaríamos el signo '>' para evaluar si los valores requeridos del primer par serán mayores que el segundo par o no. Aquí, emplearemos el '<' sign to verify whether the values of pair 1 are less than the values of pair 2 or not. Next, we would utilize the '==' operator. This operator checks whether the pair 1 values would be equal to the pair 2 values or not. In the last, we would use the '!=' operator. This operator evaluates if the value checks whether the value of the first pair would not be equal to the values of the second pair or not.

Aplicamos estos operadores a los valores de ambos pares. Luego, obtenga el resultado en la forma de 0 y 1. El resultado '0' representa el 'falso' y el '1' representa el 'verdadero'. Además, usaríamos el comando 'cout' para mostrar la línea 'uso de funciones de intercambio'. Primero, mostraremos los valores del primer y segundo par antes de cambiar el uso de la declaración 'Cout'. Utilizaríamos el método swap () para intercambiar los valores del primer par a los valores del segundo par. La declaración de 'cout' imprime la línea 'después de intercambiar'.

Además de esto, nuevamente empleamos el comando 'cout' para mostrar los valores después de intercambiar. El comando 'return 0' se aplicaría al final del código.

El método Make Par () se demuestra en el ejemplo mencionado anteriormente, con el que podemos ver que el par1 se inicia con un tipo 'int' y no se especifican los tipos de datos para las variables. Luego, observamos a los operadores que se pueden usar con la función de par. Una cosa para recordar para que los operadores de comparación funcionen correctamente es que dos variables en un par deben ser el mismo tipo de datos. Luego se demostró la función de intercambio, lo que demuestra que se estaba utilizando con pares para intercambiar no solo las variables dentro de ellas, sino también los pares que este programa había declarado.

Ejemplo 4

La función Tie () realiza operaciones muy similares a las tuplas. Para extraer los valores de tupla (o par en este caso) en las variables independientes, produce una tupla de punteros valiosos a sus parámetros. Aquí, la corbata está disponible en dos versiones con o sin "ignorar", como en tuplas. La palabra clave "ignorar" evita que un determinado elemento de tuple sea decodificado o desempaquetado. Los pares tienen solo dos parámetros, pero las tuplas pueden tener numerosos argumentos. Por lo tanto, la decodificación o el desempaquetado debe tratarse explícitamente principalmente en el caso de pares.

#incluir
usando el espacio de nombres STD;
int main ()

par par_1 = 13, 62;
int i, j;
Tie (i, j) = par_1;
cout << i << " " << j << "\n";
par par_2 = 73, 54;
Tie (i, ignorar) = par_2;
cout << i << " " << j << "\n";
par par_3 = 23, 34, 'i';
int m, n;
char o;
m = par_3.primero;
TIE (N, O) = par_3.segundo;
cout << m << " " << n << " " << o << "\n";

Primero, la biblioteca se incluiría. Utilizaremos el espacio de nombres estándar como 'STD'. La función principal () se invocaría. El método de par se utilizará. Primero, indicaremos los valores del primer par. Luego, declaramos dos variables llamadas 'I' y 'J'. Usaremos el método tie (). Pasamos dos atributos a esta función. La instrucción 'cout' se utilizará para mostrar los valores de ambas variables.

A continuación, utilizamos la función de par una vez más. Especificamos los valores del segundo par. La función Tie () se utilizará. Hemos pasado 'ignorar' como el parámetro de este método. El comando 'cout' se usará para mostrar el elemento de la variable 'j'. El método 'par' se usa una vez más. Pasaremos int y char como los argumentos a la función del par. Ahora, inicializaríamos dos variables denominadas 'M' y 'N'. Estas variables tienen un entero de tipo de datos. Se declarará una nueva variable 'O'. Tiene un tipo de datos de caracteres. Una vez más hemos estado usando el método tie (). Esta función contiene dos argumentos que incluyen variables 'n' y 'o'. La instrucción 'cout' se aplicará para imprimir el valor.

Conclusión

El contenedor de pares funciona de manera similar a la "tupla" de Python, ya que puede contener cada componente en una variable de par con los mismos o distintos tipos de datos. No importa los tipos de datos de las piezas, el contenedor de par en C ++ se usa principalmente para combinar dos elementos en una sola unidad. Este artículo también demostró el uso de operadores de swap () y pares. También proporcionó un ejemplo de operador de comparación. En un ejemplo, hemos cambiado los valores de dos pares. También utilizamos el método tie (). Se incorporan cuatro ejemplos únicos en esta guía para comprender los pares en C++.