c++ - 缩进感知原始字符串文字

Question

有没有办法让原始字符串文字知道缩进？

例如

{
    std::string_view str(
    R"(
       Hello
           World
    )");
    std::cout << "ref\n" << str;
}

打印

ref

       Hello
           World
    

但我愿意

ref
Hello
    World

我看到 this answer解决了这个问题，但它是运行时。对于 c23，我认为 #embed 可能会解决这个问题。

但是有没有办法在编译时做到这一点，最好是使用 c++17，c++20 也可以。

Answer 1

tl;博士

• 可以在 C++20 中用 user-defined literal operator 做到这一点.
  示例:godbolt

  std::cout << R"(
      Hello
          World
  )"_M << std::endl;
  

• 理论上也可以在 C++17 中执行此操作，但语法不会那么好:

  constexpr auto str = unindent(R"(
      Hello
          World!
  )"); // type of str would be std::array<char, N>
  std::cout << str.data() << std::endl;
  

---

1。为什么 C++17 实现不是最优的

在这种情况下，C++17 的最大问题是我们需要修改字符串(删除其中的空格)- 因此我们需要将修改后的字符串存储在某处。

在 C++20 中，我们可以使用 string literal operator template 获取字符串作为模板参数。 ，例如:

template<class _char_type, std::size_t size>
struct string_wrapper {
    using char_type = _char_type;

    consteval string_wrapper(const char_type (&arr)[size]) {
        std::ranges::copy(arr, str);
    }

    char_type str[size];
};

template<string_wrapper str>
consteval decltype(auto) operator"" _M() {
    return do_unindent<str>();
}

// R"(foo)"_M
// would be interpreted as:
// operator"" _M<string_wrapper{R"(foo)"}>() 

这允许我们将未缩进的字符串存储在模板参数中，因此它的生命周期永远不会成为问题；我们可以直接返回对存储在模板参数中的数组的引用。

另一方面，在 C++17 中，我们不能将类类型作为模板参数，字符串文字运算符模板也不可用。所以没有巧妙的方法来全局存储修改后的字符串(常量表达式中不允许使用 static 变量，所以这不是一个选项)

所以在 C++17 中实现它的唯一方法是返回一个 std::array。 (或类似的东西):

template<std::size_t size>
constexpr auto unindent(const char (&str)[size]) {
    return std::array<char, size>{ /* ... */ };
}

然而，这有一些主要缺点:

• 你总是要调用.data()转换 std::array回到const char* :

  std::cout << unindent(R"(foo)").data() << std::endl;
  

• 你必须小心保持std::array活:

  // BAD: Woops: dangling pointer!
  const char* str = unindent(R"(foo)").data();
  
  // GOOD: keep array alive
  auto arr = unindent(R"(foo)");
  const char* str = arr.data();
  

• 请注意，我们返回的数组需要大于实际未缩进的字符串 (std::array<char, size>)。由于 str作为函数的参数，它不是常量表达式，所以我们不能用它来确定未缩进字符串的实际大小(因此我们只能使用原始字符串的长度):

  constexpr std::array<char, 8> arr = unindent("  a\n  b");
  // arr would be {'a', '\n', 'b', '\0', '\0', '\0', '\0', '\0'};
  

  所以这很可能会导致很多额外的 '\0'在你的最终二进制文件中，除了相当困惑( arr.size() 不是字符串的真实长度)
• 我们不能使用 user-defined literals - C++17 支持的唯一变体是:

  constexpr /*...*/ operator"" _M(const char* str, std::size_t len) {
      return std::array<char, 1000> { /* ... */ };
  }
  

  ...但是str并且它的长度不再是常量表达式，因此我们不能将两者都用于 std::array 的大小;所以唯一可能的选择是使用固定大小的数组——这不是很有用。

出于这些原因，我将只提供 C++20 实现。

---

2。全面实现

这是完整的 C++20 实现:

godbolt

#include <algorithm>
#include <string_view>
#include <vector>
#include <ranges>

namespace multiline_raw_string {
    template<class char_type>
    using string_view = std::basic_string_view<char_type>;

    // characters that are considered space
    // we need this because std::isspace is not constexpr
    template<class char_type>
    constexpr string_view<char_type> space_chars = std::declval<string_view<char_type>>();
    template<>
    constexpr string_view<char> space_chars<char> = " \f\n\r\t\v";
    template<>
    constexpr string_view<wchar_t> space_chars<wchar_t> = L" \f\n\r\t\v";
    template<>
    constexpr string_view<char8_t> space_chars<char8_t> = u8" \f\n\r\t\v";
    template<>
    constexpr string_view<char16_t> space_chars<char16_t> = u" \f\n\r\t\v";
    template<>
    constexpr string_view<char32_t> space_chars<char32_t> = U" \f\n\r\t\v";
    
    
    // list of all potential line endings that could be encountered
    template<class char_type>
    constexpr string_view<char_type> potential_line_endings[] = std::declval<string_view<char_type>[]>();
    template<>
    constexpr string_view<char> potential_line_endings<char>[] = {
        "\r\n",
        "\r",
        "\n"
    };
    template<>
    constexpr string_view<wchar_t> potential_line_endings<wchar_t>[] = {
        L"\r\n",
        L"\r",
        L"\n"
    };
    template<>
    constexpr string_view<char8_t> potential_line_endings<char8_t>[] = {
        u8"\r\n",
        u8"\r",
        u8"\n"
    };
    template<>
    constexpr string_view<char16_t> potential_line_endings<char16_t>[] = {
        u"\r\n",
        u"\r",
        u"\n"
    };
    template<>
    constexpr string_view<char32_t> potential_line_endings<char32_t>[] = {
        U"\r\n",
        U"\r",
        U"\n"
    };

    // null-terminator for the different character types
    template<class char_type>
    constexpr char_type null_char = std::declval<char_type>();
    template<>
    constexpr char null_char<char> = '\0';
    template<>
    constexpr wchar_t null_char<wchar_t> = L'\0';
    template<>
    constexpr char8_t null_char<char8_t> = u8'\0';
    template<>
    constexpr char16_t null_char<char16_t> = u'\0';
    template<>
    constexpr char32_t null_char<char32_t> = U'\0';

    // detects the line ending used within a string.
    // e.g. detect_line_ending("foo\nbar\nbaz") -> "\n"
    template<class char_type>
    consteval string_view<char_type> detect_line_ending(string_view<char_type> str) {
        return *std::ranges::max_element(
            potential_line_endings<char_type>,
            {},
            [str](string_view<char_type> line_ending) {
                // count the number of lines we would get with line_ending
                auto view = std::views::split(str, line_ending);
                return std::ranges::distance(view);
            }
        );
    }

    // returns a view to the leading sequence of space characters within a string
    // e.g. get_leading_space_sequence(" \t  foo") -> " \t  "
    template<class char_type>
    consteval string_view<char_type> get_leading_space_sequence(string_view<char_type> line) {
        return line.substr(0, line.find_first_not_of(space_chars<char_type>));
    }

    // checks if a line consists purely out of space characters
    // e.g. is_line_empty("    \t") -> true
    //      is_line_empty("   foo") -> false
    template<class char_type>
    consteval bool is_line_empty(string_view<char_type> line) {
        return get_leading_space_sequence(line).size() == line.size();
    }

    // splits a string into individual lines
    // and removes the first & last line if they are empty
    // e.g. split_lines("\na\nb\nc\n", "\n") -> {"a", "b", "c"}
    template<class char_type>
    consteval std::vector<string_view<char_type>> split_lines(
        string_view<char_type> str,
        string_view<char_type> line_ending
    ) {
        std::vector<string_view<char_type>> lines;

        for (auto line : std::views::split(str, line_ending)) {
            lines.emplace_back(line.begin(), line.end());
        }

        // remove first/last lines in case they are completely empty
        if(lines.size() > 1 && is_line_empty(lines[0])) {
            lines.erase(lines.begin());
        }
        if(lines.size() > 1 && is_line_empty(lines[lines.size()-1])) {
            lines.erase(lines.end()-1);
        }

        return lines;
    }

    // determines the longest possible sequence of space characters
    // that we can remove from each line.
    // e.g. determine_common_space_prefix_sequence({" \ta", " foo", " \t\ŧbar"}) -> " "
    template<class char_type>
    consteval string_view<char_type> determine_common_space_prefix_sequence(
        std::vector<string_view<char_type>> const& lines
    ) {
        std::vector<string_view<char_type>> space_sequences = {
            string_view<char_type>{} // empty string
        };

        for(string_view<char_type> line : lines) {
            string_view<char_type> spaces = get_leading_space_sequence(line);
            for(std::size_t len = 1; len <= spaces.size(); len++) {
                space_sequences.emplace_back(spaces.substr(0, len));
            }
   
            // remove duplicates
            std::ranges::sort(space_sequences);
            auto [first, last] = std::ranges::unique(space_sequences);
            space_sequences.erase(first, last);
        }

        // only consider space prefix sequences that apply to all lines
        auto shared_prefixes = std::views::filter(
            space_sequences,
            [&lines](string_view<char_type> prefix) {
                return std::ranges::all_of(
                    lines,
                    [&prefix](string_view<char_type> line) {
                        return line.starts_with(prefix);
                    }
                );
            }
        );

        // select the longest possible space prefix sequence
        return *std::ranges::max_element(
            shared_prefixes,
            {},
            &string_view<char_type>::size
        );
    }

    // unindents the individual lines of a raw string literal
    // e.g. unindent_string("  \n  a\n  b\n  c\n") -> "a\nb\nc"
    template<class char_type>
    consteval std::vector<char_type> unindent_string(string_view<char_type> str) {
        string_view<char_type> line_ending = detect_line_ending(str);
        std::vector<string_view<char_type>> lines = split_lines(str, line_ending);
        string_view<char_type> common_space_sequence = determine_common_space_prefix_sequence(lines);

        std::vector<char_type> new_string;
        bool is_first = true;
        for(auto line : lines) {
            // append newline
            if(is_first) {
                is_first = false;
            } else {
                new_string.insert(new_string.end(), line_ending.begin(), line_ending.end());
            }

            // append unindented line
            auto unindented = line.substr(common_space_sequence.size());
            new_string.insert(new_string.end(), unindented.begin(), unindented.end());
        }

        // add null terminator
        new_string.push_back(null_char<char_type>);

        return new_string;
    }

    // returns the size required for the unindented string
    template<class char_type>
    consteval std::size_t unindent_string_size(string_view<char_type> str) {
        return unindent_string(str).size();
    }

    // simple type that stores a raw string
    // we need this to get around the limitation that string literals
    // are not considered valid non-type template arguments.
    template<class _char_type, std::size_t size>
    struct string_wrapper {
        using char_type = _char_type;

        consteval string_wrapper(const char_type (&arr)[size]) {
            std::ranges::copy(arr, str);
        }

        char_type str[size];
    };

    // used for sneakily creating and storing
    // the unindented string in a template parameter.
    template<string_wrapper sw>
    struct unindented_string_wrapper {
        using char_type = typename decltype(sw)::char_type;
        static constexpr std::size_t buffer_size = unindent_string_size<char_type>(sw.str);
        using array_ref = const char_type (&)[buffer_size];

        consteval unindented_string_wrapper(int) {
            auto newstr = unindent_string<char_type>(sw.str);
            std::ranges::copy(newstr, buffer);
        }

        consteval array_ref get() const {
            return buffer;
        }

        char_type buffer[buffer_size];
    };

    // uses a defaulted template argument that depends on the str
    // to initialize the unindented string within a template parameter.
    // this enables us to return a reference to the unindented string.
    template<string_wrapper str, unindented_string_wrapper<str> unindented = 0>
    consteval decltype(auto) do_unindent() {
        return unindented.get();
    }

    // the actual user-defined string literal operator
    template<string_wrapper str>
    consteval decltype(auto) operator"" _M() {
        return do_unindent<str>();
    }
}

using multiline_raw_string::operator"" _M;

使用示例:godbolt

std::cout << R"(
     a
    b
     c
    d
)"_M << std::endl;
/* Will print the following:
 a
b
 c
d
*/

// The type of R"(...)"_M is still const char (&)[N],
// so it can be used like a normal string literal:
std::cout << std::size(R"(asdf)"_M) << std::endl;
// (will print 5)

// Lifetime is not a problem; can be stored in a std::string_view:
constexpr std::string_view str = R"(
    foo
    bar
)"_M;

// also works with wchar_t, char8_t, char16_t and char32_t literals:
std::wcout << LR"(foo)"_M << std::endl;

---

3。实现说明

• 哪些字符被视为空格？
  std::isspace() 不幸的是不是 constexpr，所以我们必须推出自己的:(为了取消缩进，您可以添加您希望被视为“空格”的其他字符):

  template<>
  constexpr string_view<char> space_chars<char> = " \f\n\r\t\v";
  

• 行尾。
  原始字符串文字中的行结尾取决于源代码中使用的行结尾；不幸的是，没有很好的方法让编译器告诉我们正在使用什么行尾(在一个源文件中甚至可能混合使用)——所以我们必须手动检测字符串文字中存在什么类型的行尾.
  我已经实现了 \r\n , \n和 \r作为潜在的行结尾，这些应该涵盖大多数用例:

  template<>
  constexpr string_view<char> potential_line_endings<char>[] = {
      "\r\n",
      "\r",
      "\n"
  };
  

• 处理混合缩进
  用于缩进的空格字符在每一行中必须相同，否则它们不会被删除。 - 所以你可以使用任何你喜欢的空格字符来缩进(甚至混合使用) - 只要你在所有行中保持一致。
  例如这行不通:

  // mixed indentation (indentation will remain)
  constexpr std::string_view str = R"(
  <tab>foo
       bar
  )"_M;
  

  但这将:

  // all lines have the same indentation pattern
  constexpr std::string_view str = R"(
  <tab>  foo
  <tab>  bar
  )"_M;