Как вы печатаете time_point C ++ 11?

(В этом посте я опущу std::chrono:: оговорки для ясности. Надеюсь, вы знаете, куда они идут.)

Причина, по которой ваш пример кода не компилируется, заключается в несоответствии между типом возвращаемого значения system_clock::now() и типом переменной, которой вы пытаетесь присвоить это значение (time_point<system_clock, nanoseconds>).

Задокументированное возвращаемое значение system_clock::now() - system_clock::time_point, которое является typedef для time_point<system_clock, system_clock::duration>. system_clock::duration определяется реализацией, обычно используются microseconds и nanoseconds. Кажется, что ваша реализация использует microseconds, поэтому тип возврата system_clock::now() - time_point<system_clock, microseconds>.

time_points с разной длительностью не могут быть неявно преобразованы друг в друга, поэтому вы получите ошибку компилятора.

Вы можете явно преобразовать временные точки с разной продолжительностью с помощью time_point_cast, чтобы в вашей системе компилировалось следующее:

time_point<system_clock, nanoseconds> time_point;
time_point = time_point_cast<nanoseconds>(system_clock::now());

Обратите внимание, что явный параметр шаблона для time_point_cast является типом целевой продолжительности, а не типом целевой time_point. Типы часов должны совпадать в time_point_cast, поэтому указание всего типа time_point (который шаблонизирован как для типа часов, так и для типа продолжительности) будет избыточным.

Конечно, в вашем случае, поскольку вы просто хотите распечатать точку времени, нет необходимости в том, чтобы она была в каком-либо конкретном разрешении, поэтому вы можете просто объявить time_point тем же типом, что и то, что возвращает system_clock::now() для начала. Простой способ сделать это - использовать system_clock::time_point typedef:

system_clock::time_point time_point;
time_point = system_clock::now();  // no time_point_cast needed

Поскольку это C ++ 11, вы также можете просто использовать auto:

auto time_point = system_clock::now(); 

После устранения этой ошибки компилятора преобразование в time_t работает нормально:

std::time_t now_c = std::chrono::system_clock::to_time_t(time_point);

и теперь вы можете использовать стандартные методы для отображения time_t значений, например std::ctime или std::strftime. (Как отмечает Кассио Нери в комментарии к вашему вопросу, функция more C ++ - y std::put_time еще не поддерживается GCC).

Этот фрагмент может вам помочь:

#include <iomanip>
#include <iostream>
#include <chrono>
#include <ctime>

template<typename Clock, typename Duration>
std::ostream &operator<<(std::ostream &stream,
  const std::chrono::time_point<Clock, Duration> &time_point) {
  const time_t time = Clock::to_time_t(time_point);
#if __GNUC__ > 4 || \
    ((__GNUC__ == 4) && __GNUC_MINOR__ > 8 && __GNUC_REVISION__ > 1)
  // Maybe the put_time will be implemented later?
  struct tm tm;
  localtime_r(&time, &tm);
  return stream << std::put_time(&tm, "%c"); // Print standard date&time
#else
  char buffer[26];
  ctime_r(&time, buffer);
  buffer[24] = '\0';  // Removes the newline that is added
  return stream << buffer;
#endif
}

int main() {
  std::cout << std::chrono::system_clock::now() << std::endl;
  // Wed May 22 14:17:03 2013
}

Обновленный ответ на старый вопрос:

Для std::chrono::time_point<std::chrono::system_clock, some-duration> теперь есть сторонние библиотеки, которые дают вам гораздо лучший контроль. Для time_points, основанных на других часах, все еще нет лучшего решения, чем просто получить внутреннее представление и распечатать его.

Но для system_clock, используя эту библиотеку, это так же просто, как:

#include "date.h"
#include <iostream>

int
main()
{
    using namespace date;
    using namespace std::chrono;
    std::cout << system_clock::now() << " UTC\n";
}

который просто выводит для меня:

2016-07-19 03:21:01.910626 UTC

текущая дата и время в формате UTC с точностью до микросекунд. Если на вашей платформе system_clock::time_point имеет точность наносекунды, она распечатает для вас точность наносекунды.

2021 Обновление

Вот версия указанной выше программы на C ++ 20:

#include <chrono>
#include <iostream>

int
main()
{
    std::cout << std::chrono::system_clock::now() << " UTC\n";
}

nanoseconds, похоже, является частью проблемы, немного посмотрев документацию, я смог заставить это работать:

#include <iostream>
#include <chrono>
#include <ctime>


int main(){

    //set time_point to current time
    std::chrono::time_point<std::chrono::system_clock> time_point;
    time_point = std::chrono::system_clock::now();

    std::time_t ttp = std::chrono::system_clock::to_time_t(time_point);
    std::cout << "time: " << std::ctime(&ttp);

    return 0;
}

Хотя похоже, что std::chrono::microseconds работает нормально:

std::chrono::time_point<std::chrono::system_clock,std::chrono::microseconds> time_point;

Для всех, кто работает с time_point<steady_clock> (не time_point<system_clock>):

#include <chrono>
#include <iostream>

template<std::intmax_t resolution>
std::ostream &operator<<(
    std::ostream &stream,
    const std::chrono::duration<
        std::intmax_t,
        std::ratio<std::intmax_t(1), resolution>
    > &duration)
{
    const std::intmax_t ticks = duration.count();
    stream << (ticks / resolution) << '.';
    std::intmax_t div = resolution;
    std::intmax_t frac = ticks;
    for (;;) {
        frac %= div;
        if (frac == 0) break;
        div /= 10;
        stream << frac / div;
    }
    return stream;
}

template<typename Clock, typename Duration>
std::ostream &operator<<(
    std::ostream &stream,
    const std::chrono::time_point<Clock, Duration> &timepoint)
{
    Duration ago = timepoint.time_since_epoch();
    return stream << ago;
}

int main(){
    // print time_point
    std::chrono::time_point<std::chrono::steady_clock> now =
        std::chrono::steady_clock::now();
    std::cout << now << "\n";

    // print duration (such as the difference between 2 time_points)
    std::chrono::steady_clock::duration age = now - now;
    std::cout << age << "\n";
}

Средство форматирования десятичных чисел не является наиболее эффективным, но не требует предварительного знания количества десятичных знаков, которое неизвестно, если вы хотите использовать шаблон resolution, если вы не можете придумать постоянное выражение для ceil(log10(resolution)).

Ctime () не работает для Visual C ++. Я использую MS Visual Studio 2013. Я изменил приведенный выше код, чтобы использовать ctime_s (...), как было предложено компилятором MSVC. Это сработало.

//set time_point to current time
std::chrono::time_point<std::chrono::system_clock> time_point;
time_point = std::chrono::system_clock::now();

std::time_t ttp = std::chrono::system_clock::to_time_t(time_point);
char chr[50];
errno_t e = ctime_s(chr, 50, &ttp);
if (e) std::cout << "Error." << std::endl;
else std::cout << chr << std::endl;

Еще один фрагмент кода. Плюс в том, что он довольно автономен и поддерживает текстовое представление микросекунд.

std::ostream& operator<<(std::ostream& stream, const std::chrono::system_clock::time_point& point)
{
    auto time = std::chrono::system_clock::to_time_t(point);
    std::tm* tm = std::localtime(&time);
    char buffer[26];
    std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S.", tm);
    stream << buffer;
    auto duration = point.time_since_epoch();
    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
    auto remaining = std::chrono::duration_cast<std::chrono::nanoseconds>(duration - seconds);
    // remove microsecond cast line if you would like a higher resolution sub second time representation, then just stream remaining.count()
    auto micro = std::chrono::duration_cast<std::chrono::microseconds>(remaining);
    return stream << micro.count();
}