Início / coding / Perguntas / 79569560
Accepted
bers
Asked: 2025-04-12 03:03:24 +0800 CST

Por que não posso especializar std::formatter dentro do meu namespace?

  • 772

Quero me especializar std::formatterdentro do meu namespace. No entanto, isso não funciona como eu gostaria (variante 1). Funciona fora do namespace (variante 3), bem como com uma solução alternativa dentro do namespace (variante 2).

#include <format>
#include <iostream>
#include <string>
#include <type_traits>

class Class {};

#define VARIANT 1

namespace Namespace {

#if VARIANT == 1
template <>
struct std::formatter<Class> : std::formatter<std::string> {
    auto format(const Class& Class, auto& context) const {
        return std::formatter<std::string>::format("CLASS", context);
    }
};
#endif

#if VARIANT == 2
template <typename T>
    requires std::same_as<T, Class>
struct std::formatter<T> : std::formatter<std::string> {
    auto format(const Class& Class, auto& context) const {
        return std::formatter<std::string>::format("CLASS", context);
    }
};
#endif

}  // namespace Namespace

#if VARIANT == 3
template <>
struct std::formatter<Class> : std::formatter<std::string> {
    auto format(const Class& Class, auto& context) const {
        return std::formatter<std::string>::format("CLASS", context);
    }
};
#endif

int main() { std::cout << std::format("{}", Class()) << std::endl; }

Isto está no x64 msvc v19.40 VS17.10. gcc compila apenas a variante 3.

Então, minhas perguntas são: quais são as formas portáteis e em conformidade com os padrões de especialização std::formatterdentro de namespaces (ou em geral)?

c++

1 respostas

  1. Best Answer

    Então, minhas perguntas são: quais são as formas portáteis e em conformidade com os padrões de especialização std::formatterdentro de namespaces (ou em geral)?

    Não há nenhuma.

    Você só pode especializar um modelo de classe em locais onde possa definir o modelo primário. Ou seja, você precisa fazer o seguinte (no escopo global):

    template <>
struct std::formatter<MyClass> { ... };

    Ou você faz isso (dentro de std):

    namespace std {
    template <>
    struct formatter<MyClass> { ... };
}

    Mas você não pode fazer isso ou algo parecido:

    namespace N {
    template <>
    struct ::std::formatter<MyClass> { ... };
}

    De forma mais geral, dado algo como:

    namespace N::M {
    template <class T> struct C;
}

    Todas estas opções estão corretas:

                     template <> struct N::M::C<int> { };   // ok
namespace N    { template <> struct M::C<double> { }; } // ok
namespace N::M { template <> struct C<float> { }; }     // ok

N::M::C<int> a;     // ok
N::M::C<double> b;  // ok
N::M::C<float> c;   // ok

    Mas não em nenhum outro lugar.

    • 6

relate perguntas