Passing Functor as template parameter

Hi,

I want to parametrize the access to my 'valarray' data member with Accessor functors, so that clients of my library can use a callback to their own access function. These accessors just need to transform the row- and column-index to one overall index.

For this purpose, I have made an interface class "MatrixAccessor":

Code:

    class MatrixAccessor
    {
    public:
	virtual size_t operator()(size_t i, size_t j);
    };

with two derivations

Code:

    class C_Accessor : public MatrixAccessor // for row-oriented memory access
    {
    public:
    C_Accessor(size_t nb_rows, size_t nb_cols) : _nbrows(nb_rows), _nbcols(nb_cols) {}
	size_t operator()(size_t i, size_t j)
	{
	    return(i+j*_nbrows);
	}
    private:
	size_t _nbrows;
	size_t _nbcols;
    };

However, when I want to pass this Accessor via a template parameter, like in

Code:

    template<typename T, typename Accessor = C_Accessor>
	class Matrix
	{
	public:
          MatrixAccessor get_accessor() const {
            return this->static_cast<MatrixAccessor>(accessor);
          }
        };

I will have to specialise this parameter in ALL member functions! And that's not exactly what will make my library user-friendly.

Main problem: today's C++ standard does not allow default-specialisation of function template parameters.

As a workaround, my idea is to not store the function object as an "Accessor" (template parameter), but as a "MatrixAccessor" (interface). I now pass the accessor as argument in the constructors, with as default value a static const object which I declare in the same header as the accessor declarations. However, this does not allow the interface from being an abstract base class, which I initially wanted.

But, I do have the feeling that I'm not benefitting from static polymorphism as much as I could, and that this workaround will slow down algorithms with my library.
Has someone got a better idea, or improvements to my idea?

Thanks a lot!!!


edit:

The constructor argument will be a pointer to MatrixAccessor, of course necessary to call the correct 'operator()'. The base class can now remain a pure abstract class.

Why do you need the MatrixAccessor hierachy?

Do you mean the derivation of my accessors from "MatrixAccessor" ? Because I want to store a pointer to it in my class, while not knowing which type I will get.
This is for me the great advantage of passing the functor as template parameter, but I just don't want to specify it everywhere...

Do you mean the derivation of my accessors from "MatrixAccessor" ? Because I want to store a pointer to it in my class, while not knowing which type I will get.

If that is the case, then you should be storing an Accessor*, not a MatrixAccessor*, otherwise the Accessor template parameter is useless. get_accessor() should not return a MatrixAccessor*, much less a MatrixAccessor (which leads to type slicing), but should return an Accessor*.

Your MatrixAccessor class have operator() as a pure virtual, and it should also have a virtual destructor.

That said, I am not sure why you want to mix the run time polymorphism of the class hierarchy with the compile type polymorphism of the template parameter. std::set does something similiar by allowing a comparison function object to be provided at run time, but the type of the comparison function object is fixed at compile time.

Perhaps my explanation was not clear.

The solution of passing the functor as template parameter has my preference, since then I won't use dynamic polymorphism at all. In that case I won't store a pointer to MatrixAccessor, but an object.

But since I cannot set a default specialisation for the accessor in the template (member) functions, users will have to specialise this parameter every time they use it. And this I don't want.

So that's why I'll go back to the C-style functors: passing a pointer to a function as constructor argument and storing this pointer. Then I'll have to use dynamic polymorphism.

My question was basically: Can I use static polymorphism for the accessor but without having to specialise for all (member) functions the parameter?

The solution of passing the functor as template parameter has my preference, since then I won't use dynamic polymorphism at all. In that case I won't store a pointer to MatrixAccessor, but an object.

Right. So what's wrong with:

Code:

template<typename T, typename Accessor = C_Accessor>
class Matrix
{
public:
    // ...

    Accessor get_accessor() const
    {
        return accessor;
    }
private:
    Accessor accessor;
};

But since I cannot set a default specialisation for the accessor in the template (member) functions, users will have to specialise this parameter every time they use it.

Your users can instantiate the template with the desired accessor type, can they not?

My question was basically: Can I use static polymorphism for the accessor but without having to specialise for all (member) functions the parameter?

Yes, by instantiating the template with the desired template arguments.

Hmmm... yes my fear actually only holds for free functions or operators, but then I won't need this template parameter anyway.
Thanks!!