完全可以将std::is_enum与未命名的枚举一起使用。
在当前的实现中，只有两个问题需要解决：

• std::is_enum<C::c1>::value-C::c1是数据成员，但std::is_enum需要类型模板参数。

=>这里需要使用decltype(...)，例如std::is_enum<decltype(C::c1)>::value

• 如果C没有名为c1的成员，则C::c1将导致替换失败。

解决这个问题的唯一方法是在替换失败不会导致程序格式不正确的情况下执行此操作。
因此，您可以使用SFINAE或（如果C20可用）requires-expression。
在C20中，这是可行的：
godbolt example

template<class T>
concept is_enum_value = std::is_enum_v<T>;

template<class C>
struct C3 {
    void foo() {
        if constexpr(requires { { C::c1 } -> is_enum_value; }) {
            do_this();
        }
        if constexpr(requires { { C::c2 } -> is_enum_value; }) {
            do_that();
        }
    }

    // ...
};

如果C::c1和C::c2互斥（即每个类C都有c1或c2，或者两者都没有-但永远不会同时有c1和c2），您可以考虑使用尾随的requires-clauses来重载foo。
godbolt example

template<class C>
struct C3 {
    void foo() requires requires { { C::c1 } -> is_enum_value; } {
        // do_this implementation
    }
    void foo() requires requires { { C::c2 } -> is_enum_value; } {
        // do_that implementation
    }
};

如果C++20不可用，则需要使用SFINAE，这有点麻烦：
godbolt example

template<class T, class = void>
constexpr bool has_c1 = false;
template<class T>
constexpr bool has_c1<T, std::enable_if_t<std::is_enum_v<decltype(T::c1)>>> = true;

template<class T, class = void>
constexpr bool has_c2 = false;
template<class T>
constexpr bool has_c2<T, std::enable_if_t<std::is_enum_v<decltype(T::c2)>>> = true; 

template<class C>
struct C3 {
    void foo() {
        if constexpr(has_c1<C>) {
            do_this();
        }
        if constexpr(has_c2<C>) {
            do_that();
        }
    }

    // ...
};

C++11使用SFINAE

您可以使用decltype获取与c1和c2关联的类型，然后使用 SFINAE，如下所示。C++11 Demo：

struct C1{
    enum{
        c1 = 3
    };
};

struct C2{
    enum{
        c2 = 10
    };
};

template<class C>
class C3{
    void do_this(){std::cout << "do this called" << std::endl;}
    void do_that(){std::cout << "do that called " << std::endl;}
public:
    //overload for calling do_this
    template<typename T = C,typename std::enable_if<std::is_same<T, C1>::value, bool>::type = std::is_enum<decltype(T::c1)>::value >void foo()
    {
        do_this();
    }
    //overload for calling do_that
    template<typename T = C,typename std::enable_if<std::is_same<T, C2>::value, bool>::type = std::is_enum<decltype(T::c2)>::value >void foo()
    {
        do_that();
    }
    //overload when none of the conditions are satisfied
    template<typename... T>
    void foo(T...)
    {
        std::cout <<"ellipsis called " << std::endl;
    }
     
};
int main()
{
    C3<C1> c1;
    c1.foo();     //calls do_this() using #1

    C3<C2> c2;
    c2.foo();     //calls do_that() using #2

    C3<int> c3;
    c3.foo();    //calls the ellipsis version
    
}

另请参阅使用std::enable_if_t、std::is_same_v和std::is_enum_v的C++ 17 demo版本。

C++20使用概念

struct C1{
    enum{
        c1 = 3
    };
};
template<typename T>
concept enumC1 = std::is_same_v<T, C1>;

struct C2{
    enum{
        c2 = 10
    };
};
template<typename T>
concept enumC2 = std::is_same_v<T, C2>;

template<class C>
class C3{
    void do_this(){std::cout << "do this called" << std::endl;}
    void do_that(){std::cout << "do that called " << std::endl;}
public:
    //overload when none of the conditions are satisfied
    template<typename T = C>
    void foo()
    {
        std::cout <<"general called " << std::endl;
    }
    //overload for calling do_this
    template<enumC1 T = C>void foo()
    {
        do_this();
    }
    //overload for calling do_that
    template<enumC2 T = C>void foo()
    {
        do_that();
    }
    
     
};
int main()
{
    C3<C1> c1;
    c1.foo();     //calls do_this()

    C3<C2> c2;
    c2.foo();     //calls do_that()

    C3<int> c3;
    c3.foo();    //calls the general version
    
}

C++ 20 demo

你可能应该给它们起相同的名字，这样模板就可以同时使用它们：

#include <cstdio>
#include <type_traits>

struct C1 {
    enum { c = 3 };
};

struct C2 {
    static constexpr int c = 10;
};

template <class C>
void foo() {
    if constexpr (std::is_enum_v<decltype(C::c)>) {
        std::puts("::c is an enum");
    } else {
        std::puts("::c is not an enum");
    }
}

int main() {
    foo<C1>();
    foo<C2>();
}

也有很好的答案，但我会给予C++20的另一个变体：

if constexpr(requires { requires std::is_enum_v<decltype((C::c1))>; }) { /*...*/ }

这使用了一个嵌套的需求，而不是像@Turtlefight的答案中那样使用了一个带有类型约束的复合需求。如果替换到表达式中导致无效的类型或表达式，则嵌套要求失败，如果表达式不是计算为true的bool类型的常量表达式，则嵌套要求也失败。但这在功能上应该是相同的。
decltype中的附加括号是必要的，另一个答案中使用的复合语句也隐含地使用decltype来确定表达式的类型。
如果没有它，decltype将为枚举类型的数据成员（而不是枚举器的名称）生成非引用类型并成功，例如。

class C2{
    static enum {
        c2 = 10
    } c1;
}

将成功进行c1和c2的测试，而不是仅成功进行c2的测试。