Encontre o próximo dia da semana usando o cronógrafo

Para responder à primeira pergunta, é melhor dividi-la em partes:

Vamos chamar a data de início de: date, e o dia da semana de destino de: wd.

1. Determine o weekdayde date. Chame isso de starting_wd.
2. Determine o número de dias wdque faltam para starting_wd. Chame isso de num_days.
3. Adicionar num_daysà date.

Isso pode parecer algo como:

std::chrono::year_month_day
next_weekday(std::chrono::year_month_day date, std::chrono::weekday wd)
{
    using namespace std::chrono;
    weekday starting_wd{date};
    days num_days = wd - starting_wd;
    return sys_days{date} + num_days;
}

Isso pode ser exercitado assim:

cout << next_weekday(April/28/2025, Friday) << '\n';

que imprime:

2025-05-02

Notas:

• Se o weekdayde datejá for wd, isso adiciona 0 dayse retorna date.
• A codificação subjacente de weekdaysé encapsulada para que você não precise se preocupar com ela. Não importa quais valores wde starting_wdtenham, num_dayssempre estará no intervalo de days{0}a days{6}. Você pode pensar nisso weekdayscomo um "intervalo circular".
• Este é essencialmente um problema de "adicionar um número de dias a uma data" e year_month_dayestá correto, mas é ineficiente para esta operação. O tráfico sys_daysseria mais eficiente.

Para resolver este último problema, poderíamos alterar o tipo de retorno e o tipo de entrada do parâmetro datepara sys_days:

std::chrono::sys_days
next_weekday(std::chrono::sys_days date, std::chrono::weekday wd)
{
    std::chrono::weekday starting_wd{date};
    auto num_days = wd - starting_wd;
    return date + num_days;
}

Notas:

• year_month_dayé uma {y, m, d}estrutura de dados. sys_daysé uma {count of days since epoch}estrutura de dados. Ambos representam uma data. E as conversões de um para o outro não perdem informações.
• A saída ainda é 2025-05-02.
• O código do cliente não muda porque há uma conversão implícita de year_month_day(o tipo da expressão April/28/2025) para sys_days.
• Agora não há necessidade de converter dateantes sys_daysde adicionar num_days .
• Isso é mais eficiente. E se os clientes desejam que a entrada, a saída ou ambas sejam year_month_day, essas conversões são feitas implicitamente. Portanto, essas conversões custam apenas aos clientes que precisam delas (pague apenas pelo que usar, de acordo com o princípio do design).

Agora é fácil ver que é trivial eliminar os temporários locais e fazer disso uma linha:

std::chrono::sys_days
next_weekday(std::chrono::sys_days date, std::chrono::weekday wd)
{
    return date + (wd - std::chrono::weekday{date});
}

Que tal encontrar o dia da semana anterior em vez do próximo?

Neste caso você precisa subtrair o número que days dateestá à frente de wd:

std::chrono::sys_days
prev_weekday(std::chrono::sys_days date, std::chrono::weekday wd)
{
    return date - (std::chrono::weekday{date} - wd);
}

Se conduzido por:

cout << prev_weekday(April/28/2025, Friday) << '\n';

a saída agora é:

2025-04-25

Posso começar com intvalores, colocá-los chronoe depois retirá int -los?

Se você tiver seus year, monthe daycomo inteiros, isso se parece com:

int iy = 2025;
int im = 4;
int id = 28;
year_month_day next_friday = next_weekday(year{iy}/im/id, Friday);

O tipo de retorno é sys_days, que é implicitamente conversível para year_month_day. Use os getters: .year(), .month()e .day():

auto y = next_friday.year();
auto m = next_friday.month();
auto d = next_friday.day();

Neste caso , yhas type year, mhas type monthe dhas type day. Se você quiser que seja int, basta converter explicitamente para int:

int iy{y};  // iy == 2025

monthe dayter conversões explícitas para unsignedesse propósito.

unsigned im{m};  // im == 5
unsigned id{d};  // id == 2

Nota: Essas conversões explícitas são exatamente o inverso de ir na outra direção: de tipos integrais para cronológicos:

year  y{iy};
month m{im};
day   d{id};

Esta é uma API simétrica e fácil de lembrar.

Observação: para permitir que o compilador detecte erros de lógica no seu código, é melhor não converter para tipos integrais, mas sim permanecer dentro do sistema de tipos chrono. Isso transforma erros de lógica em erros de tempo de compilação. Mas se você precisar interoperar com outra biblioteca de datas, números inteiros geralmente são a única maneira de fazer isso.

Se a data de entrada já estiver no dia da semana de destino, o que é necessário para alterar entre obter a data de entrada ou obter uma semana a partir da data de entrada?

Esta é uma transformação muito fácil: basta incrementar o dateanterior ao algoritmo (ou decrementar no caso de prev_weekday):

std::chrono::sys_days
next_weekday(std::chrono::sys_days date, std::chrono::weekday wd)
{
    ++date;
    return date + (wd - std::chrono::weekday{date});
}

Observação: o LLVM ainda não implementou o operador de incremento em time_point (em abril de 2025). Você pode contornar isso com date += std::chrono::days{1};.

Pontos de bônus: aplique constexpre next_weekdayfuncionará também em tempo de compilação:

static_assert(next_weekday(April/28/2025, Friday) == May/2/2025);