Question

是否可以覆盖std::local上的多个方面？

例如，采取一个相当人为的例子：

#include <locale>

class NumberFacet : public std::numpunct<char>
{
protected:
    char do_decimal_point() const override
    {
        return '.';
    }

    char do_thousands_sep() const override
    {
        return ',';
    }
};

class MoneyFacet : public std::moneypunct<char>
{
protected:
    char do_decimal_point() const override
    {
        return '.';
    }

    char do_thousands_sep() const override
    {
        return ',';
    }
};

我知道我可以覆盖std::locale这样的一个方面来创建一个新的locale变量。

std::locale locale(std::locale(), new NumberFacet());

我如何通过MoneyFacet？

我必须这样做似乎不能令人满意：

std::locale locale(std::locale(std::locale(), new NumberFacet()), new MoneyFacet());

有更好的方法吗？

Answer 1

IOStreams库没有为您提供更好的编写方式，但您可以利用递归来完成工作。由于补充新的语言环境总是涉及从旧语言环境进行复制，因此您可以不断递归以使用提供的方面构建新的语言环境。

template<class...>struct types{constexpr types(){}};
template<class...Ts>constexpr types<Ts...> types_t{};

template<class L, class F>
L makeloc(L loc, types<F>, int) {
    return std::locale(loc, new F{});
}

template<class L, class F, class... Fs>
L makeloc(L loc, types<F, Fs...>, long) {
    return makeloc(std::locale(loc, new F{}), types_t<Fs...>, 0);
}

template<class S, class L, class... Fs>
void imbue(S& s, L loc, types<Fs...> facets) {
    s.imbue(makeloc(loc, facets, 0));
}

int main() {
    imbue(std::cout, std::locale(), types_t<MoneyFacet, NumberFacet /*, ... */>);
}

Answer 2

operator<<()符合这种情况：

#include <locale>
template <typename T,                                                                                                                                                                                                                                                         
    typename = std::enable_if_t<                                                                                                                                                                                                                                              
        std::is_constructible<std::locale, std::locale, T*>::value                                                                                                                                                                                                            
    >                                                                                                                                                                                                                                                                         
>                                                                                                                                                                                                                                                                             
std::locale operator<<(const std::locale& locale, T* facet)                                                                                                                                                                                                                   
{                                                                                                                                                                                                                                                                             
    return {locale, facet};                                                                                                                                                                                                                                                   
}

int main()
{
    auto locale = std::locale{} << new MoneyFacet{} << new NumberFacet{};
    std::cout.imbue(locale);
    std::cout << 12345.67f << '\n';
    std::cout << 123456789u << '\n';
}

Demo

覆盖std :: locale上的多个方面

2 个答案: