RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.github.io/LWG/issue3540 below:

§[format.arg] There should be no const in basic_format_arg(const T* p)

This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of C++23 status.

3540. §[format.arg] There should be no const in basic_format_arg(const T* p)

Section: 28.5.8.1 [format.arg] Status: C++23 Submitter: S. B. Tam Opened: 2021-04-07 Last modified: 2023-11-22

Priority: Not Prioritized

View all other issues in [format.arg].

View all issues with C++23 status.

Discussion:

When P0645R10 "Text formatting" was merged into the draft standard, there was a typo: an exposition-only constructor of basic_format_arg is declared as accepting const T* in the class synopsis, but is later declared to accept T*. This was editorial issue 3461 and was resolved by adding const to the redeclaration.

As it is, constructing basic_format_arg from void* will select template<class T> explicit basic_format_arg(const T& v) and store a basic_format_arg::handle instead of select template<class T> basic_format_arg(const T*) and store a const void*, because void* → void*const& is identity conversion, while void* → const void* is qualification conversion. While this technically works, it seems that storing a const void* would be more intuitive. Hence, I think const should be removed from both declarations of basic_format_arg(const T*), so that construction from void* will select this constructor, resulting in more intuitive behavior.

[2021-04-20; Reflector poll]

Set status to Tentatively Ready after five votes in favour during reflector poll.

[2021-06-07 Approved at June 2021 virtual plenary. Status changed: Voting → WP.]

Proposed resolution:

This wording is relative to N4885.

Modify 28.5.8.1 [format.arg] as indicated:

namespace std {
  template<class Context>
  class basic_format_arg {
  public:
    class handle;

  private:
    using char_type = typename Context::char_type;                     // exposition only

    variant<monostate, bool, char_type,
      int, unsigned int, long long int, unsigned long long int,
      float, double, long double,
      const char_type*, basic_string_view<char_type>,
      const void*, handle> value;                                      // exposition only

    template<class T> explicit basic_format_arg(const T& v) noexcept;  // exposition only
    explicit basic_format_arg(float n) noexcept;                       // exposition only
    explicit basic_format_arg(double n) noexcept;                      // exposition only
    explicit basic_format_arg(long double n) noexcept;                 // exposition only
    explicit basic_format_arg(const char_type* s);                     // exposition only

    template<class traits>
      explicit basic_format_arg(
        basic_string_view<char_type, traits> s) noexcept;              // exposition only

    template<class traits, class Allocator>
      explicit basic_format_arg(
        const basic_string<char_type, traits, Allocator>& s) noexcept; // exposition only
    
    explicit basic_format_arg(nullptr_t) noexcept;                     // exposition only

    template<class T>
      explicit basic_format_arg(const T* p) noexcept;                  // exposition only
  public:
    basic_format_arg() noexcept;

    explicit operator bool() const noexcept;
  };
}

[…]

template<class T> explicit basic_format_arg(const T* p) noexcept;

-12- Constraints: is_void_v<T> is true.
-13- Effects: Initializes value with p. -14- [Note 1: Constructing basic_format_arg from a pointer to a member is ill-formed unless the user provides an enabled specialization of formatter for that pointer to member type. — end note]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4