There was a proposal std::basic_cstring_view. However, the proposal claimed a cstring_view with sized version is aka “better choice” than no-sized version.

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1402r0.pdf

I disagree with this proposal.

1.    ABI breaking/Backward compatibility

People cannot switch to cstring_view when they store their char const* in the structs/classes because the layout of struct would change, which means even you have cstring_view, you cannot kill the use cases of char const*. The c-style string will just exist forever.

struct legacy_structure

{

                char const* str;

                std::size_t s;

};

2.    The reason people are using c_str() is to pass parameters towards c interface.

For example:

std::string str(“abc.txt”);

FILE *fp = fopen(str.c_str(),”w”); //ignore exception safety issues here.

    Suppose, we are using std::cstring_view, it solves nothing and only makes the problem worse since we have to pay extra theta(n) cost for reading the size. It brings zero advantages over neither std::basic_string_view, nor std::basic_view.

3.    What is the point of making cstring_view which did exactly the same thing string_view could do? What real advantages could cstring_view bring? It is impossible to ensure ‘\0’ for the sequence as well, just like string_view. Also would people just abolish string_view when they could just use cstring_view? (because they could be potentially misleading cstring_view is “better”)

4.    What does this call std::cstring_view, not just std::cstring? I do think the standard library requires a minimum interface for c_str(), not some kinds of “view”. Calling it cstring_view is pretty hard to differentiate it with string_view.

Here is our proposal with source code.

We need a minimum interface for wrapping c style string. Here are our design goals:

1.            The class is to provide a generic interface for different string classes in order for passing through C APIs, no other purposes.

2.            Unlike std::basic_string or std::basic_string_view.  The std::basic_cstring provides As few APIs as possible (to ensure security). No no start_with(), no back(), no size(), no find(), no substr(),  remove_suffix() etc.

3.            No its unique string literals.

4.            No hash function,

5.            Reduce potential usages of c-style string APIs such as strcmp, strlen, strncmp, strnlen,

6.            end() should be a special iterator type.

7.            all operations are constexpr

8.            It does not rely on std::basic_string,std::basic_string_view. The cstring_view auto-detects any char sequences class with v.data() through C++20 concepts lite.

For example:

    std::vector<char> vec(4,'a');

    vec.back()=0;

    std::experimental::cstring svv(vec);

9. No std::ostream support. Use template for outputing cstring instead. This would reduce the reliance of std::ostream&. We do not need #include<ostream> which would greatly reduce compilation time

template<typename __ostrm,typename __char_type,typename __traits>

inline decltype(auto) operator<<(__ostrm& __os,basic_cstring<__char_type,__traits> const & __a)

{

    return __os<<__a.c_str();

}

I’ve provided my implementation of std::basic_cstring_view in the attachments.

Sent from Mail for Windows 10