C++98 : Provide different function implementations, 取决于成员的存在

Question

设置:有一个类classA , 和一个类 classB正在使用 classA .不幸的是，编程时classB , 不知是否classA会有某个成员someMember或不。取决于此，成员函数 someFunction在classB应以一种或另一种方式实现。因为一种方法是使用 someMember , 重要的是这个函数实例在 someMember 的情况下不被编译不是 classA 的成员.

问题:除了宏/定义，在 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

因为你的问题被标记为 templates 我假设你的 classB 实际上可以是一个类模板或者至少它可以使用一个......如果是这种情况你可以申请SFINAE例如使用以下解决方案:

#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]

---

在这种情况下(如果你使用的是 c++98)你可能会更幸运地尝试使用额外的特征，例如:

#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]