함수 템플릿과 오버로드가 섞여 있습니다.

Question

그래서 텍스트 파일의 데이터를 다양한 행렬로 읽는 함수를 만들고 싶습니다.
첫 번째 요소는 괄호로 요소에 액세스하는 Eigen 행렬입니다.
예. mat(1,2). 두 번째 유형은 vector<vector<T>입니다. T은 int, double 등이 될 수 있습니다. 분명히 대괄호로 액세스합니다.

이제 두 상황에 대한 템플릿을 만들어야합니다. Eigen에는 많은 행렬 유형 (MatrixXd, SparseMatrix 등)이 있으며 vector<vector<T>>에는 많은 유형이 있습니다. T.

그러나 Eigen에 대한 템플릿 기능이 실제로 호출되지 않도록하려면 어떻게해야합니까? vector<vector<T>>에 대한 템플릿 기능은 무엇입니까?

과부하가 템플릿보다 우선한다는 것을 알고 있지만 둘 다 템플릿입니다!
어떻게해야합니까?

Answer 1

과 같이 중첩 된 벡터 케이스에 대한 부분 전문화 * 및 다양한 아이겐 클래스에 대한 일반적인 경우, 뭔가를 사용

template <typename T> 
void foo(vector<vector<T>>& mat) { 
    // code that uses mat[x][y] 
} 

template <typename T> 
void foo(T& mat) { 
    // code that uses mat(x,y) 
} 

(* 네,의 pedants는 지적 알고 기술적으로 말하자면, 이것은 당신이 C++ 11 솔루션을 수용 할 수있는 경우

Answer 2

가, 사용에 대한 SFINAE 검사 어떤 유형 T이 T()(0U, 0U) 또는 T()[0U][0U]을 지원할 수있는 경우 "부분 특수화"하지만 "일부 주문 함수 오버로드".) 아닌가요?

T이 두 가지 작업을 모두 지원하지 않는 경우이 방법이 작동합니다.

다음 당신을 줄 수있는 작업 예 (bar 대체 Eigen)

#include <vector> 
#include <iostream> 

template <typename T> 
auto foo (T & mat) -> decltype(mat[0U][0U], int()) 
{ return 1; } 

template <typename T> 
auto foo (T & mat) -> decltype(mat(0U, 0U), int()) 
{ return 2; } 

struct bar 
{ 
    void operator() (std::size_t x, std::size_t y) 
    { } 
}; 

int main() 
{ 
    std::vector<std::vector<int>> m1; 
    bar       m2; 

    std::cout << foo(m1) << std::endl; // print 1 
    std::cout << foo(m2) << std::endl; // print 2 
} 

둘 다 [0U][0U] 및 (0U, 0U)이 (다음 예제 baz 참조)을 지원하는 템플릿 클래스로 작업해야하는 경우입니다 우선 하나 개의 버전 또는 또 다른 바람직한 버전에서 int 다른 버전에서 long (예 :로)를 int 값을 전달하고 수신하는

S

예를 들어

#include <vector> 
#include <iostream> 

template <typename T> 
auto foo (T & mat, long) -> decltype(mat[0U][0U], int()) 
{ return 1; } 

template <typename T> 
auto foo (T & mat, int) -> decltype(mat(0U, 0U), int()) 
{ return 2; } 

template <typename T> 
int foo (T & mat) 
{ return foo(mat, 0); } 


struct bar 
{ 
    void operator() (std::size_t x, std::size_t y) 
    { } 
}; 

struct baz 
{ 
    std::vector<std::vector<int>> m; 

    std::vector<int> & operator[] (std::size_t x) 
    { return m[x]; } 

    int & operator() (std::size_t x, std::size_t y) 
    { return m[x][y]; } 
}; 

int main() 
{ 
    std::vector<std::vector<int>> m1; 
    bar       m2; 
    baz       m3; 

    std::cout << foo(m1) << std::endl; // print 1 
    std::cout << foo(m2) << std::endl; // print 2 
    std::cout << foo(m3) << std::endl; // print 2 
}