All perguntas(coding)

Estou trabalhando em um projeto no qual estou construindo um tipo de vetor de bits em Rust e estou explorando se é possível restringir genéricos constantes usando limites de desigualdade.

Meu objetivo é projetar uma API que evite a verificação de limites em tempo de execução usando garantias em tempo de compilação baseadas em genéricos constantes, além de uma variante verificada em tempo de execução. Minha esperança é que essas funções sejam simples o suficiente para que o compilador possa embuti-las, de modo que seja uma abstração verdadeiramente de custo zero.

Aqui está um exemplo de código simplificado que demonstra o que estou tentando fazer. Este código não compila, mas mostra o tipo de restrição que desejo:

/// Idea: A function with multiple generic parameters where a 
/// trait bound is used to establish an ordering between them.
fn add_ordered<const N1: usize, const N2: usize>() -> usize 
where N2 > N1 {
    N1 + N2
}

fn main() {
    let n = add_ordered::<1, 2>();
    println!("{n}");
}

Se eu remover a cláusula where N2 > N1, o código será compilado, mas não manterá o tipo de invariante que estou tentando manter aqui (nesse caso, que N2 é maior que N2).

Minhas perguntas:

• Existe atualmente uma maneira em Rust de escrever uma restrição genérica const como where N2 > N1?
• Caso contrário, há alguma solução alternativa ou recurso de linguagem (noturno ou não) que permita algo semelhante?
• Se realmente não há como fazer isso agora, há algum motivo para que não possa ser feito, além do fato de que simplesmente não foi feito? Isso poderia levar a uma possível RFC?

Pesquisei um pouco, mas não consegui encontrar muita coisa sobre isso. Quaisquer dicas ou explicações serão muito apreciadas. Obrigado!

Por favor, explique esse comportamento em Kotlin:

data class A<T>(val p: T)
class B

fun f1(): A<Number> = A(B()) as A<Number>
fun f2(): A<Unit> = A(B()) as A<Unit>

fun main() {
    println("f1: ${f1().p::class.simpleName}") // print "f1: B"
    println("f2: ${f2().p::class.simpleName}") // print "f2: Unit"
}

Eu esperaria a saída "B" tanto no primeiro quanto no segundo caso.

Além disso, curiosamente, ele funciona corretamente para data class A<T>(val p: T?).

É algum tipo de otimização do compilador?

Observe que esta é uma pergunta de direito linguístico . Conheço o significado comum de "variável", mas estou tentando entender exatamente o que o padrão chama de "variáveis". Estou escrevendo um material didático e quero usar as definições corretas.

Variáveis ​​são comumente definidas como "objetos nomeados", ou mais corretamente "objetos que foram declarados" (já que variáveis ​​podem não ter nome, mas são sempre declaradas).

Mas há um segundo ponto de vista: variáveis ​​são um conceito de tempo de compilação. Segundo essa definição, uma declaração no código-fonte sempre corresponde a uma variável, mesmo que, em tempo de execução, vários objetos sejam criados a partir dela.

Qual está correta?

Aqui está um exemplo em que isso é importante. Digamos que você tenha

void foo(bool a)
{
    int x = 42;

    if (a)
        foo(false);
}

Quando você chama foo(true), duas instâncias de int x = 42;get existem ao mesmo tempo.

Eles são claramente dois objetos diferentes, mas tecnicamente são variáveis ​​diferentes ou a mesma variável?

Se variáveis ​​são uma coisa de tempo de compilação, então as duas são a mesma variável.

A segunda definição parece errada à primeira vista, mas aqui temos um membro do comitê C++ argumentando que ela é a correta , por exemplo.

este não é um bug específico, mas uma questão geral de design em C++. Considere o seguinte cenário:

struct MyInterface {};

struct Data : MyInterface{};

struct DataWrapper
{
    SomeContainerOf<MyInterface*> getData()
    {...}
private:
    std::vector<Data> dataStorage;
};

Em termos dos meus requisitos, preciso da função de acesso para DataWrapperretornar um contêiner de MyInterface*valores (ponteiros porque estamos realmente retornando Datavalores).

Idealmente, queremos fazer isso sem fazer uma cópia. Quero saber a melhor maneira de fazer isso. Pelo que posso dizer, algo como o seguinte é a maneira idiomática do C++ de fazer isso:

auto DataWrapper::getData()
{
    return dataStorage
        | std::ranges::views::transform(
            [](Data& d) -> MyInterface* { return &d; }
        );
}

Mas o problema é que está muito claro que esse método acessador é explícito sobre seus valores de retorno - preciso que saibam que esse método retorna essa lista, e estou preocupado que ao fazer o tipo de retorno auto, isso atrapalhe um pouco isso . Parece que (posso estar errado aqui) você não deveria saber qual viewé o tipo de a (em um estilo semelhante aos lambdas)

A alternativa que estou considerando seria fazer uma visualização customizada (onde eu poderia deixar o tipo um pouco mais claro), mas realmente me dói reimplementar algo que está tão claramente no padrão. Qual seria a medida recomendada para tal cenário? O C++ moderno diz que devo manter o valor de retorno auto?

A documentação diz que existem apenas 3 variáveis ​​lexicais especiais ( $_, $/, $!).

No entanto, inspecionando o pseudostash MY::, parece que uma variável nomeada $¢também existe e não está documentada (ou pelo menos, pesquisar em docs.raku por $¢ não produz nenhum resultado) (Editar: de acordo com a resposta aceita, isso é realmente falso , está realmente documentado).

say MY::.hash;
# ==> PseudoStash.new((!UNIT_MARKER => (!UNIT_MARKER), $! => Nil, $/ => Nil, $=finish => (Mu), $=pod => [], $?PACKAGE => (GLOBAL), $_ => (Any), $¢ => Nil, &foo => &foo, ::?PACKAGE => (GLOBAL), EXPORT => (EXPORT), GLOBALish => (GLOBAL)))

sub foo {say MY::.hash}
foo();
# ==> PseudoStash.new(($! => Nil, $/ => Nil, $_ => (Any), $¢ => Nil))

$¢=5;
# The compiler doesn't complain, despite $¢ not having been declared

say $¢ 
# ==> 5

Tem $¢algum significado especial?

Se for importante, estou usando o rakudo v2023.12, implementando a v6.d.

Gostaria de usar o índice do array em uma rotina de mapa. Por exemplo, este código Raku:

raku -e 'my @a = "First", "Second", "Third", "First"; say @a.map({ "Index of $_ is: ;" })'

impressões:

(Index of First is: ; Index of Second is: ; Index of Third is: ; Index of First is: ;)

Seria possível obter o índice do array, como:

(Index of First is: 0; Index of Second is: 1; Index of Third is: 2; Index of First is: 3;)

Obrigado!

Eu tenho o seguinte código:

#include <print>
#include <vector>

int main() {
    std::vector<int> v{1, 2, 3};
    std::println("{}", v);
}

Entre os numerosos erros que isso produz, há ( clang++ -std=c++23 -stdlib=libc++, https://godbolt.org/z/3z9Tseh37 ):

[...]/format_arg_store.h:167:17: error: static assertion failed due to [...]
  167 |   static_assert(__arg != __arg_t::__none, "the supplied type is not formattable");
      |                 ^~~~~~~~~~~~~~~~~~~~~~~~

Isso me confunde porque de acordo com a página de suporte do compilador cppreference C++23 , o libc++ suporta std::printlne implementa P2286: Formatting Ranges .

Estou fazendo algo errado ou isso é um bug padrão da biblioteca?

O código a seguir é impresso nullptrem vez de empty( godbolt link ):

#include <iostream>

class empty { };

#if 1
void f(std::nullptr_t) {
    std::cout << "nullptr\n";
}
#endif

void f(empty) {
    std::cout << "empty\n";
}

int main() {
    f({});
}

Desativar a f(nullptr_t)variante faz com emptyque ela seja impressa. Quais são as regras que o C++ está usando para selecionar a nullptr_tvariante sobre a emptyvariante quando ambas estão disponíveis?

Eu estava escrevendo um programa C++ simples que gera uma lista de valores inteiros aleatórios de uma distribuição normal, depois pega os primeiros N itens gerados e os filtra para que seu valor absoluto seja maior que 42. O código que escrevi é o seguinte:

int main() {
//convenience
    namespace rng = std::ranges;
    namespace view = std::views;
//random generation boilerplate
    std::random_device r;
    std::mt19937 gen(r());
    std::normal_distribution<float> taps(-4, 15);
 //the filtering   
    for (const auto& value : view::repeat(0)
        | view::transform([&taps, &gen](auto _) { return std::round(taps(gen)); })
        | view::take(1005)
        | view::filter([](auto val) { return (val < -42 || val > 42); }))
    {
        std::cout << value << ' ';
    }
    return 0;
}

se eu remover a view::filterlinha, a sequência parece perfeitamente normal e há cerca de 3 valores que satisfazem a condição. No entanto, quando o filtro é aplicado, a saída parece ser algum lixo aleatório, como -12 -8 -14 2 -4 -11 -38. Como isso faz algum sentido? Esses números nem sequer satisfazem a condição de filtragem. Qualquer ajuda é apreciada.

notas:
compilado com g++ -o test main.cpp -std=c++2b, tanto no Windows quanto no Linux.
Se eu substituir views::repeat(0) por views::iota(0) e compilar com -std=c++20, a saída será a mesma - algum lixo aleatório.
Além disso, se alguém sugerir a melhor maneira de gerar uma lista a partir do lambda, eu agradeceria muito.

Eu tenho algum código legado com algumas classes singleton que se registram usando construtores de variáveis ​​globais. É uma grande base de código, compilada em um executável. Tentei organizar a base de código e reagrupar o código em bibliotecas. Um exemplo mínimo do código atual é

main.cpp

int main(int argc, char *argv[])
{
  return 0;
} 

Hash.cpp

#include <iostream>

class Hash
{
public:
    Hash()
    {
        std::cout << "Hash\n";
    }
};

Hash a;

e a configuração de compilação atual é

CMakeLists.txt

cmake_minimum_required(VERSION 3.26)
project(mcve)

add_executable(mcve main.cpp Hash.cpp)

Construindo o código e executando as impressões executáveis

Hash

Eu modifiquei a configuração de compilação para

cmake_minimum_required(VERSION 3.26)
project(mcve)

add_library(Hash Hash.cpp)
add_executable(mcve main.cpp)
target_link_libraries(mcve Hash)

Isso cria uma biblioteca estática libHash.ae a vincula ao executável. Compilar o mesmo código e executar o executável não imprime nada. Por que a diferença e onde é descrita? Faz parte do padrão C++ ou do compilador? É específico do sistema operacional (bibliotecas estáticas do Linux)? É um comportamento indefinido?