forward_list.h File Reference

This file contains implementation of ForwardList class. More...

#include <cstddef>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <limits>
#include <memory>
#include <ranges>
#include <utility>

Go to the source code of this file.

Classes
class	dsa::ForwardList< T >
	Implements ForwardList using Node with pointer to next element as internal base. More...
class	dsa::ForwardList< T >::NodeBase
	Struct implements base pointer used by ForwardList. More...
class	dsa::ForwardList< T >::Node
	Implements Node class with user data. More...
class	dsa::ForwardList< T >::ForwardListIterator< IF_CONST >
	Implements ForwardListIterator. More...

Functions
template<typename T>
auto	dsa::operator<< (std::ostream &out, const ForwardList< T > &list) -> std::ostream &
	Overloads operator to print all elements of ForwardList.
template<typename T>
auto	dsa::operator== (const ForwardList< T > &lhs, const ForwardList< T > &rhs) noexcept(noexcept(*lhs.begin()== *rhs.begin())) -> bool
	The relational operator compares two ForwardList objects.
template<typename T>
auto	dsa::operator<=> (const ForwardList< T > &lhs, const ForwardList< T > &rhs) noexcept(noexcept(*lhs.begin()== *rhs.begin())) -> std::compare_three_way_result_t< T >
	The relational operator compares two ForwardList objects.
template<typename T>
void	dsa::swap (ForwardList< T > &lhs, ForwardList< T > &rhs) noexcept(noexcept(lhs.swap(rhs)))
	Exchanges content of two ForwardList containers.
template<typename T, typename U>
auto	dsa::erase (ForwardList< T > &container, const U &value) -> ForwardList< T >::size_type
	Function erases from container all elements that are equal to value.
template<typename T, typename Pred>
auto	dsa::erase_if (ForwardList< T > &container, Pred pred) -> ForwardList< T >::size_type
	Function erases from container all elements that satisfy the predicate pred.

Detailed Description

This file contains implementation of ForwardList class.

Author

Michal Zygmunt

Copyright

Copyright (c) 2025 Michal Zygmunt This project is distributed under the MIT License. See accompanying LICENSE.txt file or obtain copy at https://opensource.org/license/mit

Definition in file forward_list.h.

Function Documentation

erase()

template<typename T, typename U>

auto dsa::erase	(	ForwardList< T > &	container,
		const U &	value ) -> ForwardList<T>::size_type

Function erases from container all elements that are equal to value.

Template Parameters

T	data type stored in containers
U	data type of value

Parameters

[in,out]	container	object to remove erase elements from
[in]	value	value to remove from container

Returns

size_type number of elements removed

Definition at line 1974 of file forward_list.h.

    {
        return erase_if(container, [&value](U node_val) { return node_val == value; });
    }

erase_if()

template<typename T, typename Pred>

auto dsa::erase_if	(	ForwardList< T > &	container,
		Pred	pred ) -> ForwardList<T>::size_type

Function erases from container all elements that satisfy the predicate pred.

Template Parameters

T	data type stored in containers
Pred	predicate to check if element should be erased

Parameters

[in,out]	container	container object to remove erase elements from
[in]	pred	predicate which returns true if the element should be erased

Returns

size_type number of elements removed

Definition at line 1989 of file forward_list.h.

    {
        return container.remove_if(pred);
    }

operator<<()

template<typename T>

auto dsa::operator<<	(	std::ostream &	out,
		const ForwardList< T > &	list ) -> std::ostream&

Overloads operator to print all elements of ForwardList.

Template Parameters

T	type of initializer list elements

Parameters

[in,out]	out	reference to output stream
[in]	list	ForwardList to print

Returns

std::ostream&

Definition at line 1863 of file forward_list.h.

    {
        if (list.empty())
        {
            return out;
        }
 
        for (auto it = list.cbegin(); it != list.cend(); ++it)
        {
            T value = *it;
            out << value << ' ';
        }
 
        return out;
    }

operator<=>()

template<typename T>

auto dsa::operator<=> ( const ForwardList< T > & lhs, const ForwardList< T > & rhs ) -> std::compare_three_way_result_t<T>

nodiscardnoexcept

The relational operator compares two ForwardList objects.

Depending on type T, function returns one of following objects: std::strong_ordering::less / equal / greater std::weak_ordering::less / equivalent / greater std::partial_ordering::less / equivalent / greater / unordered It is best to compare results with 0 to determine if lhs is <, >, or == to rhs

Parameters

[in]	lhs	input container
[in]	rhs	input container

Returns

three way comparison result type

Definition at line 1928 of file forward_list.h.

    {
        auto lhs_iter = lhs.cbegin();
        auto rhs_iter = rhs.cbegin();
 
        while (lhs_iter != lhs.cend() && rhs_iter != rhs.cend())
        {
            auto cmp = *lhs_iter <=> *rhs_iter;
            if (cmp != 0)
            {
                return cmp;
            }
 
            lhs_iter++;
            rhs_iter++;
        }
 
        // first n elements are equal
        // check sizes
        return lhs.size() <=> rhs.size();
    }

operator==()

template<typename T>

auto dsa::operator== ( const ForwardList< T > & lhs, const ForwardList< T > & rhs ) -> bool

nodiscardnoexcept

The relational operator compares two ForwardList objects.

Template Parameters

T	type of data stored in ForwardList

Parameters

[in]	lhs	input container
[in]	rhs	input container

Return values

true	if containers are equal
false	if containers are not equal

Definition at line 1889 of file forward_list.h.

    {
        if (lhs.size() != rhs.size())
        {
            return false;
        }
 
        auto lhs_iter = lhs.cbegin();
        auto rhs_iter = rhs.cbegin();
 
        while (lhs_iter != lhs.cend())
        {
            if (*lhs_iter != *rhs_iter)
            {
                return false;
            }
 
            lhs_iter++;
            rhs_iter++;
        }
 
        return true;
    }

swap()

template<typename T>

void dsa::swap ( ForwardList< T > & lhs, ForwardList< T > & rhs )

noexcept

Exchanges content of two ForwardList containers.

Template Parameters

T	data type stored in containers

Parameters

[in]	lhs	container to swap content
[in]	rhs	container to swap content

Definition at line 1959 of file forward_list.h.

    {
        lhs.swap(rhs);
    }