缩进感知原始字符串文字

Question

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

例如

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

印刷

ref

       Hello
           World
    

但我想

ref
Hello
    World

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

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

Answer 1

tl;博士

• 可以在 C++20 中使用用户定义的文字运算符来执行此操作。
  示例：神栓

  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 中，我们可以使用字符串文字运算符模板将字符串作为模板参数获取，例如：

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 中，我们不能将类类型作为模板 arguments，并且字符串文字运算符模板也不可用。 所以没有巧妙的方法来全局存储修改后的字符串（常量表达式中不允许使用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是 function 的参数，它不是常量表达式，所以我们不能用它来确定未缩进字符串的实际大小（因此我们只能使用原始字符串的长度）：

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

  所以这很可能会在你的最终二进制文件中导致很多额外'\0' ，除了相当混乱（ arr.size()不是字符串的真实长度）
• 我们不能使用用户定义的文字- 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 实现：

神栓

#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;

Answer 2

始终存在隐式字符串文字连接。 您仍然需要\n字符，但行的相对位置很清楚。

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