Avoiding ambiguous parameters in templated Eigen functions with MSVS

Question

I'm writing some funtions that are supposed to take Eigen::Array as an input. The Arrays are of constant size, but the size is a template parameter and should be deducted from the input. When compiling with MSVS, i have to supply the size to the function or it will result in an error.

#include <Eigen/Core>

template<unsigned short t_iSize>
void foo(const Eigen::Array<unsigned short, t_iSize, 1>&)
{

}

int main()
{
    Eigen::Array<unsigned short, 3, 1> test;
    // foo(test);    // Compiler errors C2672 and C2784
    foo<3>(test);    // Giving the size solves the errors
}

The size should be possible to be deducted from the variable test, but it seems to fail when computing the template arguments 4 and 5 for the Array.

Error C2672: "foo": no matching overloaded function found.

Error C2784: "void foo(const Eigen::Array< unsigned short,t_iSize,1,|_Rows==&&?:&&_Rows!=?:,_Rows,1> &)": could not deduce template argument for "const Eigen::Array< unsigned short,t_iSize,1,|_Rows==&&?:&&_Rows!=?:,_Rows,1> &" from "Eigen::Array< unsigned short,3,1,0,3,1>".

Is it possible to avoid this problem when taking the Eigen::Array, or do I need to take Eigen::ArrayBase as a function parameter? I would like to avoid that, as it obscures the fact that the function only takes this specific type of arrays.

Edit:

As Jarod42 noted, the template parameter should be of type int. Visual Studio can compile the code with this mistake. It fails in deducing the parameter _Rows, though, where other compilers can do so.

Here you can see the problem I ran into.

Jarod42 · Accepted Answer · 2019-10-25T13:36:06.753

2

Declaration of Eigen::Array is

template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
class Eigen::Array;

Your function uses wrong type for row, unsigned short should be int.

template <int t_iSize>
void foo(const Eigen::Array<unsigned short, t_iSize, 1>&)
{
    // ...
}

Demo

As workaround for your issue with Msvc, you might do:

apply the default value manually:

template <int t_iSize>
void bar(const Eigen::Array<unsigned short, t_iSize, 1, 0, t_iSize, 1>&) {
  // ...
}

or add the extra template (and so the code is even more generic):

template <int t_iSize, int Options, int MaxRows, int MaxCols>
void foo(const Eigen::Array<unsigned short, t_iSize, 1, Options, MaxRows, MaxCols>&) {
  // ...
}

Demo

edited Oct 25 '19 at 13:36

answered Oct 23 '19 at 11:29

Jarod42

203,559
14
181
302

Changing the template parameter from unsigned short to int doesn't make it compileable in my case – Daniel Bauer Oct 23 '19 at 15:03
Provided Demo link which show issue with old variant. (cannot reproduce on msvc though, maybe flag?) – Jarod42 Oct 23 '19 at 17:24
I linked the problem I had in my question. MSVS seems to ignore the mismatched template types, but has a problem when the template parameters depend on each other – Daniel Bauer Oct 24 '19 at 11:50
1

Then possible workaround [Demo](https://godbolt.org/z/GAhXDs) – Jarod42 Oct 24 '19 at 12:05
These two workarounds do the job perfectly. Do you want to write a complete answer? – Daniel Bauer Oct 25 '19 at 13:08
@DanielBauer: added. – Jarod42 Oct 25 '19 at 14:16

Avoiding ambiguous parameters in templated Eigen functions with MSVS

1 Answers1