<utilidad> en C++

Es un archivo de encabezado que contiene utilidades en dominios no relacionados. 

• Pares : estos son los objetos que pueden contener dos tipos diferentes de valores. 
• Enfoque relacional genérico : se utiliza para los operadores relacionales !=, >, = bajo un espacio de nombres específico: rel_ops. 
• Función de intercambio genérica : esta es una definición estándar utilizada por defecto por los componentes de la biblioteca estándar para todos los tipos que no proporcionan su propia sobrecarga: intercambio.

Funciones: 

1. swap : Intercambia el valor de dos objetos.

// CPP program to illustrate
// the use of swap function
#include <iostream>    
#include <utility>    
using namespace std;
 
// Driver Program
int main ()
{
 
    // a: _ _ _ _ (empty array in beginning)
    int a[4];        
     
    // Initializing, a: _ _ _ _ & b: 10 20 30 40
    int b[] = {10, 20, 30, 40};
     
    // After swapping, a: 10 20 30 40 & b: _ _ _ _
    swap(a, b);            
     
    cout << "a contains:";
    for (int i; i<4;i++)
        cout << a[i]<<endl;
     
    return 0;
}

Producción: 

a contains:10
20
30
40

2. make_pair : Construye un par con su primer elemento establecido en x y su segundo elemento establecido en y.

// CPP program to illustrate
// the use of make_pair
#include <utility>    
#include <iostream>
using namespace std;
 
// Driver program
int main ()
{
     
    // Initializing the pair with int type
    pair <int, int> a;
    pair <int, int> b;
     
    // Use of the make_pair function
    a = make_pair (10, 20);
     
    // It's ok to write like this as implicit
    // conversion takes place from pair<double, char>
    b = make_pair (15.5, 'B');
     
    // Printing the first and second values of the pair
    cout << "a: " << a.first << ", " << a.second << endl;
    cout << "b: " << b.first << ", " << b.second << endl;
     
    return 0;
}

Producción:

a: 10, 20
b: 15, 66

3. mover : Se mueve como rvalue . move se usa para indicar que un objeto puede ser «mover de», es decir, permitir la transferencia de recursos de un objeto (para ser movido) a otro objeto.

// CPP program to illustrate
// the use of move
#include <utility>    
#include <iostream>    
#include <vector>    
#include <string>    
using namespace std;
 
// Driver Program
int main ()
{
    string s = "Hello!!";
    string s1 = "I am a geek.";
    vector<string> gfg;
     
    // It copies 's' in gfg
    gfg.push_back (s);
     
    // It moves 's1' in the gfg(containing 's')
    gfg.push_back (move(s1));        
     
    cout << "gfg contains:";
    for (int i=0;i< gfg.size(); i++)
        cout << ' ' << gfg[i];
    cout<<endl;
     
    return 0;
}

Producción:

gfg contains: Hello!! I am a geek.

4. mover (rango de elementos) : Mueve los elementos en el rango [primero, último] al rango que comienza en el resultado. 
Después de esta operación, los elementos en el rango desde el que se movió aún contendrán valores válidos del tipo apropiado, pero no necesariamente los mismos valores que antes del movimiento.

// CPP program to
// Illustrate the use of vector
// move range of elements
#include <iostream>
 
// for move (ranges)
#include <algorithm>
 
// for move (objects)
#include <utility>    
#include <vector>    
#include <string>
using namespace std;
 
// Driver program
int main ()
{
    vector<string> string1 = {"Hello!", "I", "am", "a", "geek"};
    vector<string> string2 (5);
     
    // moving ranges:
    cout << "Moving ranges...\n";
     
    // use of move i.e.it moves from first to last element in
    // string 1 to the string2 from it's(string 2) starting
    move ( string1.begin(), string1.begin()+5, string2.begin() );
     
    cout << "string1 contains " << string1.size()
                                << " elements\n";
     
    cout << "string2 contains " << string2.size()
                        << " elements(after moving):";
     
    for (int i=0; i<string2.size(); i++)
        cout << string2[i] << " ";
    cout << endl;
     
     
    return 0;
}

Producción:

Moving ranges...
string1 contains 5 elements
string2 contains 5 elements(after moving):Hello! I am a geek 

5. move_if_noexcept : Obtiene una referencia de valor r a su argumento si su constructor de movimientos no lanza excepciones, de lo contrario obtiene una referencia de valor l a su argumento.

// CPP program to illustrate
// the use of move_if_noexcept
#include<iostream>
#include<utility>
using namespace std;
 
struct Bad
{
     
    Bad() {}
     
    // may throw
    Bad(Bad&&)
    {
        cout << "Throwing move constructor called"<<endl;
    }
     
    // may throw as well
    Bad(const Bad&)
    {
        cout << "Throwing copy constructor called"<<endl;
    }
};
 
struct Good
{
    Good() {}
     
    // will NOT throw
    Good(Good&&) noexcept
    {
        cout << "Non-throwing move constructor called"<<endl;
    }
     
    // will NOT throw
    Good(const Good&) noexcept
    {
        cout << "Non-throwing copy constructor called"<<endl;
    }
};
 
 
// Driver Program
int main()
{
    Good g;
    Bad b;
    Good g2 = move_if_noexcept(g);
    Bad b2 = move_if_noexcept(b);
}

Producción:

Non-throwing move constructor called
Throwing copy constructor called

6. decval : Devuelve una referencia rvalue sin hacer referencia a ningún objeto. 
Esta función selecciona el tipo de un argumento como una referencia de valor r si su constructor de movimiento nunca lanza, o alternativamente, como una referencia de valor l si el tipo es construible por copia. Si el tipo no es ninguno, la función devuelve un valor r, que se seleccionará para los tipos de solo movimiento (incluso si pueden arrojar). 
Algunas operaciones se pueden implementar moviendo o copiando objetos, generalmente moviendo para valores r y copiando para valores l: Mover es generalmente una operación más eficiente que copiar cuando el objeto ya no es necesario (como los valores r).

// CPP program to illustrate
// the use of declval
#include <utility>
#include <iostream>
using namespace std;
 
//class
struct A
{
virtual int value() = 0;
};
 
// Class with constructor
class B : public A
{
    int val_;
    public:
    B(int i, int j):val_(i*j){}
    int value()
    {
        return val_;
         
    }
};
 
// Driver Program
int main()
{
    // int a
    decltype(declval<A>().value()) a;
     
    // int b
    decltype(declval<B>().value()) b;
         
    //same as constructor
    a = b = B(100, 20).value();
    cout << a << endl;
    return 0;
}

Producción:

2000

Este artículo es una contribución de Shambhavi Singh . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.