std::forward_list::merge

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de contenedores

De secuencias

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Asociativos

set

multiset

map

multimap

Asociativos no ordenados

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptadores

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Vistas

span (C++20)

mdspan (C++23)

Tablas

Invalidación de iteradores

Tabla de funciones miembro

Tabla de funciones no miembro

 

std::forward_list

Funciones miembro

forward_list::forward_list

forward_list::~forward_list

forward_list::operator=

forward_list::assign

forward_list::get_allocator

Acceso a elementos

forward_list::front

Iteradores

forward_list::before_beginforward_list::cbefore_begin

forward_list::beginforward_list::cbegin

forward_list::endforward_list::cend

Capacidad

forward_list::empty

forward_list::max_size

Modificadores

forward_list::clear

forward_list::insert_after

forward_list::emplace_after

forward_list::erase_after

forward_list::push_front

forward_list::emplace_front

forward_list::pop_front

forward_list::resize

forward_list::swap

Operaciones

forward_list::merge

forward_list::splice_after

forward_list::removeforward_list::remove_if

forward_list::reverse

forward_list::unique

forward_list::sort

Funciones no miembro

std::swap

eraseerase_if (C++20)(C++20)

operator==operator!=operator<operator>operator<=operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20)

Guías de deducción(C++17)

 

void merge( forward_list& other );	(1)	(desde C++11)
void merge( forward_list&& other );	(1)	(desde C++11)
template <class Compare> void merge( forward_list& other, Compare comp );	(2)	(desde C++11)
template <class Compare> void merge( forward_list&& other, Compare comp );	(2)	(desde C++11)

Fusiona dos listas ordenadas en una. Las listas deben ordenarse en orden ascendente.

No se copian elementos. El contenedor other queda vacío después de la operación. La función no hace nada si other se refiere al mismo objeto que *this. Si get_allocator() != Other.get_allocator(), el comportamiento no está definido. Ningún iterador o referencia se invalida, excepto que los iteradores de elementos movidos ahora se refieren a *this, no a other. La primera versión usa operator< para comparar los elementos, la segunda versión usa la función de comparación dada comp.

Esta operación es estable: para elementos equivalentes en las dos listas, los elementos de * this siempre precederán a los elementos de other, y el orden de los elementos equivalentes de * this y other no cambia.

Parámetros

other	-	El otro contenedor a fusionar.
comp	-	Objeto función de comparación (es decir, un objeto que satisface los requisitos de Compare) que devuelve ​true si el primer argumento es menor (es decir, se ordena antes) que el segundo. La signatura de la función de comparación debe ser equivalente a la siguiente: bool cmp(const Tipo1 &a, const Tipo2 &b); Si bien la signatura no necesita tener const &, la función no debe modificar los objetos que se le pasan y debe poder aceptar todos los valores de tipo (posiblemente const) Tipo1 y Tipo2 independientemente de la categoría de valor (por lo tanto, Tipo1 & no está permitido , ni Tipo1 a menos que para Tipo1 un movimiento sea equivalente a una copia (desde C++11)). Los tipos Tipo1 y Tipo2 deben ser tales que un objeto de tipo forward_list<T,Allocator>::const_iterator puede ser desreferenciado y luego convertido implícitamente a ambos. ​

Valor de retorno

(Ninguno)

Excepciones

Si se lanza una excepción, esta función no tiene ningún efecto (garantía de excepción fuerte), excepto si la excepción proviene de la función de comparación.

Complejidad

A lo sumo std::distance(begin(), end()) + std::distance(other.begin(), other.end()) - 1 comparaciones.

Ejemplo

Ejecuta este código

#include <iostream>
#include <forward_list>
 
std::ostream& operator<<(std::ostream& ostr, const std::forward_list<int>& list)
{
    for (const auto &i : list) {
        ostr << ' ' << i;
    }
    return ostr;
}
 
int main()
{
    std::forward_list<int> lista1 = {5, 9, 1, 3, 3};
    std::forward_list<int> lista2 = {8, 7, 2, 3, 4, 4};
 
    lista1.sort();
    lista2.sort();
    std::cout << "lista1:      " << lista1 << '\n';
    std::cout << "lista2:      " << lista2 << '\n';
    lista1.merge(lista2);
    std::cout << "fusionadas:  " << lista1 << '\n';
}

Salida:

lista1:      1 3 3 5 9
lista2:      2 3 4 4 7 8
fusionadas:  1 2 3 3 3 4 4 5 7 8 9

Véase también

splice_after (C++11)	Mueve elementos de otro contenedor forward_list. (función miembro pública)
merge	Fusiona dos rangos ordenados. (plantilla de función)
inplace_merge	Fusiona dos rangos ordenados in situ. (plantilla de función)
ranges::merge (C++20)	Fusiona dos rangos ordenados (niebloid)
ranges::inplace_merge (C++20)	Fusiona dos rangos ordenados in situ. (niebloid)