Fullaccess's questions

Dado o código a seguir que tenta alocar uma captura lambda no heap:

#include <array>
int test(void) {
    //auto big_lambda = new auto([d = std::array<int, 1024>{5,1,2}]() { return d[2]; });
    auto big_lambda = new auto(std::move([d = std::array<int, 1024>{5,1,2}]() { return d[2]; }));
    auto res = (*big_lambda)();
    delete big_lambda;
    return res;
}

Por que encapsular o lambda std::movecria a captura na pilha? É porque std::move"materializa" o lambda temporário antes de ser passado para o construtor de movimento (acho?)?

Considerando que o PostgreSQL não oferece garantias quanto à ordem em que os operandos são avaliados, essa expressão poderia retornar UNKNOWN se a última condição fosse avaliada antes da do meio?

"TradeOffer".status = 'Pending' AND
"TradeOffer".expiration_date IS NOT NULL AND
CURRENT_TIMESTAMP > "TradeOffer".expiration_date

Código em questão ( godbolt )

#include <stdbool.h>
void do_work(void);

typedef struct task {
    int timer;
    void (*job)(void);
} task_t;

typedef struct task_list {
    task_t *tasks;
    int length;
} task_list_t;

void test(task_list_t *task_list)
{
    for (int i = 0; i < task_list->length; i++)
    {
        task_t *task = &task_list->tasks[i];
        __attribute__((assume(task->timer > 0)));
        task->timer--;
        bool timer_finished = task->timer <= 0;
        if (timer_finished)
            task->job();
    }
}

Recebo a seguinte saída:

<source>: In function 'test':
<source>:25:1: warning: assuming signed overflow does not occur when changing X +- C1 cmp C2 to X cmp C2 -+ C1 [-Wstrict-overflow]
   25 | }
      | ^
<source>:25:1: warning: assuming signed overflow does not occur when changing X +- C1 cmp C2 to X cmp C2 -+ C1 [-Wstrict-overflow]
Compiler returned: 0

Digamos que eu não consiga mudar task_t::timerpara um tipo não assinado. Por que o assume está sendo ignorado? Ou estou entendendo mal o aviso?

Primeiro de tudo, eu sei que isso é UB e, tecnicamente, qualquer coisa pode acontecer. Mas, em relação a esse trecho de código compilado com -O0 para o alvo x86_64-linux-gnu, por que isso nunca imprime "truthy"?

#include <stdio.h>
#include <stdbool.h>

int test(void) 
{
    bool value;
    if (value)
    {
        printf("truthy");
    }
    printf("Value: %d", value);
}

int main(void)
{
    double buffer[80000];
    buffer[10] = 0;
    test();
}

Parafuso de Deus

Eu esperaria que o valor fosse basicamente aleatório. O que estou esquecendo?

EDIT: Estou falando de C aqui, mas se houver alguma diferença com C++, também estou interessado nela.

Eu estava lendo sobre gramática de shell no manual e me deparei com o seguinte

Comandos simples
Um comando simples é uma sequência de atribuições de variáveis ​​opcionais seguidas por palavras separadas por espaços em branco e redirecionamentos, e terminadas por um operador de controle.

Então decidi testar isso com o seguinte script:

#!/usr/bin/bash
if myVar=hello [ "$myVar" ]; then echo "$myVar"; else echo fail "$myVar"; fi

$ ./test.sh 
fail

Não consigo ver por que isso falha, se meu entendimento do manual estiver correto, isso deve funcionar. Ao tentar esse script no ShellCheck, recebo o seguinte aviso:

SC2097 (aviso): Esta atribuição só é vista pelo processo bifurcado.

E a explicação é:

Em name=World cmd "$name", name=Worldé passado como parte do ambiente para cmd(ou seja, no envpparâmetro para execve(2)). Isso significa que cmde seus filhos verão o parâmetro, mas nenhum outro processo verá.

Onde esse comportamento está documentado no manual? Em nenhum lugar diz que as atribuições inline (acabei de inventar esse termo) são locais para o comando em que são declaradas. Além disso, isso não explica por que o script falha. Por essa lógica, [ deve ter acesso a myVar, executar o bloco then e o script não deve imprimir nada.

O que estou perdendo?