All perguntas(coding)

Observei um comportamento interessante do g++ nas versões 13 e 14. O código a seguir funciona bem no g++14 (MSYS2, MinGW, Windows):

#include <iostream>
#include <thread>

class A
{
public:
    void f()
    {
        std::cout<<"Okay!\n";
    }
};

int main(int argc,char **argv)
{
    A a;
    std::thread t(A::f,&a);
    t.join();
    return 0;
}

Tentar compilar com g++13 (Linux), no entanto, produz:

error: invalid use of non-static member function 'void A::f()'

Mudando apenas

std::thread t(A::f,&a);

para

std::thread t(&A::f,&a);

resolve o problema. Aparentemente, na variante não-MSYS2, uma função membro não poderia ser usada no lugar de um argumento de função, mas um ponteiro para uma função membro poderia?

Isto foi testado no g++14 com MSYS2 (Windows 10). Aparentemente, outras versões do g++14 não funcionam.

$ g++ --version
g++.exe (Rev2, Built by MSYS2 project) 14.2.0

Há muitas linhas em um arquivo, como as seguintes:

000100667 ===> 000102833
005843000 ===> 005844000
011248375 ===> 011251958

Gostaria de inserir separadores específicos nos números como este:

00:01:00,667 ===> 00:01:02,833
00:58:43,000 ===> 00:58:44,000
01:12:48,375 ===> 01:12:51,958

No momento estou tentando (sucesso apenas na primeira parte):

echo 000100667 | gawk '{printf "%s:%s:%s,%s\n", $1, $2, $3, $4}' FIELDWIDTHS="2 2 2 3"

Considere este trecho de código C++23:

struct MyData {
    std::int32_t value;
};

std::vector<char> read_from_net();
void send_over_net(std::vector<char>&);

...

std::vector<char> buffer = read_from_net();

std::start_lifetime_as<MyData>(buffer.data())->value = 222; // (1)

send_over_net(buffer); // (2)

Assumindo que todos os requisitos para iniciar a vida útil de MyDataat buffer.data()sejam respeitados:

1. Existe alguma UB neste código? Começar o tempo de vida assim e modificar o campo é bem definido?
2. Posso acessar o buffer original como caracteres (2)sem UB, considerando que isso start_lifetime_asencerrou a vida útil do objeto anterior e iniciou uma nova?
3. Ou start_lifetime_asapenas inicia outra vida, mas também preserva a anterior?
4. Devo usar std::launder(buffer.data())[0]o método de acesso ao buffer original como uma matriz de caracteres depois (2)?

Tenho o seguinte dataframe de exemplo:

df <- data.frame(
    record_id = c(1, 1, 1, 2, 2, 3, 3, 3),
    instance = c(NA, NA, 2, NA, 1, 2, NA, NA),
    A = c(10, NA, NA, 20, 25, NA, 30, NA),
    B = c(NA, 5, NA, NA, 5, 15, NA, 15),
    C = c(NA, NA, 3, NA, 5, 20, NA, 20),
    D = c(NA, NA, NA, 25, 25, 30, NA, 30)
)

  record_id instance  A  B  C  D
1         1       NA 10 NA NA NA
2         1       NA NA  5 NA NA
3         1        2 NA NA  3 NA
4         2       NA 20 NA NA 25
5         2        1 25  5  5 25
6         3        2 NA 15 20 30
7         3       NA 30 NA NA NA
8         3       NA NA 15 20 30

Se a instância for NA, quero que as linhas do mesmo record_id sejam recolhidas em uma linha. No meu dataframe, não haverá dois ou mais valores na mesma coluna para o mesmo record_id e grupo de instâncias NA.

Em outras palavras, eu gostaria de obter:

  record_id instance  A  B  C  D
1         1       NA 10  5 NA NA
2         1        2 NA NA  3 NA
3         2       NA 20 NA NA 25
4         2        1 25  5  5 25
5         3        2 NA 15 20 30
6         3       NA 30 15 20 30

Como posso fazer isso?

Acredito que me deparei com um caso ambíguo no padrão C em relação ao escopo de objetos declarados na primeira cláusula de um forloop em comparação com objetos declarados no corpo do loop.

Dado o seguinte código:

for (int i = 1; i < 5; i++) {
    int i = 2;
    printf("%d ", i);
}

À primeira vista, parece que a declaração identro do corpo do loop está em um escopo interno em comparação ao ideclarado na primeira cláusula do forloop.

A seção 6.2.1p4 do padrão C23 afirma o seguinte em relação aos identificadores de escopo de bloco :

Se o declarador ou especificador de tipo que declara o identificador aparecer dentro de um bloco ou dentro da lista de declarações de parâmetros em uma definição de função, o identificador tem escopo de bloco , que termina no final do bloco associado

E 6.2.2p6 sobre ligação :

Os seguintes identificadores não têm vinculação: um identificador declarado como algo diferente de um objeto ou uma função; um identificador declarado como um parâmetro de função; um identificador de escopo de bloco para um objeto declarado sem o especificador de classe de armazenamentoextern .

Portanto, ambos têm escopo de bloco e nenhuma vinculação.

Entretanto, olhando para 6.2.1p6 que diz o seguinte sobre a comparação de escopos:

Dois identificadores têm o mesmo escopo se e somente se seus escopos terminam no mesmo ponto.

E 6.8.5.3p1 sobre a fordeclaração diz o seguinte sobre o escopo dos identificadores que declara:

Se a cláusula 1 for uma declaração, o escopo de quaisquer identificadores que ela declara é o restante da declaração e o loop inteiro, incluindo as outras duas expressões; ele é alcançado na ordem de execução antes da primeira avaliação da expressão de controle

Juntando tudo isso, parece que ambos os objetos declarados como itêm escopos que terminam no mesmo ponto, ou seja, a chave de fechamento do forloop (ou seja, o fim de "todo o loop") e, portanto, têm o mesmo escopo e, além disso, ambos não têm vinculação.

Isso seria então uma violação de restrição conforme 6.7p3:

Se um identificador não tiver vinculação, não deverá haver mais de uma declaração do identificador (em um declarador ou especificador de tipo) com o mesmo escopo e no mesmo espaço de nomes.

Mas nenhum compilador que testei exibe qualquer diagnóstico.

Intuitivamente, parece que isso deveria ser permitido.

Isso é um defeito no padrão ou estou esquecendo de algo? Existe uma razão específica para que a correspondência de escopo verifique apenas o fim, mas não o começo? A linguagem é a mesma desde C99, quando declarações em forloops foram introduzidas.

Abaixo está um exemplo reproduzível com um dataframe de teste:

dat<- structure(list(A = c(1.3, 1.5, 1.6, 1.2, 1.1, 1.2), 
                     B = c(0.25, 0.21, 0.21, 0.15, 0.26, 0.17)), 
                class = c("tbl_df", "tbl", "data.frame"), 
                row.names = c(NA, -6L))

Quero adicionar uma coluna com um valor inicial, digamos 1000, e então usar accumulate, mas dependendo de uma condição na coluna A.

Basicamente, se o valor na coluna A for superior ou igual a 1,2; Coluna C = 1000-(Coluna B * 1000). Mas isso é apenas para a primeira linha. Para o resto, em vez de 1000 (valor inicial), deve ser o valor anterior.

Minha saída desejada seria algo como isto:

(e assim a primeira linha deve ser 1000 se a coluna A for inferior a 1,2).

Tentei usar accumulate, mas não consigo fazer a parte condicional funcionar:

dat<-dat %>%
  mutate(C = accumulate(tail(B,-1), .f = ~ .x - (.x * .y), .init = 1000))

Ao preparar uma resposta para outra pergunta aqui , codifiquei uma consulta que continha múltiplas funções de janela com a mesma OVER(...)cláusula. Os resultados foram os esperados.

select ...
    sum(sum(s.price)) over (partition by p.productid
                            order by c.date
                            rows between 6 preceding and current row)
        / nullif(
             sum(count(s.price)) over(partition by p.productid
                                      order by c.date
                                      rows between 6 preceding and current row),
             0)
        as avg7DayPrice
...

Quando tentei substituir as OVER(...)cláusulas duplicadas por uma WINDOWreferência de cláusula compartilhada OVER Last7Days, definida posteriormente como WINDOW Last7Days AS (...), os resultados foram inesperadamente diferentes. (Consulte WINDOWcláusula - nova em 2022.)

select ...
    sum(sum(s.price)) over last7days
        / nullif(sum(count(s.price)) over last7days, 0)
        as avg7DayPrice
...
window last7days as (partition by p.productid
                     order by c.date
                     rows between 6 preceding and current row)

Consulta original completa:

-- Inline window over() clauses
-- Results are as expected
with calendar as (
    select min(date) as date, max(date) as endDate
    from sales
    union all
    select dateadd(day, 1, date), endDate
    from calendar
    where date < enddate
),
products as (
    select distinct productid
    from sales
)
select
    p.productid,
    c.date as salesDate, 
    avg(price) as avg1DayPrice,
    sum(sum(s.price)) over (partition by p.productid
                            order by c.date
                            rows between 6 preceding and current row)
        / nullif(
             sum(count(s.price)) over(partition by p.productid
                                      order by c.date
                                      rows between 6 preceding and current row),
             0)
        as avg7DayPrice
from calendar c
cross join products p
left join sales s
    on s.date = c.date
    and s.productid = p.productid
group by p.productid, c.date

Consulta modificada completa:

-- Reference to common defined window clause
-- Expect same results, but that is not what I get.
with calendar as (
    select min(date) as date, max(date) as endDate
    from sales
    union all
    select dateadd(day, 1, date), endDate
    from calendar
    where date < enddate
),
products as (
    select distinct productid
    from sales
)
select
    p.productid,
    c.date as salesDate, 
    avg(price) as avg1DayPrice,
    sum(sum(s.price)) over last7days
        / nullif(
             sum(count(s.price)) over last7days,
             0)
        as avg7DayPrice
from calendar c
cross join products p
left join sales s
    on s.date = c.date
    and s.productid = p.productid
group by p.productid, c.date
window last7days as (partition by p.productid
                     order by c.date
                     rows between 6 preceding and current row)

Tabela de vendas:

Resultados originais:

Resultados modificados:

Veja este db<>fiddle .

Não entendo por que os resultados são diferentes. Parece que a sum(count(s.price)) over(...)parte do cálculo é 1, 3, 4para a primeira consulta, mas 4, 4, 4na segunda. O plano de execução também é significativamente diferente. Alguém pode explicar isso?

Tenho um código semelhante a este, que não compilaria com Rust v < 1.83.0

fn main() {
    let result: Result<(), String> = Err("Something went wrong".to_string());
    
    let status = match result {
        Ok(()) => "✅", // Success
        Err(err) => &format!("❌ {:?}", err),  // Failure (this line causes an error)
    };

    println!("{}", status);
}

Erro:

error[E0716]: temporary value dropped while borrowed
   --> tests/integration_tests.rs:143:26
    |
141 |         let status = match result.result {
    |             ------ borrow later stored here
142 |             Ok(()) => "✅", // Success
143 |             Err(err) => &format!("❌ {:?}", err),  // Failure
    |                          ^^^^^^^^^^^^^^^^^^^^^^-
    |                          |                     |
    |                          |                     temporary value is freed at the end of this statement
    |                          creates a temporary value which is freed while still in use

Após a atualização para o Rust 1.83.0, este código agora compila corretamente.

Dei uma olhada nos últimos changelogs do Rust em busca de uma explicação, mas não consegui encontrar nada que parecesse relevante.

Não tenho certeza de qual versão do Rust a mensagem de erro vem, exceto que é inferior a 1.83.0

Alguém pode apontar a mudança na linguagem Rust que permite a compilação deste código?

(O que aconteceu é que eu tinha esse código em outra máquina onde estava funcionando bem. Enviei-o para outra máquina com uma versão anterior do Rust. Quando tentei compilar, recebi o erro acima. Eu o "consertei" atualizando o Rust para a versão estável mais recente.)

Se houver, std::map<std::pair<std::string, std::string>, some_type>qual é a melhor maneira de encontrar seus valores?

Acho que o mais óbvio é fazer algo assim: map.find(std::make_pair(str1, str2)); mas isso levará a uma construção de cópia das strings str1e str2durante a construção do par.

Eu esperava que talvez map.find(std::make_pair(std::ref(str1), std::ref(str2)));pudesse ajudar, mas infelizmente não, isso ainda produz cópias de strings.

map.find(std::make_pair(std::move(str1), std::move(str2))deve funcionar, mas vamos supor que essas strings ( str1, str2) sejam const ou não devam ser movidas.

Então, estou perguntando se existe alguma outra maneira de fazer uma pesquisa no mapa sem fazer cópias redundantes de strings.

(Observe que usar std::string_viewfor the std::map keyNÃO é uma opção, pois o mapa deve possuir suas strings.)

Preciso definir um modelo C++ que aceite várias coordenadas 3D como parâmetros. Quando todas as dimensões destas coordenadas são definidas como variáveis ​​inteiras separadas, a lista de parâmetros se tornaria excessivamente longa - 3 coordenadas precisam de 9 parâmetros, o que torna o modelo difícil de usar.

Portanto, é altamente desejável declarar os modelos de forma a usar matrizes em tempo de compilação. Seus argumentos padrão também devem ser declarados diretamente no local da declaração do modelo como valores, em vez de nomes de variáveis.

Após algumas experiências, para minha surpresa, descobri que o GCC 13 aceitará o seguinte programa C++ com std=c++20:

#include <cstdio>
#include <array>

template <
    std::array<int, 3> offset = {0, 0, 0}
>
struct Array
{
    void operator() (int i, int j, int k) 
    {
        printf("(%d, %d, %d)\n", i + offset[0], j + offset[1], k + offset[2]);
    }
};

int main(void)
{
    Array arr_default;
    arr_default(0, 0, 0);

    Array<{1, 1, 1}> arr;
    arr(0, 0, 0);

    return 0;
}

No entanto, o clang 18 rejeita a lista de inicialização com chaves como inválida:

test2.cpp:5:30: error: expected expression
    5 |         std::array<int, 3> offset = {0, 0, 0}
      |                                     ^
test2.cpp:17:8: error: no viable constructor or deduction guide for deduction of template arguments of 'Array'
   17 |         Array arr_default;
      |               ^
test2.cpp:7:8: note: candidate template ignored: couldn't infer template argument 'offset'
    7 | struct Array
      |        ^
test2.cpp:7:8: note: candidate function template not viable: requires 1 argument, but 0 were provided
    7 | struct Array
      |        ^~~~~
test2.cpp:20:8: error: expected expression
   20 |         Array<{1, 1, 1}> arr;
      |               ^
3 errors generated.

Pergunta

1. É realmente um programa C++ legal? Se for, que sintaxe devo usar para convencer o clang a aceitá-lo? Caso contrário, devo relatar um bug do GCC por aceitá-lo inquestionavelmente?

2. Existe uma forma alternativa e mais compatível de atingir meus objetivos? O uso std::arraynão é necessário, quaisquer outros métodos com efeito equivalente também são aceitáveis.