All perguntas(coding)

Estou lendo a documentação em std::expected::operator==, e aparentemente não é amigável ao SFINAE. Em vez de "não participa da resolução de sobrecarga se [os tipos não forem eq-comparáveis]", diz "o programa está malformado [nesse caso]".

E de fato:

#include <concepts>
#include <expected>

struct A {};

static_assert(!std::equality_comparable<std::expected<A, A>>);

Esta afirmação falha no MSVC e no Clang com libc++ e causa um erro grave no Clang com MSVC STL.

Mas por que não é compatível com SFINAE?

std::expected<T,U>requer que ambos Te Usejam completos de qualquer forma, então aparentemente nada impede que todas as operações nele sejam compatíveis com SFINAE.

Há um comportamento estranho de lobstr::obj_addr causado por sua vetorização sobre listas, quando a própria lista não altera o endereço

Acabei de começar Advanced R de Wickham (2ª ed.) e cheguei ao primeiro exercício 2.2.2 Exercises. Eu supus que, dado:

a <- 1:10; b <- a; c <- b

todos eles teriam o mesmo endereço de memória recuperado pela lobstr::obj_addrfunção. Isso é verdade se usarmos apenas a, b ou c como entradas, mas como sou preguiçoso e queria ter todos os valores de uma vez, fiz:

list(a, b, c) |> lapply(obj_addr) # lapply or sapply 

Então obtemos um conjunto diferente de valores entre os diferentes nomes toda vez que a função é executada. Isso ainda acontece se definimos x <- list(a, b, c)antes de chamar a função por meio de lapply, e obj_addr(x[[1]]) == obj_addr(x[[2]]) == obj_addr(x[[3]]) == obj_addr(a), então não é uma questão de criar uma nova lista toda vez. Alguém sabe o que está acontecendo aqui? Eu entendo que até certo ponto cada chamada gera um novo objeto de saída que terá seu próprio endereço de memória, mas não sei como lapplypode interferir em uma função constante para um determinado objeto como obj_addr.

Agradeço antecipadamente!

Por que é throw epermitido, mas não throw a, no seguinte caso?

  void test() {
    try {
      System.out.println();
    } catch (Error | RuntimeException e) {
      var a = e;
      //throw a; unreported exception Throwable; must be caught or declared to be thrown
      throw e;
    }
  }

Tudo isso intuitivamente faz sentido, mas a partir do JLS 14.20

Uma cláusula multi-catch pode ser considerada uma sequência de cláusulas uni-catch. Ou seja, uma cláusula catch onde o tipo do parâmetro de exceção é denotado como uma união D1|D2|...|Dné equivalente a uma sequência de n cláusulas catch onde os tipos dos parâmetros de exceção são tipos de classe D1, D2, ..., Dnrespectivamente. No bloco de cada uma das n cláusulas catch, o tipo declarado do parâmetro de exceção é lub(D1, D2, ..., Dn).

Como lub(Error,RuntimeException)is Throwable, o código acima deve ser equivalente a:

    try {
      System.out.println();
    } catch (Error e) {
      Throwable lub = e;
      throw lub;
    } catch (RuntimeException e) {
      Throwable lub = e;
      throw lub;
    }

(que obviamente não compila)

Além disso, o tipo de aé o tipo de e"quando tratado como se não aparecesse em um contexto de atribuição" ( JLS 14.4.1 ), mas como mostrado acima não é o mesmo que o tipo de e.

Há algo que eu esqueci?

Editar : esta não é uma duplicata de Por que é legal lançar novamente um Throwable em certos casos, sem declará-lo? porque esta questão é específica para multi-catch (que não é discutida lá) e surge devido a um mal-entendido de um fragmento específico do JLS que aborda multi-catch. As respostas fornecidas nesta pergunta me ajudaram a ligar os pontos :)

Me deparei com as bibliotecas de processamento de imagens de https://github.com/nothings/stb/ e ao experimentar módulos C++, tentei usar stb_image.h "como módulo".

Para isso eu escrevi um pequeno módulo wrapper (mesma técnica demonstrada pelo glm, https://github.com/g-truc/glm que fornece um empacotamento de sua biblioteca como módulo C++ dentro do glm.cppm) e parece funcionar como um encanto:

module;

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

export module stb_image;

// this "seems" correct
export using ::stbi_uc;

// this should be correct
export stbi_uc *stbi_load(char const *filename,int *x,int *y,int *comp,int req_comp);
export void stbi_image_free(void *retval_from_stbi_load);

// is this the correct way to export enum values?
export using ::STBI_default;
export using ::STBI_grey;
export using ::STBI_rgb;
export using ::STBI_rgb_alpha;

Não tenho certeza de como lidar com esses valores STBI que são fornecidos em stb_image.h como uma enumeração sem nome:

enum
{
   STBI_default = 0, // only used for desired_channels

   STBI_grey       = 1,
   STBI_grey_alpha = 2,
   STBI_rgb        = 3,
   STBI_rgb_alpha  = 4
};

Experimentei acima e pelo menos o Visual C++ 2022 "aceita" o que criei e o código é executado corretamente, os valores podem ser usados ​​de outro código importando este módulo "stbi_image".

Mas pesquisando na Internet, não consegui encontrar nenhuma descrição de "se houver e como" esses valores enum de um enum sem nome podem ser exportados em um módulo C++.

O que eu fiz foi a maneira correta de fazer isso?

Eu tenho uma série de valores no Excel.

A linha superior é um número base. A segunda linha mostra quantos valores em cada número da série. A terceira linha é o valor total desse número na série.

Observe que no meu exemplo os números na terceira linha somam 42 (um acaso completo!).

Quero expandir esses números assim:

O número da série é a base mais a sequência de 1 até o número da segunda linha. Então o valor é o número do valor dividido pelo número na sequência atual.

Observe que a linha final soma o mesmo que a linha de entrada. Estou distribuindo esses números uniformemente.

A verdadeira aplicação aqui é expandir os valores de um orçamento feito mensalmente pela quantidade de dias do mês e distribuir os números por dia. Pretendo então agrupar por semanas.

Estou lutando para fazer com que até mesmo a expansão mais básica funcione:

=HSTACK(BYCOL(R8C3:R8C5,LAMBDA(n,SEQUENCE(n,1))))

Eu adoraria ser apontado na direção certa.

Tento criar uma classe não copiável e não móvel, cuja construção de objetos só deve ser feita através de uma função create em vez de construtores públicos. A função create retornará um std::expectedobjeto contendo o objeto criado ou um objeto de erro. Para impor a construção por meio da função create, quero tornar privados todos os construtores disponíveis. O objetivo principal desta abordagem é a construção de objetos sem exceções.

Aqui está um exemplo simples:

class Foo
{
    int val_{};

public:
    Foo() = delete;
    Foo(const Foo&) = delete;
    Foo& operator=(const Foo&) = delete;

    static auto
    create(int val) noexcept -> std::expected<Foo, std::error_code>
    {
        if (val == 42)
            return std::unexpected<std::error_code>(std::in_place, EINVAL, std::generic_category() );

        return std::expected<Foo, std::error_code>{ std::in_place, val };
    }

private:

    friend class std::expected<Foo, std::error_code>;

    explicit Foo(int val) noexcept
    : val_{ val }
    {};

};

Observe que fiz std::expected<Foo, std::error_code>um friendpara permitir que ele chame o construtor privado. Mas ainda recebo um erro do compilador. Aqui está o código no Compiler Explorer .

Veja o código a seguir contendo 3 implementações de uma função que chama outra função de lançamento.

# include <stdexcept>

void f()
{
    throw std::runtime_error("");
}

void g1()
{
    f();
}

void g2() noexcept
{
    f();
}

void g3() noexcept
{
    try{ f(); } catch(...){ std::terminate(); }
}

int main()
{
    return 0;
}

No meu entendimento da noexceptespecificação, g2e g3são estritamente equivalentes. Mas, quando compilo no Compiler Explorer com GCC, o código gerado é estritamente equivalente para g1and g2, mas não para g3:

g1():
        push    rbp
        mov     rbp, rsp
        call    f()
        nop
        pop     rbp
        ret
g2():
        push    rbp
        mov     rbp, rsp
        call    f()
        nop
        pop     rbp
        ret
g3():
        push    rbp
        mov     rbp, rsp
        call    f()
        jmp     .L9
        mov     rdi, rax
        call    __cxa_begin_catch
        call    std::terminate()
.L9:
        pop     rbp
        ret

Por que ?

Estou usando C# 12. Em C# 12 posso usar o construtor primário:

public class UserService(IUnitOfWork uow) : IUserService
{

}

Antes do C# 12 eu usava verificação nula para itens que injetava no construtor:

public class UserService : IUserService
{
    private readonly IUnitOfWork _uow;

    public UserService(IUnitOfWork uow)
    {
        ArgumentNullException.ThrowIfNull(uow);
        _uow = uow;
    }
}

Agora, como posso fazer a verificação nula em C# 12?
É necessário usar o fail fast com o construtor primário?

Dados dois tipos de tamanho arbitrário Te U, onde U: From<T>, há uma razão pela qual a biblioteca padrão não fornece From<Option<T>> for Option<U>um where U: From<T>? Tentei fazer isso, mas recebi um erro de implementação conflitante, então claramente há uma limitação, mas não tenho certeza de onde. E sim, eu entendo que posso fazer isso com um Option::map(), mas parece que o std deveria fornecer isso imediatamente.

enum Opt<T> {
    Some(T),
    None,
}

impl<T: From<U>, U> From<Opt<T>> for Opt<U> {
    fn from(opt: Opt<T>) -> Self {
        match opt {
            Opt::Some(t) => Opt::Some(t.into()),
            Opt::None => Opt::None,
        }
    }
}

struct A;
struct B;

impl From<A> for B {
    fn from(_: A) -> Self {
        B
    }
}

fn main() {
    let a = Opt::Some(A);
    let _b: Opt<B> = a.into();
}

Erro

error[E0119]: conflicting implementations of trait `From<Opt<_>>` for type `Opt<_>`
 --> src/bin/main.rs:6:1
  |
6 | impl<T: From<U>, U> From<Opt<T>> for Opt<U> {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: conflicting implementation in crate `core`:
          - impl<T> From<T> for T;

O trecho a seguir gera erros de compilação ao adicionar -pedantice -Werrorem compiladores um pouco antigos.

#include <cstdint>
#include <iostream>

int add(int a, int b){
    return a + b;
}; // <-- stray semicolon

int main (){
    return 0;
}

No entanto, isso não acontece nas versões mais recentes do compilador. Encontre uma matriz de gcc(10.x, 11.x) e clang(5.x, 6.x) demonstrando a diferença em https://godbolt.org/z/KWeb8WTxz .

Tenho duas partes na minha pergunta:

1. Por que isso não é acionado em compiladores recentes?
2. É possível ativar o comportamento antigo em versões recentes do clangou gcc?