All perguntas(coding)

Esta é uma continuação desta pergunta: Por que posso chamar um callable que é referenciado por constante e onde o callable real é um lambda mutável?

Posso imitar a conversão implícita de um fechamento mutável const para um ponteiro de função quando ele é chamado assim:

#include <iostream>

void dummy() { std::cout << "call dummy\n";}

using fptr = void(*)();

struct callable {
    void operator()() {std::cout << "call callable\n"; }
    operator fptr() const { 
        std::cout << "convert\n";
        return &dummy; 
    }
};

int main()
{
    auto exec = []( auto const &fn ) { 
        std::cout << "call\n";
        fn(); 
    }; 
    exec( callable{} );
}

Demonstração ao vivo

Não entendo por que a conversão implícita é acionada. Ela não ocorre ao passar o argumento (o argumento é deduzido, portanto, não leva em consideração a conversão implícita), mas apenas quando ()é invocada, como evidenciado pela saída:

call
convert
call dummy

Tentei experimentar para entender o que estava acontecendo. Tentar algo semelhante com um operador diferente não funcionou (como esperado):

#include <iostream>

struct bar {
    void operator+(int) const { std::cout << "bar\n"; };   
};

struct foo {
    void operator+(int) { std::cout << "foo\n"; }
    operator bar() const { return  {}; }
};

int main() {
    auto exec = []( auto const &fn ) { 
        std::cout << "call\n";
        fn + 42; 
    }; 
    exec(foo{});
};

erro :

<source>:15:12: error: passing 'const foo' as 'this' argument discards qualifiers [-fpermissive]
   15 |         fn + 42;
      |         ~~~^~~~

O que há de especial no operador de chamada? Como é possível que ele fn()converta implicitamente fnpara chamar outra coisa?

PS: Enquanto isso, descobri que deve estar relacionado à conversão para ponteiro de função, porque quando transformo o primeiro exemplo em algo mais parecido que o segundo, recebo o erro esperado:

#include <iostream>

struct foo {
    void operator()() const { std::cout << "call foo\n"; }

};

struct callable {
    void operator()() {std::cout << "call callable\n"; }
    operator foo() const { return {}; };
};

int main()
{
    auto exec = []( auto const &fn ) { 
        std::cout << "call\n";
        fn(); 
    }; 
    exec( callable{} );
}

Agora recebo o erro esperado

<source>:17:11: error: no match for call to '(const callable) ()'
   17 |         fn();
      |         ~~^~

Agora a questão é: O que há de especial nas conversões para o tipo de ponteiro de função?

Parece que fn()leva em conta conversões para ponteiros de função. Por quê?

Esta questão vem de uma tentativa de entender a "filosofia C" e não de nenhum "problema real".

Suponha que em um programa C eu use sin(x):

#include <stdio.h>

int main() {
  char s[20] = "aha";
  printf("%f", sin(s));
  return 0;
}

Cometi dois erros deliberadamente:

1. Não #includeeditei math.h (nem forneci nenhuma declaração para pecado).
2. Eu fiz sum tipo char *(apenas algo que não pode ser convertido significativamente para um double).

Eu compilo usando GCC com o -lmsinalizador.

Como esperado, recebo um aviso e um erro.

Claro, há o aviso de declaração implícita de função blá blá blá:

bad.c: In function ‘main’:

bad.c:5:15: warning: implicit declaration of function ‘sin’ [-Wimplicit-function-declaration]
    5 |   printf("%f", sin(s));
      |                ^~~
bad.c:5:16: warning: incompatible implicit declaration of built-in function ‘sin’
bad.c:2:1: note: include ‘<math.h>’ or provide a declaration of ‘sin’
    1 | #include <stdio.h>
  +++ |+#include <math.h>

Uma pequena pesquisa parece indicar que se uma função não for declarada previamente, então C assume uma "declaração padrão" (a chamada "declaração implícita") que é como int undeclaredfunction(void).

Mas também recebo o seguinte erro:

    2 |
bad.c:5:19: error: incompatible type for argument 1 of ‘sin’
    5 |   printf("%f", sin(s));
      |                    ^
      |                    |
      |                    char *
bad.c:5:20: note: expected ‘double’ but argument is of type ‘char *’

Isso mostra que a "declaração implícita" espera um argumento do tipo double.

1. Parece que C mantém uma lista de "declarações implícitas" corretas para "funções padrão". Onde posso encontrar a lista abrangente de tais declarações implícitas corretas para um determinado compilador (digamos gccou clang)?
2. Se C já tem as declarações corretas das funções matemáticas padrão incorporadas, então por que ele espera que o programador as tenha #include<math.h>? Só por tradição? Ou por limpeza?

A(s) resposta(s) que procuro são sobre as regras exatas usadas pelo compilador, e não sobre comentários subjetivos sobre "boas práticas de programação".

Eu tenho uma classe modelo que tem uma função ( myfunc()) que faz o mesmo em todos os casos, Texceto em alguns casos (por exemplo, bool). Eu tenho uma solução funcional, com base nesta pergunta :

template <class T> class opt_arg{
    private: void myfunc(){
     /*Do generic stuff */
    }

/* Can I insert here the bool specialization? */

};

/* The specialization "inserted outside of the class body": */
template<>
 inline void opt_arg<bool>::myfunc(){
    /* Do bool specific stuff*/
 }

Como mencionei, está funcionando bem. Só estou pensando, posso inserir a especialização de função dentro do "corpo da classe"?

O cppreference menciona que se a inicialização contiver uma parte de inicialização dinâmica, o programa ficará malformado ao usar constinit em C++20.

Só me pergunto por que o código a seguir compila então:

constinit std::string str = "Hello";

Como a std::stringclasse envolve alocação dinâmica de memória para armazenar caracteres, parece contraditório. Isso não deveria ser proibido devido à parte dinâmica?

Tentei compilar com sinalizadores -std=C++20e o programa compila bem, o que não deveria acontecer.

"arg" é uma referência universal/de encaminhamento ou uma referência de rvalue?

template<auto&& arg>
struct test {};

Estamos atualizando nosso aplicativo do .NET Framework 4.8 para o .NET 8.

Durante os testes de regressão, notamos que as conversões de ampliação implícitas parecem ocorrer em uma ordem diferente, resultando em algumas alterações nos resultados.

Parece que no .NET Framework, uma operação como: primeirod1= f1 * f2 converterá e para doubles antes de executar a multiplicação, enquanto no .NET 8 a multiplicação entre floats será realizada primeiro e então o alargamento ocorrerá.f1f2

Estou ciente do comportamento da matemática binária de ponto flutuante. Não estou tentando afirmar que uma delas está "errada" - mais tentando entender por que o comportamento foi alterado.

E: Existe alguma maneira de alterar temporariamente o comportamento do .NET 8 de volta para o comportamento do .NET Framework para que possamos entender melhor nosso teste de regressão?

(PS: sim, estou ciente de que isso não seria um problema se não tivéssemos as conversões implícitas em primeiro lugar. Mas esta é uma grande base de código legada e não posso alterá-la facilmente.)

Código de teste do aplicativo de console:

Console.WriteLine(".NET 8");

Console.WriteLine("Input Float: 0.3333333F");
float f1 = 0.3333333F;
Console.WriteLine("Decimal: " + f1.ToString());
Console.WriteLine("Binary: " + GetFloatBinary(f1));
Console.WriteLine();

Console.WriteLine("Float multiplication first, then conversion");
Console.WriteLine("f2 = f1 * f1");
float f2 = f1 * f1;
Console.WriteLine("Decimal: " + f2.ToString());
Console.WriteLine("Binary: " + GetFloatBinary(f2));
Console.WriteLine("d1 = (double)f2");
double d1 = (double)f2;
Console.WriteLine("Decimal: " + d1.ToString());
Console.WriteLine("Binary: " + GetDoubleBinary(d1));
Console.WriteLine();

Console.WriteLine("Conversion first, multiplication second");
Console.WriteLine("d2 = (double)f1 * (double)f1");
double d2 = (double)f1 * (double)f1;
Console.WriteLine("Decimal: " + d2.ToString());
Console.WriteLine("Binary: " + GetDoubleBinary(d2));
Console.WriteLine();

Console.WriteLine("Let the platform decide");
Console.WriteLine("d3 = f1 * f1");
double d3 = f1 * f1;
Console.WriteLine("Decimal: " + d3.ToString());
Console.WriteLine("Binary: " + GetDoubleBinary(d3));
Console.WriteLine();

Console.ReadLine();

static string GetFloatBinary(float value)
{
    const int bitCount = sizeof(float) * 8;
    int intValue = System.BitConverter.ToInt32(BitConverter.GetBytes(value), 0);
    return Convert.ToString(intValue, 2).PadLeft(bitCount, '0');
}

static string GetDoubleBinary(double value)
{
    const int bitCount = sizeof(double) * 8;
    int intValue = System.BitConverter.ToInt32(BitConverter.GetBytes(value), 0);
    return Convert.ToString(intValue, 2).PadLeft(bitCount, '0');
}

Resultados:

.NET FRAMEWORK
Input Float: 0.3333333F
Decimal: 0.3333333
Binary: 00111110101010101010101010101010

Float multiplication first, then conversion
f2 = f1 * f1
Decimal: 0.1111111
Binary: 00111101111000111000111000110111
d1 = (double)f2
Decimal: 0.111111097037792
Binary: 0000000000000000000000000000000011100000000000000000000000000000

Conversion first, multiplication second
d2 = (double)f1 * (double)f1
Decimal: 0.111111097865635
Binary: 0000000000000000000000000000000011100011100011100011100100000000

Let the platform decide
d3 = f1 * f1
Decimal: 0.111111097865635
Binary: 0000000000000000000000000000000011100011100011100011100100000000

.NET 8
Input Float: 0.3333333F
Decimal: 0.3333333
Binary: 00111110101010101010101010101010

Float multiplication first, then conversion
f2 = f1 * f1
Decimal: 0.1111111
Binary: 00111101111000111000111000110111
d1 = (double)f2
Decimal: 0.1111110970377922
Binary: 0000000000000000000000000000000011100000000000000000000000000000

Conversion first, multiplication second
d2 = (double)f1 * (double)f1
Decimal: 0.11111109786563489
Binary: 0000000000000000000000000000000011100011100011100011100100000000

Let the platform decide
d3 = f1 * f1
Decimal: 0.1111110970377922
Binary: 0000000000000000000000000000000011100000000000000000000000000000

Acho que entendi claramente o que mudou, mas não consigo encontrar nenhuma documentação sobre o porquê.

Obrigado por qualquer informação!

Estou trabalhando em R e preferiria uma solução dplyr, se possível.

dados de amostra:

data.frame(
  col1 = c("a", "b", "c", "d"),
  col2 = c("a", "b", "d", "a"),
  col3 = rep("a", 4L),
  col4 = c("a", "b", "d", "a"),
  col5 = c("a", "a", "c", "d"),
  col6 = rep(c("b", "a"), each = 2L)
)

Pergunta

Gostaria de saber para cada linha se col1, col2 e col3 são iguais a col4, col5 e col6, mas a ordem de col1 - col3 e col4 - col6 deve ser ignorada.

Portanto, para a linha 1, se col1 - col3 contivesse a,a,b respectivamente, e col4 - col6 contivesse b,a,a respectivamente, isso seria considerado uma correspondência.

Resultado desejado

Coloquei uma nota na coluna "avaliação" para ajudar na compreensão

Eu li isso

Promoção integral: pré-valores de tipos integrais pequenos (como char) podem ser convertidos em pré-valores de tipos integrais maiores (como int). - primeira linha
[...detalhes - não importante...]
Observe que todas as outras conversões não são promoções; por exemplo, a resolução de sobrecarga escolhe char -> int (promoção) em vez de char -> short (conversão). - linha final.

A conversão de char -> int é 'promotion' ; está claro (de um byte para 4 bytes)
A ​​conversão de char -> short é 'não promoção'; por que?
Tenho pensado que char tem um byte e short (short int) tem dois bytes. Por que não é considerado uma promoção? Parece contradizer a primeira linha - não significa que 'converter do tipo pequeno para o tipo maior' é promoção? )
-----Editar: depois de procurar algumas respostas:
Podemos considerar "uma promoção é um caso especial de conversão"? , podemos dizer "todas as promoções são conversões, mas nem todas as conversões são promoções"?
Ou deveríamos considerá-los como dois conceitos diferentes e separados?

Considere a seguinte valarrayclasse -like:

#include <stdlib.h>

struct va
{
    void add1(const va& other);
    void add2(const va& other);

    size_t* data;
    size_t  size;
};

void va::add1(const va& other) {
    for (size_t i = 0; i < size; ++i) {
        data[i] += other.data[i];
    }
}

void va::add2(const va& other){
    for (size_t i = 0, s = size; i < s; ++i) {
        data[i] += other.data[i];
    }
}

A add2função é vetorizada para diferentes compiladores (MSVC, Clang, GCC, ICC), enquanto add1não é. Veja https://godbolt.org/z/c61qvrrbv

Isso é explicado pelo possível aliasing: os compiladores não podem provar que um dos elementos apontados por datanão é o sizepróprio.

No entanto, também há sobreposição potencial de elementos apontados por datae other.data. Para o MSVC, existe o potencial de aliasing desses elementos e ponteiros, pois não tira proveito da Strict Aliasing Rule. Isso se aplica a ambos add1e add2.

Os compiladores estão realizando verificações para todos os possíveis aliasing que suspeitam e executam operações vetorizadas para arquivos add2.

Por que eles não estão adicionando mais verificações e tendo essa otimização para add1?

Na Referência do CPP consta que:

std::byteé um tipo distinto que implementa o conceito de byte conforme especificado na definição da linguagem C++.

Assim como char e unsigned char, ele pode ser usado para acessar a memória bruta ocupada por outros objetos ( representação de objeto ), mas ao contrário desses tipos, não é um tipo de caractere e não é um tipo aritmético. Um byte é apenas uma coleção de bits e apenas operadores bit a bit são definidos para ele .

Mas isso não é verdade: como é um tipo de enumeração, as operações de comparação ( <, <=, >, >=, ==, !=) também são possíveis.

Isso é intencional, por exemplo, para usar std::bytetambém como uma chave para std::map, etc.?