메서드 및 템플릿에 대한 포인터, C++

Question

2 개의 전용 멤버 a1, a2 및 b1, b2가있는 템플릿 클래스 A와 B가 2 개 있습니다.

template <typename T> 
class A 
{ 
private: 
    T a1, a2; 

public: 
    T getA1() const {return a1;} 
    T getA2() const {return a2;} 

}; 


template <typename T> 
class B 
{ 
private: 
    T b1, b2; 

public: 
    T getB1() const {return b1;} 
    T getB2() const {return b2;} 

}; 

테스트 클래스에는 getter를 가리키는 2 개의 포인터가 필요합니다.

class Test 
{ 
    private: 
    template <typename T> 
    static T (*getFirst)(); 

    template <typename T> 
    static T (*getSecond)(); 

} 


template <typename T> 
T (* Test::getFirst)() = &A<T>::getA1; //Pointer to getA1, error 

template <typename T> 
T (* Test::getSecond)() = &B<T>::getB2; //Pointer to getB2, error 

int main 
{ 
    A <double> a; 
    B <double> b; 

    double c = a.getFirst + b.getSecond; 
} 

T가 가능 전문성없이이 코드 (즉, 클래스 템플릿 멤버에 대한 포인터) 또는 그 "포인터"를 구현되어 ... 기본 데이터 타입을 나타냅니다 전문화해야 하는가? 어떤 사례를 가져 주셔서 감사합니다 ...

Answer 1

당신은 불법적 인 일을하고 있습니다.

template <typename T> 
static T (*getFirst)(); 

여기

당신이 C++에서 불법 템플릿 함수 포인터을 정의하기 위해 노력하고,이를 참조하십시오.

은 C++ 표준 템플릿이 클래스 또는 기능의 가족을 정의

$ 1분의 14을에서 말한다.

이 말하지 않을 수 있음을 양해 해 주시기 바랍니다 "는 템플릿 클래스, 기능또는 함수 포인터의 가족을 정의합니다." 그래서 당신이하려는 것은 "함수 포인터 계열" 템플릿을 사용하는 것을 허용하지 않는다는 것입니다.

---

당신이 이런 일을 할 수있는 포인터를 작동하려면

,

template <class T> 
struct A 
{ 
    static T (*FunctionPointer)(); //function pointer 
}; 

struct B 
{ 
    template <class T> 
    static T Function(); //static function, not function pointer 
}; 

int (*A<double>::FunctionPointer)() = &B::Function<double>; 

그러나 더 나은 대안은 다음과 같습니다 function object를 사용합니다. :-)

Answer 2

간단히 말해서 불가능합니다.

먼저 템플릿 함수에 대한 포인터를 선언 할 수없고 구체적인 함수에 대한 포인터 만 선언 할 수 있습니다. 둘째, 포인터를 자유 함수로 선언하려했지만 A::getA1은 암시적인 this 인수가있는 멤버 함수이므로 의미가 일치하지 않습니다.

이 같은 수행 할 수 있습니다

template <typename T> 
struct A 
{ 
    static T get() { return T() }; 
}; 

template <typename T> 
struct Holder 
{ 
    typedef T(A<T>::*F_ptr)(); 
    static F_ptr f_ptr; 
}; 


template <typename T> 
typename Holder<T>::F_ptr Holder<T>::f_ptr = &A<T>::get; 

템플릿 클래스의 구성원으로 템플릿 함수에 포인터를 유지하기를

Answer 3

라인 : 하나는 :

template <typename T> 
T (*Test::getFirst)() = &A<T>::getA1; //Pointer to getA1, error 

두 가지 문제를 가지고 그 &A<T>::getA1은 T (A::*)()const이지만 getFirst는 T (*)()입니다. 이전 함수는 멤버 함수에 대한 포인터이기 때문에 호환되지 않습니다.

두 번째 문제점은 생성 된 개체가 반환 형식에서만 다를 수 있다는 것입니다. double (A::*getFirst)()const과 char (A::*getFirst)()const을 수동으로 선언 할 수없는 것처럼 자동으로 선언 할 템플릿도 만들 수 없습니다.

라인 :

double c = a.getFirst + b.getSecond;

이 나 손에 문제에 관련되지 않을 수 있습니다 문제의 그것의 자신의 세트가있다.

죄송합니다. "답변이 없습니다." 어쩌면 당신이 성취하려고하는 것이 라기보다는 당신이 성취하고자하는 것에 대해 더 많이 이야기한다면, 우리는 도울 수있을 것입니다.

Answer 4

코드가 매우 혼란스러워서, 내가 무엇을 요구하고 있는지 정말로 이해할 수 있을지 모르겠다. 여기에 컴파일 된 예제를 적용했다.

// This is one template class A with two getters 
template <typename T> 
class A 
{ 
private: 
    T a1, a2; 

public: 
    T getA1() const {return a1;} 
    T getA2() const {return a2;} 
}; 

// This is another unrelated template class, with two other getters 
template <typename T> 
class B 
{ 
private: 
    T b1, b2; 

public: 
    T getB1() const {return b1;} 
    T getB2() const {return b2;} 
}; 

// These are declarations of generic "getFirst" and "getSecond" 
template<typename T1, typename T2> 
T1 getFirst(const T2& t); 

template<class T1, class T2> 
T1 getSecond(const T2& t); 

// Here I'm specializing getFirst/getSecond for the A template 
template<class X> 
double getFirst(const A<X>& a) { return a.getA1(); } 

template<class X> 
double getSecond(const A<X>& a) { return a.getA2(); } 

// Here I'm doing the same for the B template 
template<class X> 
double getFirst(const B<X>& b) { return b.getB1(); } 

template<class X> 
double getSecond(const B<X>& b) { return b.getB2(); } 

// Now I can use getFirst/getSecond with either A or B 
int main(int argc, const char *argv[]) 
{ 
    A<double> a; 
    B<double> b; 
    double c = getFirst(a) + getSecond(b); 
    return 0; 
}