[libcxx] LWG2221: No formatted output operator for nullptr

[K-ballo]

Summary

With effects equivalent to os << (const void*)nullptr.

[lichray]

include/ostream

225

Oh, common, I persuaded the committee to allow you to print a (null) and you don't do it...

[mclow.lists]

Other than the actual text being output, this LGTM.
I'ld like to see the changes I suggested in the test go in, but they're really minor.

include/ostream

225

I think that (null) is a better thing to output here than 0x0.

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/nullptr_t.pass.cpp

72

You could just say `assert(!sb.str().empty()) here; no need to save the string in a variable.

79

Might as well check for a non-empty string here, too.

[• Quuxplusone]

include/ostream

225

Are you two implying that

*this << (const void *)0;

does *not* print (null)? It certainly should, IMO. (I mean, it'll call num_put for void* in the current locale, but I would naturally expect that to print (null).)
Anyway, whether the current locale prints null as (null) or not, there is great potential utility in using the same format for all pointers, as K-ballo is doing here. I'd really like to be able to

std::ostringstream oss;
oss << nullptr;  // equivalently: oss << (void*)0;
void *p;
std::istringstream(oss.str()) >> p;  // should read in a null pointer, not derp out

FWIW, it looks like libc++ currently *does* print null pointers as (nil), which is not quite the same thing as (null). libstdc++ prints them as 0.
https://wandbox.org/permlink/yAM6tjMzvEX9HhhE

[K-ballo]

include/ostream

225

It's been a while now, but I seem to recall that the reason we settled on (*this) << (const void*)0 was precisely so that it would go through num_put, as the rest of the pointers do. As I read back on the specification, however, I am no longer sure that such an implementation is conforming. Maybe if we were to call the facet directly...

I am no longer interested in this issue. If anyone wants to take over control I would be happy to yield it; otherwise, I'll implement whatever I'm instructed to.

[lichray]

include/ostream

225

Your test code prints 0x0 0x0 on FreeBSD though.
If reliable round-tripping is the goal, maybe we can enforce printing (nil)? fmtlib does this as well:

https://github.com/fmtlib/fmt/commit/b5fda1c90d94aeaf96081477c9bfe13789c00e03

include/ostream

     basic_ostream& operator<<(double f);
     basic_ostream& operator<<(long double f);
     basic_ostream& operator<<(const void* p);
+    basic_ostream& operator<<(nullptr_t);
     basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb);
 
     // 27.7.2.7 Unformatted output:

 #include <locale>
 #include <iterator>
 #include <bitset>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

     basic_ostream& operator<<(const void* __p);
     basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
 
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_ostream& operator<<(nullptr_t)
+    { return *this << (const void*)0; }
+
     // 27.7.2.7 Unformatted output:
     basic_ostream& put(char_type __c);
     basic_ostream& write(const char_type* __s, streamsize __n);

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/nullptr_t.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <ostream>
+
+// template <class charT, class traits = char_traits<charT> >
+//   class basic_ostream;
+
+// operator<<(nullptr_t);
+
+#include <ostream>
+#include <cstddef>
+#include <cassert>
+
+template <class CharT>
+class testbuf
+    : public std::basic_streambuf<CharT>
+{
+    typedef std::basic_streambuf<CharT> base;
+    std::basic_string<CharT> str_;
+public:
+    testbuf()
+    {
+    }
+
+    std::basic_string<CharT> str() const
+        {return std::basic_string<CharT>(base::pbase(), base::pptr());}
+
+protected:
+
+    virtual typename base::int_type
+        overflow(typename base::int_type __c = base::traits_type::eof())
+        {
+            if (__c != base::traits_type::eof())
+            {
+                int n = static_cast<int>(str_.size());
+                str_.push_back(static_cast<CharT>(__c));
+                str_.resize(str_.capacity());
+                base::setp(const_cast<CharT*>(str_.data()),
+                           const_cast<CharT*>(str_.data() + str_.size()));
+                base::pbump(n+1);
+            }
+            return __c;
+        }
+};
+
+int main()
+{
+    {
+        std::ostream os((std::streambuf*)0);
+        std::nullptr_t n = nullptr;
+        os << n;
+        assert(os.bad());
+        assert(os.fail());
+    }
+    {
+        testbuf<char> sb;
+        std::ostream os(&sb);
+        std::nullptr_t n = nullptr;
+        os << n;
+        assert(os.good());
+        std::string s(sb.str());
+
+        // Implementation defined. Instead of validating the output,
+        // at least ensure that it does not generate an empty string.
+        assert(!s.empty());
+    }
+    {
+        testbuf<char> sb;
+        std::ostream os(&sb);
+        std::nullptr_t const n = nullptr;
+        os << n;
+        assert(os.good());
+    }
+}

www/cxx1z_status.html

    <tr><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/LWG2062">2062</a></td><td>Effect contradictions w/o no-throw guarantee of std::function swaps</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="http://wg21.link/LWG2166">2166</a></td><td>Heap property underspecified?</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="http://wg21.link/LWG2221">2221</a></td><td>No formatted output operator for nullptr</td><td>Issaquah</td><td></td></tr>
+  <tr><td><a href="http://wg21.link/LWG2221">2221</a></td><td>No formatted output operator for nullptr</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="http://wg21.link/LWG2223">2223</a></td><td>shrink_to_fit effect on iterator validity</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="http://wg21.link/LWG2261">2261</a></td><td>Are containers required to use their 'pointer' type internally?</td><td>Issaquah</td><td></td></tr>
   <tr><td><a href="http://wg21.link/LWG2394">2394</a></td><td>locale::name specification unclear - what is implementation-defined?</td><td>Issaquah</td><td>Complete</td></tr>