std::array as a parameter in virtual function

Question

I want to send std::array as a parameter to my virtual function

class Handler:
    {
    public:
        template <std::size_t N>
        virtual void handle(const std::array<char, N>& msg, std::vector<boost::asio::const_buffer>& buffers) = 0;
    };

but gcc said templates may not be 'virtual'. So how i pass a std::array to my function?

by fixing the size of the array (i.e. not having it as a template parameter). If you need variable sized arrays you can use vectors instead. — 463035818_is_not_an_ai, Apr 27 '15 at 12:47
[use something like this](http://stackoverflow.com/a/29009821/1774667). Arrays are for storage, no need to store parameters. — Yakk - Adam Nevraumont, Apr 27 '15 at 12:53

score 5 · Answer 1 · edited May 23 '17 at 11:58

A member function template may not be virtual. See this question.

However, you can make a virtual member function takes a std::array of specific size by moving the N out to the Handler:

template <size_t N>
class Handler:
{
public:
    virtual void handle(const std::array<char, N>& msg,
        std::vector<boost::asio::const_buffer>& buffers) = 0;
};

Or simply passing a vector<char>, which given the context, could make more sense:

class Handler:
{
public:
    virtual void handle(const std::vector<char>& msg,
        std::vector<boost::asio::const_buffer>& buffers) = 0;
};

score 2 · Answer 2 · answered Apr 27 '15 at 13:06

One possible solution is to make a member function template that accepts std::array and forwards it to your virtual member function in such a way that the size of the array is passed as a normal function argument rather than a non-type template argument. An illustration:

virtual void handle(const char* arr, std::size_t sz, std::vector<boost::asio::const_buffer>& buffers) = 0;

template <std::size_t sz>
void handle(const std::array<char, sz>& arr, std::vector<boost::asio::const_buffer>& buffers) {
  handle(sz ? &arr[0] : nullptr, sz, buffers);
}

score 0 · Answer 3 · answered Apr 27 '15 at 12:58

(simplistic) explanation:

A virtual function works because each class maintains a table of addresses of the virtual functions for that class.
A template function (or method) is not code, it's instructions on how to generate code.

so this:

template <std::size_t N>
void handle(const std::array<char, N>& msg, std::vector<boost::asio::const_buffer>& buffers)
{
   // stuff that looks like code
}

does not define a method. It tells the compiler how to write a different method (function) for each and any value of N.

in which case:

template <>
void handle(const std::array<char, 10>& msg, std::vector<boost::asio::const_buffer>& buffers)

and

template <>
void handle(const std::array<char, 20>& msg, std::vector<boost::asio::const_buffer>& buffers)

are actually different functions (that happen to behave similarly). Because they are different functions, they will occupy different addresses.

Therefore in order for them to be virtual, there must be 2 entries in the virtual function table.

This, for example, would work:

class Handler:
    {
    public:
        virtual void handle(const std::array<char, 10>& msg, std::vector<boost::asio::const_buffer>& buffers) = 0;

        virtual void handle(const std::array<char, 20>& msg, std::vector<boost::asio::const_buffer>& buffers) = 0;

        // and so on for every value on N you need.
    };

std::array as a parameter in virtual function

3 Answers3

Linked