Question

此代码具有未定义的行为：

#include <string_view>
#include <iostream>

using namespace std::string_view_literals;

void foo(std::string_view msg) {
    std::cout << msg.data() << '\n'; // undefined behavior if 'msg' is not null-
                                     // terminated

    // std::cout << msg << '\n'; is not undefined because operator<< uses
    //                           iterators to print 'msg', but that's not the point
}

int main() {
    foo("hello"sv); // not null-terminated - undefined behavior
    foo("foo");     // same, even more dangerous
}

原因是std::string_view可以存储非空终止字符串，并且在调用data时不包含空终止符。这实际上是有限的，为了使上面的代码定义为行为，我必须构造一个std::string：

std::string str{ msg };
std::cout << str.data() << '\n';

在这种情况下，这确实使std::string_view变得不必要，我仍然需要复制传递给foo的字符串，所以为什么不使用移动语义并将msg更改为std::string }？这可能会更快，但我没有测量。

无论哪种方式，每当我想将std::string传递给只接受const char*的函数时，必须构造const char*有点不必要，但必须有一个委员会之所以这样决定的原因。

那么，为什么std::string_view::data不会返回像std::string::data这样的以空字符结尾的字符串？

Answer 1

那么，为什么std :: string_view :: data不会返回以null结尾的字符串，如std :: string :: data

仅仅因为它不能。 string_view可以是更大的字符串（字符串的子字符串）的更窄视图。这意味着字符串已查看将不必在特定视图的末尾具有空终止。出于显而易见的原因，您无法将空终止符写入基础字符串，并且您无法创建字符串的副本并返回char *而不会发生内存泄漏。

如果你想要一个空终止字符串，你必须从中创建一个std::string副本。

让我充分利用std::string_view：

auto tokenize(std::string_view str, Pred is_delim) -> std::vector<std::string_view>

此处生成的向量包含标记作为较大字符串的视图。

Answer 2

string_view的目的是表示连续字符序列的范围。将这样的范围限制为以NUL终结符结尾的范围限制了该类的有用性。

话虽如此，拥有string_view的备用版本仍然是有用的，该版本仅用于真正以NUL终止的字符串创建。

我的zstring_view类是从string_view私有继承的，它提供了从前端删除元素和不能使字符串非NUL终止的其他操作的支持。它提供了其余的操作，但它们返回string_view，而不是zstring_view。

你会感到惊讶的是，你必须从string_view中失去一些操作才能完成这项工作：

template<typename charT, typename traits = std::char_traits<charT>>
class basic_zstring_view : private basic_string_view<charT, traits>
{
public:
    using base_view_type = basic_string_view<charT, traits>;

    using base_view_type::traits_type;
    using base_view_type::value_type;
    using base_view_type::pointer;
    using base_view_type::const_pointer;
    using base_view_type::reference;
    using base_view_type::const_reference;

    using base_view_type::const_iterator;
    using base_view_type::iterator;
    using base_view_type::const_reverse_iterator;
    using base_view_type::reverse_iterator;

    using typename base_view_type::size_type;
    using base_view_type::difference_type;

    using base_view_type::npos;

    basic_zstring_view(const charT* str) : base_view_type(str) {}
    constexpr explicit basic_zstring_view(const charT* str, size_type len) : base_view_type(str, len) {}
    constexpr explicit basic_zstring_view(const base_view_type &view) : base_view_type(view) {}

    constexpr basic_zstring_view(const basic_zstring_view&) noexcept = default;
    basic_zstring_view& operator=(const basic_zstring_view&) noexcept = default;

    using base_view_type::begin;
    using base_view_type::end;
    using base_view_type::cbegin;
    using base_view_type::cend;
    using base_view_type::rbegin;
    using base_view_type::rend;
    using base_view_type::crbegin;
    using base_view_type::crend;

    using base_view_type::size;
    using base_view_type::length;
    using base_view_type::max_size;
    using base_view_type::empty;

    using base_view_type::operator[];
    using base_view_type::at;
    using base_view_type::front;
    using base_view_type::back;
    using base_view_type::data;

    using base_view_type::remove_prefix;

    //`using base_view_type::remove_suffix`; Intentionally not provided.

    ///Creates a `basic_string_view` that lacks the last few characters.
    constexpr basic_string_view<charT, traits> view_suffix(size_type n) const
    {
        return basic_string_view<charT, traits>(data(), size() - n);
    }

    using base_view_type::swap;

    template<class Allocator = std::allocator<charT> >
    std::basic_string<charT, traits, Allocator> to_string(const Allocator& a = Allocator()) const
    {
        return std::basic_string<charT, traits, Allocator>(begin(), end(), a);
    }

    constexpr operator base_view_type() const {return base_view_type(data(), size());}

    using base_view_type::to_string;

    using base_view_type::copy;

    using base_view_type::substr;

    using base_view_type::operator==;
    using base_view_type::operator!=;
    using base_view_type::compare;
};

Answer 3

在处理带有已知空终止符的字符串文字时，我通常使用类似的方法来确保所计数的字符中包含空值。

template < size_t L > std::string_view string_viewz(const char (&t) [L])
{
    return std::string_view(t, L);
}

此处的目的不是尝试解决兼容性问题，而是太多。但是，如果您知道您要做什么，则希望string_view span的值为null（序列化），那么这是一个不错的技巧。

auto view = string_viewz("Surrogate String");

为什么std :: string_view :: data不包含空终止符？

3 个答案: