All perguntas(coding)

Um ponteiro não const para um elemento do array pode ser usado para acessar o array inteiro, o que exigiria que o compilador recarregasse quaisquer elementos do array buscados anteriormente na memória:

void use_value(int* a) {
  a[1] = 2; // change array pointed to by a
}
void do_thing() {
  int a[] = {1, 2, 3};
  calculate(a[1]); // do something with this value (presumably a[1] will be stored in a register)
  use_value(&a[0]);
  calculate(a[1]); // the compiler must now reload a[1] from memory
}

O que estou pensando é se esse problema ocorre se o ponteiro for alterado para uma referência:

void use_value(int& a) {
  (&a)[1] = 2; // is this UB?
}
void do_thing() {
  int a[] = {1, 2, 3};
  calculate(a[1]); // do something with this value (presumably a[1] will be stored in a register)
  use_value(a[0]);
  calculate(a[1]); // must the compiler now reload a[1] from memory?
}

Enquanto eu estava brincando com a função constexpr, me deparei com o seguinte problema.

Acessar membro inativo de union é um comportamento indefinido, eu sei. Mas há uma exceção para essa regra.

De acordo com o padrão C++23 [class.mem.general]/26,

Em uma união de layout padrão com um membro ativo (11.5) do tipo struct T1, é permitido ler um membro de dados não estático m de outro membro de união do tipo struct T2, desde que m faça parte da sequência inicial comum de T1 e T2; o comportamento é como se o membro correspondente de T1 fosse nomeado.

Portanto, de acordo com o padrão, o código a seguir tem um comportamento bem definido. (Observação: o código a seguir também foi retirado do padrão)

struct T1 { int a, b; };
struct T2 { int c; double d; };
union U { T1 t1; T2 t2; };
int f() {
    U u = { { 1, 2 } }; // active member is t1
    return u.t2.c; // OK, as if u.t1.a were nominated
}

Como o código acima é bem definido, ele deve ser avaliado em tempo de compilação.

Então preparei o seguinte código (Aqui está o link do explorador do compilador: https://godbolt.org/z/G4e3avMaz

#include <type_traits>

template <typename T, T value>
struct Test_Union {
    struct T1 {
        T item_1 ;
    } ;

    struct T2 {
        T item_1 ;
    } ;

    union Union {
        T1 t1 ;
        T2 t2 ;
    } ;

    static_assert(std::is_standard_layout_v<T1>) ;
    static_assert(std::is_standard_layout_v<T2>) ;
    static_assert(sizeof(T1) == sizeof(T2)) ;
    static_assert(sizeof(T1) == sizeof(Union)) ;

    static constexpr Union test_1 = {.t1 = {value}} ;

    constexpr T no_error_1 (void) {
        return test_1.t1.item_1 ;
    }

    constexpr T no_error_2 (void) {
        constexpr Union test_2 = {.t1 = {value}} ;
        return test_2.t1.item_1 ;
    }

    constexpr T error_1 (void) {
        return test_1.t2.item_1 ;
    }

    constexpr T error_2 (void) {
        constexpr Union test_2 = {.t1 = {value}} ;
        return test_2.t2.item_1 ;
    }
} ;

int main (void) {
    []() consteval {
        Test_Union<int, 123> test ;
        test.no_error_1() ;
    } () ;

    []() consteval {
        Test_Union<int, 123> test ;
        test.no_error_2() ;
    } () ;
    // consteval function is not a constant expression error
    []() consteval {
        Test_Union<int, 123> test ;
        test.error_1() ;
    } () ;

    // consteval function is not a constant expression error
    []() consteval {
        Test_Union<int, 123> test ;
        test.error_2() ;
    } () ;
}

Quando você compila o exemplo em g++ ou clang (eu fiz isso), você obtém um erro de tempo de compilação para os dois últimos consteval lambda que chamaram as funções error_1 e error_2.

As razões são semelhantes. Para clang:

<source>:55:5: error: call to consteval function 'main()::(anonymous class)::operator()' is not a constant expression
   55 |     []() consteval {
      |     ^
<source>:35:16: note: read of member 't2' of union with active member 't1' is not allowed in a constant expression
   35 |         return test_1.t2.item_1 ;
      |                ^
<source>:57:9: note: in call to 'test.error_1()'
   57 |         test.error_1() ;
      |         ^~~~~~~~~~~~~~
<source>:55:5: note: in call to '[]() {
    Test_Union<int, 123> test;
    test.error_1();
}.operator()()'
   55 |     []() consteval {
      |     ^~~~~~~~~~~~~~~~
   56 |         Test_Union<int, 123> test ;
      |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~
   57 |         test.error_1() ;
      |         ~~~~~~~~~~~~~~~~
   58 |     } () ;
      |     ~~~~
<source>:60:5: error: call to consteval function 'main()::(anonymous class)::operator()' is not a constant expression
   60 |     []() consteval {
      |     ^
<source>:40:16: note: read of member 't2' of union with active member 't1' is not allowed in a constant expression
   40 |         return test_2.t2.item_1 ;
      |                ^
<source>:62:9: note: in call to 'test.error_2()'
   62 |         test.error_2() ;
      |         ^~~~~~~~~~~~~~
<source>:60:5: note: in call to '[]() {
    Test_Union<int, 123> test;
    test.error_2();
}.operator()()'
   60 |     []() consteval {
      |     ^~~~~~~~~~~~~~~~
   61 |         Test_Union<int, 123> test ;
      |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~
   62 |         test.error_2() ;
      |         ~~~~~~~~~~~~~~~~
   63 |     } () ;

O Clang está reclamando que está acessando membro inativo do union. Mas de acordo com o padrão cpp, deve estar ok. Como acessar t2.item_1 deve ser o mesmo que t1.item_1.

Então o que você acha? Não consegui pensar em nenhuma resposta lógica sobre o porquê de os compiladores mostrarem um erro. A única coisa que pensei é que parece um bug do compilador.

Estou tentando formar dinamicamente uma fórmula para usar em dynlm. Encontro um comportamento functionque não entendo, que pode ser visto neste código:

library(data.table)
dt_test <- data.table("a"=rnorm(10), "b"=1:5)

dt_test[, .(.(
   formula("z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + tt + tt2")
 )), .(b)]

Espera-se que o código acima produza fórmulas (idênticas) para cada valor de b. Esta fórmula é incluída .(.(...))para retornar uma lista, apenas para que ela possa ser armazenada corretamente em uma coluna do data.table original.

Entretanto, a fórmula retornada não corresponde à string fornecida originalmente, mas adiciona uma vírgula entre +e tt, como você pode ver na saída:

       b                                                                           V1
   <int>                                                                       <list>
1:     1 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2
2:     2 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2
3:     3 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2
4:     4 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2
5:     5 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2

Basicamente, ele adiciona uma vírgula onde não há nenhuma. Ele faz isso até mesmo reorganizando os termos da soma, mas para de fazer isso se eu apagar q_val, por exemplo. O mesmo vale para as.formula.

Gostaria de entender o que está acontecendo e evitar isso.

Contexto / Reprodução

type Example = {
    a: string,
    b: number
}


let value: Example = {
    a: 'hello',
    b: 10,
}

// This IIFE is because typescript will narrow the type if assigned directly like
// const k: keyof Example = 'a'
const k = ((): keyof Example => 'a')()

value = {
    ...value,
    // Obviously this is unsound
    [k]: 5,
}

Isso passa mesmo no modo estrito. Link do playground .

Pergunta

Por que o typescript é inseguro aqui? Quero entender a insegurança geral para que eu possa evitar usar padrões como esse que não serão typesafe. Eu também apreciaria qualquer documentação relevante ou problemas do GitHub.

Descrição

Guru deu uma tarefa para seus alunos. Ele deu uma frase, e os alunos têm que trocar a primeira e a última palavra e inverter todos os caracteres entre essas palavras. Ajude os alunos a resolver essa tarefa usando um programa Java.

Requisitos:

• As palavras presentes na frase devem ser maiores que 2, caso contrário, imprima "Comprimento inválido"

• A palavra deve conter apenas letras e espaços, caso contrário, imprimir " é uma frase inválida"

Observação:

• Na entrada/saída de exemplo fornecida, o texto destacado em negrito corresponde à entrada fornecida pelo usuário, e o restante do texto representa a saída.

• Certifique-se de seguir as especificações orientadas a objetos fornecidas na descrição da pergunta.

• Certifique-se de fornecer os nomes das classes, atributos e métodos conforme especificado na descrição da pergunta.

• Siga o modelo de código, se fornecido

Não use System.exit(0) para encerrar o programa.

Exemplos de entrada/saída. Todas as entradas são precedidas pelo promptEnter the sentence

Exemplo 1 :

Input: Você usa sua máscara
Output:mask ruoy raew uoy Do

Exemplo 2:

Input: Leitor de cartão
Output:Comprimento inválido

Exemplo 3:

Input: Indique @ um amigo
Output:Indique @ um amigo é uma frase inválida

import java.util.Scanner;

class SentenceProcessor {
    
    // Method to check if the sentence is valid
    public boolean isValidSentence(String sentence) {
        return sentence.matches("[a-zA-Z ]+"); // Only alphabets and spaces allowed
    }

    // Method to process the sentence
    public String processSentence(String sentence) {
        if (!isValidSentence(sentence)) {
            return sentence + " is an invalid sentence";
        }

        String[] words = sentence.trim().split("\\s+"); // Split by whitespace

        if (words.length <= 2) {
            return "Invalid Length";
        }

        // Swap first and last words
        String firstWord = words[0];
        String lastWord = words[words.length - 1];
        words[0] = lastWord;
        words[words.length - 1] = firstWord;

        // Reverse middle words
        for (int i = 1; i < words.length - 1; i++) {
            words[i] = new StringBuilder(words[i]).reverse().toString();
        }

        return String.join(" ", words); // Join words with a space
    }
}

public class UserInterface {
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        System.out.println("Enter the sentence");
        String input = sc.nextLine();
        
        SentenceProcessor processor = new SentenceProcessor();
        String result = processor.processSentence(input);
        
        System.out.println(result);
        
        sc.close(); // Close the scanner to avoid resource leaks
    }
}

Saída:-

Enter the sentence<br>
Do you wear your mask<br>
mask uoy raew ruoy Do<br>

Saída esperada:-

Enter the sentence<br>
Do you wear your mask<br>
mask ruoy raew uoy Do<br>

Tentei resolver isso, mas não estou conseguindo obter a saída desejada. Também tentei usar várias fontes abertas que não conseguiram me dar o código correto. Elas estão me dando repetidamente a mesma saída (como chatgpt, copilot).

Eu tenho um modelo static_string

template <std::size_t N>
struct static_string {
    std::array<char, N + 1> elements_; 

    constexpr static_string() noexcept : elements_{} {}

    constexpr static_string(const char (&data)[N + 1]) noexcept {
        for (size_t i = 0; i < N + 1; i++) {
            elements_[i] = data[i];
        }
    }
};

template <std::size_t N>
static_string(const char (&)[N]) -> static_string<N - 1>;

Funciona bem quando usadoconstexpr static_string str1("this is a str");

E eu quero construir a partir de um constexpr std::string_view, então eu adiciono:

    constexpr static_string(std::string_view sv) noexcept {
        for (size_t i = 0; i < N; ++i) {
            elements_[i] = sv[i];
        }
    }

então se eu usar

   constexpr std::string_view sv = "this is a str";
   constexpr static_string<sv.size()> str2(sv);

o compilador produz

<source>: In function 'int main()':
<source>:33:47: error: 'static_string<13>{std::array<char, 14>{std::__array_traits<char, 14>::_Type{'t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 's', 't', 'r'}}}' is not a constant expression
   33 |     constexpr static_string<sv.size()> str2(sv);
      |                                               ^
<source>:33:47: error: 'static_string<13>(sv)' is not a constant expression because it refers to an incompletely initialized variable
Compiler returned: 1

Então, por que essa expressão não foi avaliada como uma constante? É possível construir a partir de constexpr std::string_view? Obrigado, veja https://www.godbolt.org/z/6TToEPnch

Executar o seguinte no GHCi gera um erro em stuff' 4mas não em stuff 4. Por quê?

Existe uma maneira de consertar isso? Eu gostaria de usar MkStuff'e não MkStuff.

ghci> 
:{
class MkStuff s m | m -> s where
  stuff:: s -> m ()

instance MkStuff Int IO where
  stuff = print

class MkStuff' s m | m -> s where
  stuff' :: s -> m

instance MkStuff' Int (IO ()) where
  stuff' = print
:}

ghci> stuff 4
4
ghci> stuff' 4

<interactive>:16:1: error: [GHC-39999]
    • No instance for ‘MkStuff' Integer ()’ arising from a use of ‘it’
    • In the first argument of ‘print’, namely ‘it’   
      In a stmt of an interactive GHCi command: print it

Embora a assinatura do método em Subseja compatível com Super, mypy rejeita a substituição: Signature of "method" incompatible with supertype "Super".

estou usando

• python 3.13.1
• meupy 1.14.0

Primeiro, fiz o seguinte test.pyi.

from typing import overload

class Super:
    def method(self, arg:Other|Super)->Super: pass

class Sub(Super):
    @overload
    def method(self, arg:Other|Sub)->Sub: pass
    @overload
    def method(self, arg:Super)->Super: pass

class Other: pass

Então, quando executei mypy test.pyina linha de comando, o mypy produziu o seguinte diagnóstico:

test.pyi:7: error: Signature of "method" incompatible with supertype "Super"  [override]
test.pyi:7: note:      Superclass:
test.pyi:7: note:          def method(self, arg: Other | Super) -> Super
test.pyi:7: note:      Subclass:
test.pyi:7: note:          @overload
test.pyi:7: note:          def method(self, arg: Other | Sub) -> Sub
test.pyi:7: note:          @overload
test.pyi:7: note:          def method(self, arg: Super) -> Super
Found 1 error in 1 file (checked 1 source file)

Verifiquei o tipo de E/S de ambos Super.methode Sub.methode descobri que não há nenhum padrão que viole o LSP (Princípio de Substituição de Liskov).

Sub.methodLata sobrecarregada

• entrada argdo tipo Other|Super(= Other|Sub+ Super) e
• tipo de saída Super(= Sub+ Super).

O tipo de entrada e saída acima corresponde à assinatura de Super.method.

Então, não tenho ideia do que ser Signature of "method" incompatible with supertype "Super".

A seguir está a tabela de E/S de method.

*O LSP exige que o tipo de retorno de um submétodo seja mais estreito ou igual ao tipo de retorno do supermétodo.

** Sub.methodretorna

• Subquando Othera entrada e
• Superquando Supera entrada,

então ele retorna Sub|Superquando Other|Supera entrada.
Sub|Supersignifica Super.

Como você pode ver na tabela acima, não há padrões que violem o LSP.

Então, acho que a mensagem de erro mypy Signature of "method" incompatible with supertype "Super"está incorreta.

Meu código está errado?

Além disso, se meu código não estiver errado e a mensagem de erro do mypy estiver errada, onde posso perguntar?

PS Uma maneira rápida de esconder o erro.

Embora não seja uma solução completa, encontrei uma maneira simples de esconder o erro.

from typing import overload

class Super:
    def method(self, arg:Other|Super)->Super: pass

class Sub(Super):
    @overload
    def method(self, arg:Other|Sub)->Sub: pass
    @overload
    def method(self, arg:Super)->Super: pass
    # Start of hiding error
    @overload
    def method( # type: ignore[overload-cannot-match]
               self, arg:Other|Super)->Super: pass
    # End of hiding error

class Other: pass

Como uma última sobrecarga, adicionei um Sub.methodcom a mesma assinatura exata de Super.method. No entanto, quando esse problema for resolvido em uma versão futura, isso significará que o código que adicionei não será alcançado e devemos obter um [overload-cannot-match]erro. Portanto, adicionei # type: ignore[overload-cannot-match]para ignorar esse erro com antecedência.

(À primeira vista, pode parecer que estou simplesmente silenciando erros com type: ignore, mas isso não é relevante para o mypy no momento. Isso é apenas um impedimento contra erros futuros.)

Digamos que eu crie um servidor TCP multithread simples como este:

int server_fd = socket(/* args */);

setsockopt(server_fd, /* other args... */);
bind(server_fd, /* other args... */);
listen(server_fd, backlog);

while (1) {
    int client_fd = accept(server_fd, /* other args... */);
    
    if (fork() == 0) {
        // handle client request
        close(client_fd);
        exit(0);
    }
}

Um servidor como esse deve ser capaz de lidar com muitos clientes, mas o que acontece se um cliente malicioso executar o handshake TCP inicial extremamente lentamente? Durante isso, o servidor ainda será capaz de aceitar outros clientes legítimos, ou o cliente lento proíbe isso, já que a chamada para accept()está bloqueando?

Para esclarecer minha pergunta:
O que a chamada faz accept()por baixo dos panos? Ela simplesmente pega o próximo soquete de entrada e o prepara para comunicação estabelecendo um descritor de arquivo, ou ela está se comunicando ativamente com o cliente para completar o handshake? O processo de esperar por um handshake TCP afeta outras conexões de entrada?

Estou tentando criar uma função que retorna um callable parcialmente aplicado, mas estou tendo problemas com a verificação de tipo mypy.

Aqui está minha primeira implementação:

Ajude-me a explicar minha pergunta para o stackoverflow. Ou seja, encontre um título e o corpo

este código:

from collections.abc import Callable
from functools import partial

def f(i: int, j: float, k: int) -> int:
    return i + int(j) + k

def g(a: float) -> Callable[[int, int], int]:
    return partial(f, j=a)

fun: Callable[[int, int], int] = g(3.0)
r: int = fun(4, 5)
print(r)

Foi verificado com sucesso pelo mypy

mas não pode correr

r: int = fun(4, 5) TypeError: f() obteve vários valores para o argumento 'j'

para resolver esse problema, chamo a função com argumento nomeado

from functools import partial

def f(i: int, j: float, k: int) -> int:
    return i + int(j) + k

def g(a: float) -> Callable[[int, int], int]:
    return partial(f, j=a)

fun: Callable[[int, int], int] = g(3.0)
# line 12 in my code (where the error message comes from)
r: int = fun(i=4, k=5)
print(r)

funciona bem agora

mas a verificação mypy falha

main.py:12: erro: Argumento de palavra-chave inesperado "i" [call-arg] main.py:12: erro: Argumento de palavra-chave inesperado "k" [call-arg] Foram encontrados 2 erros em 1 arquivo (1 arquivo de origem foi verificado)

Existe uma maneira de anotar esse código para que ele seja executado corretamente e passe na verificação de tipo do mypy? Eu tentei várias combinações de dicas de tipo, mas não encontrei uma solução que satisfaça tanto o comportamento de tempo de execução quanto a verificação de tipo estática.

Eu sei que existe essa solução, sem usar Partial

from collections.abc import Callable 


def f(i :int,j : float,k :int) ->int:
    return i+int(j)+k
    
def g(a :float) -> Callable[[int,int],int]:
    def ret(i,k):
        return f(i,a,k)
    return ret

fun :Callable[[int,int],int]= g(3.0)
r : int = fun(4,5)
print(r)

Mas eu realmente quero usar Callable porque estou trabalhando com funções com muitos parâmetros e é muito mais simples apenas dizer quais parâmetros são substituídos