Question

我有一个名称空间,通过我的申请,加上相关的印刷声明,创造了一系列的词汇。

namespace NS {
    enum EnumA { A1, A2, A3 };
    enum EnumB { B1, B2, B3 };

    inline std::string toString(const EnumA key) {
        switch(key) {
        case A1: return "A1";
        case A2: return "A2";
        case A3: return "A3";
        }
        return "UNKNOWN";
    }

    // .. same for EnumB
}

// this is the part I would like to templatize
inline std::ostream& operator<<(std::ostream& s, const NS::EnumA key) {
    s << NS::toString(key);
    return s;
}
inline std::ostream& operator<<(std::ostream& s, const NS::EnumB key) {
    s << NS::toString(key);
    return s;
}

有可能使下游经营者与任何<代码>NS合作我只得这样说? 和:

template <typename T>
inline std::ostream& operator<<(std::ostream& s, const NS::<T> key) {
    s << NS::toString(key);
    return s;
}

Answer 1

如果名称空间中的唯一东西(NS)属于可计量的类型,你可将operator<<列入名称空间,因此:

namespace NS {
  enum EnumA { A1, A2, A3 };
  enum EnumB { B1, B2, B3 };

  inline std::string toString(const EnumA key) {
    ...
  }
  inline std::string toString(const EnumB key) {
    ...
  }

  template <typename T>
  inline std::ostream& operator<<(std::ostream& s, const T key) {
    std::operator << (s, NS::toString(key));
    return s;
  }

}

A complete program is here.

Answer 2

The obvious approach will result in your overload being considered for all types; this will result in calls being ambiguous for all types, since templates are not choosy. So you need some way to tell the compiler that your enum is the right type of enum, and to ignore all the rest; a traits class is probably the easiest way to do that.

namespace NS {
  enum EnumA { };

  template<typename T>
  struct is_ns_enum : std::false_type { };

  template<>
  struct is_ns_enum<EnumA> : std::true_type { };
}

From there, you can use SFINAE to implement your function.

template<typename T>
inline typename std::enable_if<is_ns_enum<T>::value, std::ostream&>::type
operator <<(std::ostream& s, const T&) {
  ...
}

这样,如果你专门使用<代码>is_ns_enum,则考虑超载,但被弃置于其他所有类型,从而防止这种高压错误。

Answer 3

如果您对流层类型也有所节制,这将发挥作用:

#include <string>
#include <iostream>
using namespace std;

namespace NS {
    enum EnumA { A1, A2, A3 };
    enum EnumB { B1, B2, B3 };

inline std::string toString(const EnumA key) {
        switch(key) {
        case A1: return "A1";
        case A2: return "A2";
        case A3: return "A3";
        }
        return "UNKNOWN";
    }

inline std::string toString(const EnumB key) {
        switch(key) {
        case B1: return "B1";
        case B2: return "B2";
        case B3: return "B3";
        }
        return "UNKNOWN";
    }
};

template <class Stream, typename T>
inline std::ostream& operator<<(Stream& s, T key) {
    s << NS::toString(key);
    return s;
}

int main()
{
    cout << NS::A2;
    cout << NS::B3;
}

友情链接