std::next vs std::advance en C++

std::advance y std::next se utilizan para avanzar el iterador en una determinada posición, de modo que podamos hacer que el iterador apunte a la posición deseada. Aunque ambos tienen el mismo propósito, pero su implementación es diferente entre sí. Esto hace que sea importante para nosotros entender la diferencia entre los dos. En C++11, std::next() avanzará en uno de forma predeterminada, mientras que std::advance() requiere una distancia .

1. Diferencia sintáctica: la sintaxis de std::advance y std::next es:

// Definition of std::advance()
template
void advance( InputIt& it, Distance n );

it: Iterator to be advanced
n: Distance to be advanced

// Definition of std::next()
ForwardIterator next (ForwardIterator it,
       typename iterator_traits::difference_type n = 1);

it: Iterator pointing to base position
n: Distance to be advanced from base position.

• Tipo de devolución: std::advance no devuelve nada, mientras que std::next devuelve un iterador después de avanzar n posiciones desde la posición base dada.
• Como en la sintaxis de std::next() , al menos avanzará el iterador una posición , incluso si no especificamos la posición que tiene que avanzar ya que tiene un valor predeterminado uno, mientras que si usamos std: :advance , no tiene ese argumento predeterminado.

1. Laboral
   • Modificación de argumentos: std::advance modifica sus argumentos para que apunte a la posición deseada, mientras que std::next no modifica su argumento, de hecho devuelve un nuevo iterador que apunta a la posición deseada. 

// C++ program to demonstrate
// std::advance vs std::next
#include <iostream>
#include <iterator>
#include <deque>
#include <algorithm>
using namespace std;
int main()
{
    // Declaring first container
    deque<int> v1 = { 1, 2, 3 };
 
    // Declaring second container for
    // copying values
    deque<int> v2 = { 4, 5, 6 };
 
    deque<int>::iterator ii;
    ii = v1.begin();
    // ii points to 1 in v1
 
    deque<int>::iterator iii;
    iii = std::next(ii, 2);
    // ii not modified
 
    // For std::advance
    // std::advance(ii, 2)
    // ii modified and now points to 3
 
    // Using copy()
    std::copy(ii, iii, std::back_inserter(v2));
    // v2 now contains 4 5 6 1 2
 
    // Displaying v1 and v2
    cout << "v1 = ";
 
    int i;
    for (i = 0; i < 3; ++i) {
        cout << v1[i] << " ";
    }
 
    cout << "\nv2 = ";
    for (i = 0; i < 5; ++i) {
        cout << v2[i] << " ";
    }
 
    return 0;
}

• Producción:

v1 = 1 2 3
v2 = 4 5 6 1 2 

• Explicación: Como se puede ver, queremos hacer que ii apunte a 2 espacios por delante de donde apunta, por lo que si usamos std::advance ii apuntará a dos espacios por delante, mientras que si usamos std::next, entonces ii no avanzará, pero se devolverá un iterador que apunta a la nueva posición y se almacenará en iii.

1. Requisito previo: std::next requiere que el iterador pasado como argumento sea del tipo al menos iterador hacia adelante , mientras que std::advance no tiene tales restricciones, ya que puede funcionar con cualquier iterador, incluso con iterador de entrada o mejor que él.

Veamos las diferencias en forma tabular -:

Este artículo es una contribución de Mrigendra 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.