C++ 在编译时将字符串转换为大写

是否可以在编译时将字符串转换为大写而不受大小限制

例如：

将产生：

char* myString = "A BIG STRING HERE!";

这是可能的，使用和C++14

#include <iostream>
#include <boost/hana/unpack.hpp>
#include <boost/hana/string.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/value.hpp>
#include <boost/hana/core/to.hpp>

constexpr char to_upper(char c) noexcept
{
    switch(c) {
    default: return c;
    case 'b': return 'B';
    case 'i': return 'I';
    case 'g': return 'G';
    case 's': return 'S';
    case 't': return 'T';
    case 'r': return 'R';
    case 'n': return 'N';
    // The other characters in the alphabet.
    }
}

auto to_upper_str = [](auto hana_str) noexcept {
    return boost::hana::unpack(hana_str, [](auto... chars) noexcept {
        return boost::hana::string_c<
            boost::hana::char_c<to_upper(boost::hana::value(chars))>...>;
    });
};

int main()
{
    auto str = to_upper_str(BOOST_HANA_STRING("Big string."));
    std::cout << boost::hana::to<const char*>(str) << '\n';
}

#包括
#包括
#包括
#包括
#包括
#包括
constexpr char to_upper（char c）无例外
{
开关（c）{
默认值：返回c；
案例“b”：返回“b”；
案例“i”：返回“i”；
案例“g”：返回“g”；
案例“s”：返回“s”；
案例“t”：返回“t”；
案例'r'：返回'r'；
案例“n”：返回“n”；
//字母表中的其他字符。
}
}
自动到上层结构=[]（自动hana结构）无例外{
返回boost:：hana:：unpack（hana_str，[]（自动…字符）无例外{
返回boost:：hana:：string\u c<
boost:：hana:：char_c…>；
});
};
int main（）
{
auto str=to_upper_str（BOOST_HANA_STRING（“大字符串”））；
std:：cout只要您不尝试将字符串链直接传递给模板，并且您创建了helper变量来存储此序列，以便进一步进行大写，您就可以使用此代码（c++1z）：

#包括
#包括
#包括
#包括
模板
结构字符串长度；
模板
结构字符串长度{
静态constexpr std:：size\u t value=N；
};
模板
结构字符串\u文本；
模板
结构字符串{
静态constexpr std:：size\u t size=string\u literal\u length:：value；
静态constexpr字符值[string_literal_length:：value]={STR[Is]…}；
};
constexpr char str[]=“abc”；
模板
结构字符串\u文本\u到\u上限；
模板
结构字符串\u文字\u到\u上限{
静态conExpRchar值[SL::Stase] = {（（SL::Valu[i]）=‘a’& & SL:：‘值’是不可能的。这是不可能的。你在研究什么？模板模板编程。实际上我发现C++确实是可能的。当我设法做的时候，我会发布一个答案。注意，类型应该是代码> char const [n]。
，而不是
char*
。或者至少是
char const*
。或者可能是一个C++11字符串文字。值得注意的是，根据
BOOST\u HANA\u string
的规定，字符串不能在未计算的上下文中使用，这使得它在传递模板参数的值时不太有用。是否可以使用constepr函数来声明助手变量，使用模板，然后返回变量的
：：值
？这样我就可以轻松地将
写入大写（）
macro。我已经尝试过了，但仍然不习惯参数逻辑。此外，在Visual Studio 2015 update 3中，我遇到了以下错误：
error C2754'string\u literal'：部分专门化不能有依赖的非类型模板参数
。
#include <iostream>
#include <boost/hana/unpack.hpp>
#include <boost/hana/string.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/value.hpp>
#include <boost/hana/core/to.hpp>

constexpr char to_upper(char c) noexcept
{
    switch(c) {
    default: return c;
    case 'b': return 'B';
    case 'i': return 'I';
    case 'g': return 'G';
    case 's': return 'S';
    case 't': return 'T';
    case 'r': return 'R';
    case 'n': return 'N';
    // The other characters in the alphabet.
    }
}

auto to_upper_str = [](auto hana_str) noexcept {
    return boost::hana::unpack(hana_str, [](auto... chars) noexcept {
        return boost::hana::string_c<
            boost::hana::char_c<to_upper(boost::hana::value(chars))>...>;
    });
};

int main()
{
    auto str = to_upper_str(BOOST_HANA_STRING("Big string."));
    std::cout << boost::hana::to<const char*>(str) << '\n';
}

#include <utility>
#include <iostream>
#include <type_traits>
#include <typeinfo>

template <class T>
struct string_literal_length;

template <std::size_t N>
struct string_literal_length<char const[N]>{
    static constexpr std::size_t value = N;
};

template <class STR_T, STR_T &, class = std::make_index_sequence<string_literal_length<STR_T>::value>>
struct string_literal;

template <class STR_T, STR_T &STR, std::size_t... Is>
struct string_literal<STR_T, STR, std::index_sequence<Is...>> {
    static constexpr std::size_t size = string_literal_length<STR_T>::value;
    static constexpr char value[string_literal_length<STR_T>::value] = {STR[Is]...};
};

constexpr char str[] = "abc";

template <class SL, class = std::make_index_sequence<SL::size>>
struct string_literal_to_upper;

template <class SL, std::size_t... Is>
struct string_literal_to_upper<SL, std::index_sequence<Is...>>{
    static constexpr char value[SL::size] = { ((SL::value[Is] >= 'a' && SL::value[Is] <= 'z')?(static_cast<char>(SL::value[Is] - 'a' + 'A')):(SL::value[Is]))...};
};

int main() {
    std::cout << string_literal_to_upper<string_literal<decltype(str), str>>::value << std::endl;
}

#include <utility>
#include <iostream>
#include <type_traits>
#include <typeinfo>

template <class T>
struct string_literal_length;

template <std::size_t N>
struct string_literal_length<char const[N]>{
    static constexpr std::size_t value = N;
};

template <class STR_T, STR_T *, class = std::make_index_sequence<string_literal_length<STR_T>::value>>
struct string_literal;

template <class STR_T, STR_T *STR, std::size_t... Is>
struct string_literal<STR_T, STR, std::index_sequence<Is...>> {
    static constexpr std::size_t size = string_literal_length<STR_T>::value;
    static constexpr char value[string_literal_length<STR_T>::value] = { (*STR)[Is]...};
};

struct Literal {
   static constexpr char const str[] = "abc";
};

template <class SL, class = std::make_index_sequence<SL::size>>
struct string_literal_to_upper;

template <class SL, std::size_t... Is>
struct string_literal_to_upper<SL, std::index_sequence<Is...>>{
    static constexpr char value[SL::size] = { ((SL::value[Is] >= 'a' && SL::value[Is] <= 'z')?(static_cast<char>(SL::value[Is] - 'a' + 'A')):(SL::value[Is]))...};
};

int main() {
    std::cout << string_literal_to_upper<string_literal<decltype(Literal::str), &Literal::str>>::value << std::endl;
}