use of algorithms in function cause ERROR: no instance of overloaded function

Question

I'm trying to use an algorithm in a function.

Should be very simple.

However, regardless of which algorithm I attempt to use, all of them cause the same error when used in a function.

E0304 no instance of overloaded function "std::begin" matches the argument list

E0304 no instance of overloaded function "std::end" matches the argument list

I am guessing there is some small change that needs to be made.

#include <iostream>
#include <algorithm>

#include "bool_element_option_03.h"
#include "storage.h"

int main()
{
    int arr_value[ELEMENTS]{ 1, 2, 9, 4, 5, 6, 7, 8 };

    int arr_copy_value[ELEMENTS];
    
    // array population
    for (int var_create_array_a = 0; var_create_array_a < ELEMENTS; var_create_array_a++)
    {
        arr_copy_value[var_create_array_a] = 0;
    }

    //std::copy(std::begin(arr_value), std::end(arr_value), std::begin(arr_copy_value));
    //std::sort(std::rbegin(arr_copy_value), std::rend(arr_copy_value));

    for (int output = 0; output < ELEMENTS; output++)
    {
        std::cout << "copied decimals: " << arr_copy_value[output] << std::endl;
    }

    bool_element_option_03(arr_value, arr_copy_value);

    return 0;
}

#ifndef _STORAGE_H
#define _STORAGE_H
#define WIN32_LEAN_AND_MEAN

// -----------------------------------------------------------------------------------------------------------------------------------------------------
//                  Constants
// -----------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------
const int ELEMENTS = 8;
//-----------------------------------------------

#endif

#include <iostream>
#include <algorithm>

#include "storage.h"

void bool_element_option_03(int arr_value[], int* arr_copy_value)
{
    std::copy(std::begin(arr_value + ELEMENTS), std::end(arr_value + ELEMENTS), std::begin(arr_copy_value + ELEMENTS));
    std::sort(std::rbegin(arr_copy_value + ELEMENTS), std::rend(arr_copy_value + ELEMENTS));

    for (int output = 0; output < ELEMENTS; output++)
    {
        std::cout << "copied decimals: " << arr_copy_value[output] << std::endl;
    }
}

If I take these algorithms out of the function and put them in main(), they work as they should.

Should I intentionally overload this function (so I can use algorithms in it)?

Overloading this function is not my intention. I'm not calling it multiple times with different arguments.
This function is only being called once.

Answer 1

The error text is explicit:

E0304 no instance of overloaded function "std::begin" matches the argument list

So, what are those instances? See e.g. https://en.cppreference.com/w/cpp/iterator/begin

template< class C >
constexpr auto begin( C& c ) -> decltype(c.begin());   

template< class C >
constexpr auto begin( const C& c ) -> decltype(c.begin());

Returns exactly c.begin(), which is typically an iterator to the beginning of the sequence represented by c. If C is a standard Container, this returns C::iterator when c is not const-qualified, and C::const_iterator otherwise.

template< class T, std::size_t N >
constexpr T* begin( T (&array)[N] ) noexcept;

Returns a pointer to the beginning of the array.

The last one seems promising, its argument is a reference to an array (note how it's declared) and that is the overload used here:

int main()
{
    int arr_value[ELEMENTS]{ 1, 2, 9, 4, 5, 6, 7, 8 };
    int arr_copy_value[ELEMENTS];
    
    // ...
    
    std::copy(std::begin(arr_value),       // <---
              std::end(arr_value),
              std::begin(arr_copy_value)); // <---     
    // ...
}

That's because both arr_value and arr_copy_value are arrays, there.

When the compiler reads the refactored code, on the other end, it can't find a suitable overload:

void bool_element_option_03(int arr_value[], int* arr_copy_value)
{   //                                   ^^ That's kind of misleading
    std::copy(std::begin(arr_value + ELEMENTS),
              std::end(arr_value + ELEMENTS),
              std::begin(arr_copy_value + ELEMENTS));
    // ...
}

Here, both arr_value and arr_copy_values are pointers, not arrays and there's no overload of std::begin() (and the likes) accepting a pointer in the Standard Library.

Given the call bool_element_option_03(arr_value, arr_copy_value); in main and due to array to pointer decay⁽¹⁾, they point to the respective first elements of the two arrays declared in main. They are local variables which happen to have the same name of the variables in main.

Besides, arr_value + ELEMENTS points one after the last element of the array. It's a valid pointer as long as it's not dereferenced.

You can make this function works, without changing the call site, by directly passing those pointers⁽²⁾ to the SL algorithm functions:

void bool_element_option_03(int const *arr_value, int *arr_copy_value)
{
    std::copy(arr_value, arr_value + ELEMENTS, arr_copy_value);
    std::sort(arr_copy_value, arr_copy_value + ELEMENTS, std::greater{});
    // ...
}

This can be generalized by passing the size too:

void bool_element_option_03( size_t n, int const *src, int *dest)
{ //                         ^^^^^^^^ 
  std::copy(src, src + n, dest);
  std::sort(dest, dest + n, std::greater{});
  // ...
}

To generalize a bit more, you can modify the function signature into a template accepting references of array:

template< class Type, std::size_t N>
void bool_element_option_03(Type const (&arr_value)[N], Type (&arr_copy_value)[N])
{
    std::copy(std::begin(arr_value), std::end(arr_value), 
              std::begin(arr_copy_value));
    std::sort(std::rbegin(arr_copy_value), std::rend(arr_copy_value));
    // ...
}

Which can still be called in main with bool_element_option_03(arr_value, arr_copy_value);, except that, now, there's no decay and the arrays are actually passed by reference and the correct overload of std::begin can be selected.

---

To mimic the Standard Library algorithms, we can instead pass iterators directly:

template< class SourceRandomIterator, class DestRandomIterator >
void copy_and_sort( SourceRandomIterator source_first
                  , SourceRandomIterator source_last
                  , DestRandomIterator dest_first )
{
    auto dest_last{ std::copy(source_first, source_last, dest_first) };
    std::sort(dest_first, dest_last, std::greater{});
    // ...
}

But we also have to modify the call in main:

bool_element_option_03(std::cbegin(arr_value), std::cend(arr_value), 
                       std::begin(arr_copy_value));

---

Since C++20, we can use std::span as arguments.

void bool_element_option_03(std::span<const int> arr_value,
                            std::span<int> arr_copy_value)
{
    std::copy(std::begin(arr_value), std::end(arr_value), 
              std::begin(arr_copy_value));
    std::sort(std::rbegin(arr_copy_value), std::rend(arr_copy_value));
    // ...
}

Or take advantage of the ranges library:

template< std::ranges::random_access_range SourceRange
        , std::ranges::random_access_range DestRange >
void bool_element_option_03(SourceRange const& source,
                            DestRange& dest)
{
    std::ranges::copy(source, dest);
    std::ranges::sort(dest | std::ranges::views::reverse );
    // ...
}

In both cases, this function can be called from main as bool_element_option_03(arr_value, arr_copy_value);

---

^{1) What is array to pointer decay?
2) See e.g. How are iterators and pointers related? and how std::sort is declared.}

Answer 2

thanks for your help everyone! this is what I decide to go with.

#include <iostream>
#include <algorithm>

constexpr size_t ELEMENTS{ 8 };

void show(const int(&arr)[ELEMENTS])
{
    for (const auto& c : arr)
        std::cout << c;

    std::cout << '\n';
}

void bool_element_option_03(const int(&arr_value)[ELEMENTS], int(&arr_copy_value)[ELEMENTS])
{
    std::copy(std::begin(arr_value), std::end(arr_value), std::begin(arr_copy_value));
    std::sort(std::rbegin(arr_copy_value), std::rend(arr_copy_value));
    
    std::cout << "\nReverse sorted:\n";
    show(arr_copy_value);
}

int main()
{
    const int arr_value[ELEMENTS]{ 1, 2, 9, 4, 5, 6, 7, 8 };
    int arr_copy_value[ELEMENTS]{};

    std::cout << "\nOriginal order:\n";
    show(arr_value);
    bool_element_option_03(arr_value, arr_copy_value);
}