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

3294. zoned_time deduction guides misinterprets string/char*

Section: 29.11.7.1 [time.zone.zonedtime.overview] Status: C++20 Submitter: Tomasz Kamiński Opened: 2019-09-14 Last modified: 2021-02-25

Priority: 0

View all other issues in [time.zone.zonedtime.overview].

View all issues with C++20 status.

Discussion:

The current deduction guide for zoned_time for the following declarations

zoned_time zpc("America/New_York", std::chrono::system_clock::now());
zoned_time zps(std::string("America/New_York"), std::chrono::system_clock::now());

will attempt to produce a zoned_time instance with const char* (for zpc) and with std::string (for zps), respectively, as the deduced type for the TimeZonePtr template parameter. This is caused by the fact that the unconstrained TimeZonePtr deduction guide template will produce better candidates and will be selected by overload resolution.

The proposed resolution merges the deduction of the std::string_view/TimeZonePtr deduction guides into one guide, that deduces const time_zone* for any type convertible to string_view. This is necessary to override the deduction from TimeZonePtr constructor candidates.

In addition, we disable the deduction from string_view constructors, that would produce better candidates than the deduction guides and create zoned_time instances with durations coarser than seconds (causing similar issue as LWG 3232):

std::chrono::local_time<hours> lh(10h);
std::chrono::zoned_time zt1("Europe/Helsinki", lh);
std::chrono::zoned_time zt2(std::string("Europe/Helsinki"), lh);
std::chrono::zoned_time zt3(std::string_view("Europe/Helsinki"), lh);

Without disabling the deduction from the string_view constructor, the type of the zt3 variable would be deduced to zoned_time<hours>, with the proposed change the types of the variables zt1, zt2, and zt3 are consistently deduced as zoned_time<seconds>.

Finally, the wording eliminates the unnecessary zoned_time<Duration> guide (covered by zoned_time<Duration, TimeZonePtr2>).

The change was implemented in the example implementation. The dedicated test can be found here.

[2019-10-31 Issue Prioritization]

Status to Tentatively Ready and priority to 0 after five positive votes on the reflector.

Proposed resolution:

This wording is relative to N4830.

1. Modify 29.11.7.1 [time.zone.zonedtime.overview], class template zoned_time synopsis, as indicated:

   namespace std::chrono {
     […]
     zoned_time() -> zoned_time<seconds>;
     
     template<class Duration>
       zoned_time(sys_time<Duration>)
         -> zoned_time<common_type_t<Duration, seconds>>;
         
     template<class TimeZonePtrOrName>
       using time-zone-representation =
         conditional_t<is_convertible_v<TimeZonePtrOrName, string_view>, 
           const time_zone*,
           remove_cv_ref<TimeZonePtrOrName>>; // exposition only
   
     template<class TimeZonePtrOrName>
       zoned_time(TimeZonePtrOrName&&)
         -> zoned_time<seconds, time-zone-representation<TimeZonePtr>>;
     
     template<class TimeZonePtrOrName, class Duration>
       zoned_time(TimeZonePtrOrName&&, sys_time<Duration>)
         -> zoned_time<common_type_t<Duration, seconds>, 
           time-zone-representation<TimeZonePtrOrName>>;
     
     template<class TimeZonePtrOrName, class Duration>
       zoned_time(TimeZonePtrOrName&&, local_time<Duration>, choose = choose::earliest)
         -> zoned_time<common_type_t<Duration, seconds>, 
           time-zone-representation<TimeZonePtrOrName>>;
     
     template<class TimeZonePtr, class Duration>
       zoned_time(TimeZonePtr, zoned_time<Duration>, choose = choose::earliest)
         ->> zoned_time<common_type_t<Duration, seconds>, TimeZonePtr>;
     
     zoned_time(string_view) -> zoned_time<seconds>;
   
     template<class Duration>
       zoned_time(string_view, sys_time<Duration>)
         -> zoned_time<common_type_t<Duration, seconds>>;
     
     template<class Duration>
       zoned_time(string_view, local_time<Duration>, choose = choose::earliest)
         -> zoned_time<common_type_t<Duration, seconds>>;
     
     template<class Duration, class TimeZonePtrOrName, class TimeZonePtr2>
       zoned_time(TimeZonePtrOrName&&, zoned_time<Duration, TimeZonePtr2>, choose = choose::earliest)
        -> zoned_time<Duration, time-zone-representation<TimeZonePtrOrName>>;
   }
   

   -1- zoned_time represents a logical pairing of a time_zone and a time_point with precision Duration. zoned_time<Duration> maintains the invariant that it always refers to a valid time zone and represents a point in time that exists and is not ambiguous in that time zone.

   -2- If Duration is not a specialization of chrono::duration, the program is ill-formed.

   -?- Every constructor of zoned_time that accepts a string_view as first parameter does not participate in class template argument deduction (12.2.2.9 [over.match.class.deduct]).