C++ 98: Fournir différentes implémentations de fonction, en fonction de l'existance d'un membre

Question

Configuration: Il y a une classe classA, et une classe classB qui utilise classA. Malheureusement, lors de la programmation classB, je ne sais pas si classA aura un certain membre someMember ou non. En fonction de cela, une fonction membre someFunction dans classB doit être implémentée soit dans l'un ou l'autre sens. Comme l'one-way utilise someMember, il est important que cette instance de fonction n'est pas compilée dans le cas someMember n'est pas un membre de classA.

Question: En dehors des macros/définit, quelle est la meilleure solution pour cela en C++ 98?

MWE:

class classA 
{ 
public: 
    // c'tor 
    classA() 
    { 
     //someMember = 3; 
    }; 
    // does not have the member "someMember" 
    //int someMember; 
}; 

class classB 
{ 
public: 
    // only compile this function if "someMember" is a member of classB 
    int someFunction(classA a) 
    { 
     return a.someMember; 
    } 
    // ...and compile this one otherwise 
    int someFunction(classA a) 
    { 
     return 2; 
    } 
}; 

// --- just to have an MWE: --- 
#include<iostream> 
int main() 
{ 
    classA a; 
    classB b; 
    cout << b.someFunction(a); 
    return 0; 
} 

Answer 1

Comme votre question est taggés templates Je suppose que votre classB peut effectivement être un modèle de classe ou au moins il peut utiliser un ... Si tel est le cas, vous pouvez appliquer SFINAE par exemple en utilisant la solution suivante:

#include <iostream> 
#include <type_traits> 

class classA 
{ 
public: 
    // c'tor 
    classA() 
    { 
     someMember = 3; 
    }; 
    // does not have the member "someMember" 
    int someMember; 
}; 

template<class T, class = void> 
class classB_impl 
{ 
public: 
    // ...and compile this one otherwise 
    int someFunction(T) 
    { 
     return 2; 
    } 
}; 

template <class T> 
class classB_impl<T, decltype(std::declval<T>().someMember, void())> { 
public: 
    // only compile this function if "someMember" is a member of classB 
    int someFunction(T a) 
    { 
     return a.someMember; 
    } 
}; 

using classB = classB_impl<classA>; 

int main() { 
    classB b; 
    std::cout << b.someFunction(classA{}) << std::endl; 
} 

[live demo]

---

Dans ce cas (si vous utilisez C++ 98), vous pouvez obtenir plus de chance d'essayer d'utiliser trait supplémentaire par exemple:

#include <iostream> 

class classA 
{ 
public: 
    // c'tor 
    classA() 
    { 
     someMember = 3; 
    }; 
    // does not have the member "someMember" 
    int someMember; 
}; 

template <class T, int T::*V = &T::someMember> 
struct someMemberTrait { 
    typedef void type; 
}; 

template<class T, class = void> 
class classB_impl 
{ 
public: 
    // ...and compile this one otherwise 
    int someFunction(T) 
    { 
     return 2; 
    } 
}; 

template <class T> 
class classB_impl<T, typename someMemberTrait<T>::type> { 
public: 
    // only compile this function if "someMember" is a member of classB 
    int someFunction(T a) 
    { 
     return a.someMember; 
    } 
}; 

typedef classB_impl<classA> classB; 

int main() { 
    classB b; 
    std::cout << b.someFunction(classA()) << std::endl; 
} 

[live demo]