All perguntas(coding)

Enquanto aprendia sobre como as macros funcionam, tentei definir uma macro que funcionasse com diferentes tipos de dados sem ter que definir vários tipos. Eu costumava _Generictornar essa tarefa mais fácil. No entanto, depois que não funcionou, mesmo depois de fazer alterações várias vezes, pedi ao deepseek para descobrir, o que eventualmente resultou nisso:

#define FOO(var) _Generic((var), \
    int:    printf(#var " = %d\n", (int)(var)), \
    double: printf(#var " = %lf\n", (double)(var)), \
    long:   printf(#var " = %ld\n", (long)(var)), \
    char:   printf(#var " = '%c'\n", (char)(var)), \
    float:  printf(#var " = %f\n", (float)(var)), \
    default:printf(#var " = unknown type\n"))

int main(void) {
    int a = 3;
    FOO(a); // correctly prints "a = 3"
}

Em outros exemplos de código na referência cpp e no SO, nunca vi ninguém tendo que fazer typecast para fazer isso funcionar. Remover os typecasts ( int: printf(#var " = %d\n",(var)), \...) mostra um aviso "O formato especifica o tipo 'long', mas o argumento tem o tipo 'int'" e fornece um aviso de compilação ( -Wallhabilitado):

ue_05.c: In function ‘main’:
ue_05.c:47:14: warning: format ‘%lf’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
   47 |         FOO(a);
      |              ^
ue_05.c:27:25: note: in definition of macro ‘FOO’
   27 |         double: printf(#var " = %lf\n", (var)), \
      |                         ^~~
ue_05.c:47:14: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 2 has type ‘int’ [-Wformat=]
   47 |         FOO(a);
      |              ^
ue_05.c:28:25: note: in definition of macro ‘FOO’
   28 |         long:   printf(#var " = %ld\n", (var)), \
      |                         ^~~
ue_05.c:47:14: warning: format ‘%f’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
   47 |         FOO(a);
      |              ^
ue_05.c:30:25: note: in definition of macro ‘FOO’
   30 |         float:  printf(#var " = %f\n", (var)), \

Não consegui descobrir por que o typecast é necessário aqui e o deepseek também não conseguiu esclarecer as coisas.

Por que o typecast é necessário aqui e onde ele está documentado?

Como posso usar uma expressão regular localizar/substituir para quebrar em novas linhas para nunca ter mais de 20 símbolos por linha?

Eu encontrei isto:

Find: \s(?<=.{20})
Replace: $0\r\n

Seria perfeito, mas deixa palavras na linha maiores que 20 símbolos se elas começaram antes de 20 símbolos.

Preciso de uma expressão semelhante, mas se o último item torna a linha maior, ele também deve ir para a nova linha, então a linha final sempre terá <20 símbolos.

Eu sei que já fiz isso há muito tempo, talvez com algum plugin, mas não consigo fazer funcionar agora. Como posso fazer isso?

Gostaria de calcular uma nova coluna em um dataframe que encontre n valores consecutivos não sendo nulos e adicione uma enumeração a ela, por grupo de usuários. Seja df nosso dataframe de exemplo:

n <- 4

# Sample DataFrame
df <- tibble(
  user_id = c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2),
  date = as.Date('2024-01-01') + 0:19,
  value1 = c(NA, 5, 6, 7, 8, NA, NA, 2, 3, 4, 5, NA, 1, 2, 3, NA, 1, 2, 3, 4)
)

Resultado esperado:

# A tibble: 20 × 4
   user_id date       value1 expected_result
     <dbl> <date>      <dbl>           <dbl>
 1       1 2024-01-01     NA              NA
 2       1 2024-01-02      5               1
 3       1 2024-01-03      6               2
 4       1 2024-01-04      7               3
 5       1 2024-01-05      8               4
 6       1 2024-01-06     NA              NA
 7       1 2024-01-07     NA              NA
 8       1 2024-01-08      2               5
 9       1 2024-01-09      3               6
10       1 2024-01-10      4               7
11       1 2024-01-11      5               8
12       1 2024-01-12     NA              NA
13       2 2024-01-13      1              NA
14       2 2024-01-14      2              NA
15       2 2024-01-15      3              NA
16       2 2024-01-16     NA              NA
17       2 2024-01-17      1               1
18       2 2024-01-18      2               2
19       2 2024-01-19      3               3
20       2 2024-01-20      4               4

De acordo com o Padrão C :

Cada tipo complexo tem os mesmos requisitos de representação e alinhamento de um tipo de matriz contendo exatamente dois elementos do tipo real correspondente; o primeiro elemento é igual à parte real e o segundo elemento à parte imaginária do número complexo.

Dessa forma, é possível lançar com segurança a _Complex float *em a float *e então acessar os componentes reais/imaginários usando o float *? Ou isso ainda violaria tecnicamente o aliasing estrito e, portanto, invocaria um comportamento indefinido?

_Complex float c;

((float *)&c)[0] = 1;
((float *)&c)[1] = 2;

c; // 1 + 2i

Sabemos que esse main()é o ponto de entrada de um programa em C. Mas o que acontece se definirmos maincomo uma macro, assim?

#define main something_else

• O programa será compilado e executado corretamente?
• Como diferentes compiladores lidam com essa situação?
• Há casos em que redefinir maincomo uma macro pode ser útil ou problemático?

Estou tentando validar vários parâmetros de configuração, idealmente relatando todos os problemas em uma única passagem. Isso assume um formato semelhante a:

var isValid = true;
if (arg1 == null)
{
    // logger.LogError...
    isValid = false;
}
if (arg2 == null)
{
    // logger.LogError...
    isValid = false;
}
if (!isValid)
{
    return;
}

arg1.DoSomething(); // possible null warning

Agora, se eu abortar individualmente quando um único argumento for nulo, não há problema: a análise nula detecta com sucesso que isso foi verificado e não precisa avisar. Infelizmente, isso significa que não posso relatar vários erros de uma vez, e o usuário precisará fazer vários ciclos de edição-execução para resolver todos os problemas.

Alternativamente, posso ignorar forçosamente avisos nulos com o operador null-forgiving ( !). Mas isso me deixa vulnerável a realmente esquecer uma verificação nula ou remover uma acidentalmente mais tarde.

Posso ter meu bolo e comê-lo também? Existe um padrão mais organizado para fazer validação de múltiplos argumentos sem sacrificar a análise de nulidade?

Exemplo completo:

using System;

#nullable enable

public class Program
{
    public static void Main()
    {       
        Warning();
        NoWarning();
    }
    
    public static void Warning()
    {
        string? canBeNull = Random.Shared.Next(2) == 1 ? "not-null" : null;
        string? canBeNull2 = Random.Shared.Next(2) == 1 ? "not-null" : null;
        
        var isValid = true;
        
        if (canBeNull == null)
            isValid = false;
        
        if (canBeNull2 == null)
            isValid = false;
        
        if (!isValid)
            return;
        
        Console.WriteLine(canBeNull.Length);
    }
    
    public static void NoWarning()
    {
        string? canBeNull = Random.Shared.Next(2) == 1 ? "not-null" : null;
        string? canBeNull2 = Random.Shared.Next(2) == 1 ? "not-null" : null;
        
        if (canBeNull == null)
            return;
        
        if (canBeNull2 == null)
            return;
        
        Console.WriteLine(canBeNull.Length);
    }
}

Tenho escrito alguns testes para aritmética de números complexos.

Tentei escrevê-los de uma forma em que não preciso reescrever uma seção de código para cada operador. Estou tentando armazenar std::complexoperadores sobrecarregados como operator+, operator+=, operator-, operator-=em uma std::functionvariável. A razão pela qual preciso dos std::complexoperadores é porque preciso verificá-los em relação à minha própria implementação de números complexos.

No entanto, não consigo fazê-lo funcionar, principalmente porque parece haver uma incompatibilidade entre o tipo da variável ( std::function) e o tipo do valor ( std::complexoperadores). Como devo escrever o código para poder armazenar essas funções de operador em uma std::functionvariável?

Esta é minha tentativa, mas infelizmente não funciona:

std::function<void(std::complex<double>&, const std::complex<double>&)> var = 
                                               &std::complex<double>::operator+=;

Tenho uma função personalizada usando modelos Go da seguinte forma:

"listOperate": func(lst []string, fn func(string) string) (result []string) {
    result = make([]string, len(lst))
    for i, item := range lst {
        result[i] = fn(item)
    }
    return result
},

Tenho outra função que opera em uma string:

"toCamel": func(str string) (result string) {
        return strcase.ToCamel(str)
    }

Como posso chamar a primeira função, usando a segunda como parâmetro?

O copiloto me dá o seguinte

{{ listOperate . toCamel}}

o que faz sentido, mas não consegue analisar o erro

at <toCamel>: wrong number of args for toCamel: want 1 got 0" (template.ExecError)

o que sugere que ele está tentando executar a função em vez de passá-la. O Google me dá muitas informações sobre funções personalizadas, mas nada responde a esse problema.

Usamos o MASKEDrecurso de coluna no SQL Server para ocultar dados confidenciais ao consultar. Mas nos deparamos com um cenário em que o INSERTexecutado como parte da MERGEinstrução é inserir um valor mascarado . Ou seja, o valor recém-inserido é visto como o valor mascarado, mesmo ao consultar a tabela como um usuário com a UNMASKpermissão.

Especificamente, o cenário ocorre quando:

1. Uma coluna é MASKED.
2. O usuário atual não tem UNMASKpermissão.
3. A cláusula MERGEda declaração ONusa a MASKEDcoluna.
4. A MERGEdeclaração não corresponde, então cai na INSERTseção.

Abaixo está uma reprodução mínima do problema.

-- Define a test table with one non-masked and one masked column.
CREATE TABLE TestTable(
     C1 NVARCHAR(100) MASKED WITH (FUNCTION = 'default()'),
     C2 NVARCHAR(100) MASKED WITH (FUNCTION = 'default()'),
     C3 NVARCHAR(100) -- Not masked
);

INSERT INTO TestTable
VALUES ('aaa', 'aaa', 'aaa'), ('bbb', 'bbb', 'bbb')

-- Print the current user and initial table content
SELECT SUSER_NAME() AS LoginName, USER_NAME() AS UserName;
SELECT *, 'No columns should be Masked' FROM TestTable

-- Create users with different permissions
CREATE USER user1 WITHOUT LOGIN
-- Setup permissions (No UNMASK permissions)
GRANT SELECT, UPDATE, INSERT TO user1;   

-- Switch context to the user WITHOUT UNMASK permissions
EXECUTE AS USER = 'user1';  

-- Show the user can only see masked data
SELECT SUSER_NAME() AS LoginName, USER_NAME() AS UserName;
SELECT *, 'Columns 1 & 2 should be Masked' FROM TestTable

-- Execute the merge, matching on the masked column
MERGE TestTable target
USING (
    SELECT * FROM (VALUES 
        ('bbb', 'bbb', 'bbb'), -- Will be merged
        ('ccc', 'ccc', 'ccc'), -- Will be inserted
        ('ddd', 'ddd', 'ddd')) -- Will be inserted
        AS s (C1 ,C2 ,C3)
) AS source
ON (source.C1 = target.C1)
WHEN MATCHED THEN UPDATE SET
    target.C2 = source.C2,
    target.C3 = source.C3
WHEN NOT MATCHED BY TARGET
  THEN INSERT (C1, C2, C3)
  VALUES (source.C1, source.C2, source.C3);

-- A regular insert statement to check if masking applies there
INSERT INTO TestTable
VALUES ('eee', 'eee', 'eee')

-- Print the current user and current table content
SELECT SUSER_NAME() AS LoginName, USER_NAME() AS UserName;
SELECT *, 'Columns 1 & 2 should be Masked' FROM TestTable

REVERT; -- Back to the session user context

-- Print the current user and current table content 
SELECT SUSER_NAME() AS LoginName, USER_NAME() AS UserName;
SELECT *, 'No columns should be Masked' FROM TestTable
  
-- Tidy up
DROP TABLE TestTable;
DROP USER user1;

O resultado da última SELECTdeclaração é mostrado abaixo. Este select está sendo executado como um usuário que tem a UNMASKpermissão, mas as duas linhas inseridas por um usuário sem essa permissão ainda têm a coluna usada como uma chave no MERGEaparentemente mascarado. Eu suspeito que seja porque o valor mascarado foi inserido durante o MERGE, em vez de qualquer problema com permissões.

Este é um problema conhecido? Ou estou fazendo algo errado?

Tenho um problema que se resume a um exemplo como este:

#include <cstdlib>
#include <utility>

// class that is constructible from a `float` array type
struct data
{
    template <size_t N>
    data(float (&arr)[N]) { }
};

// function that takes an instance of `data`
void direct(data) { }
// pointer to the above function
void (*func_ptr)(data) = &direct;

// forward the argument to the function directly
template <typename T>
void call_direct(T && t)
{
    return direct(std::forward<T>(t));
}

// forward the argument to the function invoked via pointer
template <typename T>
void call_via_ptr(T && t)
{
    return (*func_ptr)(std::forward<T>(t));
}

int main()
{
    float arr[4];

    call_direct(arr);
    call_via_ptr(arr);
}

Ou seja, eu tenho uma função direct()que recebe um argumento do tipo data. dataé construtível a partir de um array de estilo C de comprimento fixo. Eu tenho outro par de funções, call_direct()e call_via_ptr(), que encaminham seu único argumento de modelo para a função, seja invocando-a diretamente ou por meio de um ponteiro de função.

A call_direct()abordagem funciona bem. No entanto, ele call_via_ptr() falha ao compilar em versões do gcc até 14.2 , gerando um erro como:

<source>: In instantiation of 'void call_via_ptr(T&&) [with T = float (&)[4]]':
<source>:35:17:   required from here
   35 |     call_via_ptr(arr);
      |     ~~~~~~~~~~~~^~~~~
<source>:27:39: error: could not convert '(float*)std::forward<float (&)[4]>((* & t))' from 'float*' to 'data'
   27 |     return (*func_ptr)(std::forward<T>(t));
      |                        ~~~~~~~~~~~~~~~^~~
      |                                       |
      |                                       float*

No entanto, ele compila bem em todas as versões do clang que testei.

Parece que ao chamar a função por meio de um ponteiro de função, o argumento array está decaindo para um float *, que não é conversível para data, daí o erro. No entanto, não está claro para mim por que o decaimento do ponteiro funcionaria de forma diferente entre os dois casos.

Existe algum ajuste que eu possa fazer aqui para permitir que isso seja construído no gcc? Qual compilador está correto aqui?