Eu tenho o seguinte código de ferrugem

use std::any::Any;
use std::rc::Rc;

fn main() {
    let mut variables = Vec::<Rc<dyn Any>>::new();
    variables.push(Rc::new(1_i32));
    variables.push(Rc::new(false));
    variables.push(Rc::new(4.53_f64));

    let integer: i32 = *variables[0].clone().downcast::<i32>().unwrap();
    let boolean: bool = *variables[1].clone().downcast::<bool>().unwrap();
    let floating: f64 = *variables[2].clone().downcast::<f64>().unwrap();

    let my_goal: (i32, bool, f64) = (integer, boolean, floating)

    println!("{:?}", my_goal);

que eu quero automatizar usando uma macro. ( Eu sei que isso não é o ideal, mas isso é apenas um MWE para fazer uma pergunta sobre macros )

Em particular, quero criar uma tupla que faça downcasting Anypara tipos fornecidos

Minha primeira tentativa é:

macro_rules! my_macro {
    ($vector:ident; $($type:ty),*) => {
        // ($($type),*)
        //println!("{:?}", $vector);
        //$(println!("{:?}", stringify!($type));)*
        let idx = 0;
        ($(
                *$vector[0].clone().downcast::<$type>().unwrap()
        ),*)
    };
}

que está errado por causa do 0hardcoded. Eu tentei várias maneiras de declarar uma variável e incrementá-la ao longo da macro, mas elas falharam. Como posso fazer?

Sou um novato absoluto em redes no Linux. Em particular, eu estava procurando alguns exemplos de protocolo ICMP, em particular, eu estava procurando solicitações de ping e respostas. Normalmente, tudo começa abrindo um soquete bruto

int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);

e então há algo como (código incompleto)

while (1) {
   sendto(sockfd, ...);
   usleep(CERTAIN_TIME);
   recvfrom(sockfd, ...);
   // then the reply is elaborated
}

Eu estava pensando se também é possível abrir dois desses soquetes brutos: um usado apenas com sendto, o outro usado com recvfrome usá-los por dois threads diferentes:

// initialization
int sendsock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
int recvsock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);

então

// thread 1
while (1) {
   sendto(sendsock, ...);
   usleep(CERTAIN_TIME);
}

// thread 2
while (1) {
   recvfrom(recvsock, ...);
   usleeep(CERTAIN_TIME);
}

É seguro?

Criei um ambiente virtual usando

python -m venv venv

Agora estou abrindo um shell Python sem ativar o ambiente virtual executando

import sys
print(sys.path, sys.prefix)

Eu entendo

['', '/usr/lib/python312.zip', '/usr/lib/python3.12', '/usr/lib/python3.12/lib-dynload', '/usr/lib/python3.12/site-packages'] /usr

que é exatamente o que eu esperava.

Enquanto, se eu ativar o ambiente, a saída é

['', '/usr/lib/python312.zip', '/usr/lib/python3.12', '/usr/lib/python3.12/lib-dynload', '/home/myname/mypath/venv/lib/python3.12/site-packages'] /home/myname/Projects/pypath/venv

O que me incomodou muito é que, mesmo dentro do venv, parece que o interpretador está pesquisando pacotes primeiramente no local do sistema e só depois dentro do diretório venv.

Isso é verdade?

Recebi um std::variantde vários tipos. Gostaria de escrever um traço que fornece outro std::variantdo ponteiro dos tipos do primeiro.

using MyVariant = std::variant<int, float>;

using MyVariantOfPointers = pointer_of_v<MyVariant>;

tal que MyVariantOfPointeré std::variant<int*, float*>. Eu tentei brincar com std::variant_size_ve std::variant_alternative_tmas não sei como construir o novo tipo recursivamente.

Estou escrevendo um alocador que usa o alinhamento como parâmetro de modelo e também o alinhamento:

template<typename T, std::align_val_t alignment>
class AlignedAllocator {
public:
  using value_type = T;
  using align_type = std::size_t;

  constexpr AlignedAllocator() noexcept = default;
  constexpr AlignedAllocator(const AlignedAllocator&) noexcept = default;
  template<typename U> constexpr AlignedAllocator(const AlignedAllocator<U, alignment>&) noexcept {}

  constexpr std::size_t align() noexcept
  {
    return static_cast<std::size_t>(alignment);
  }

  [[nodiscard]]
  value_type* allocate(std::size_t n)
  {
    return reinterpret_cast<value_type*>(::operator new[](n, alignment));
  }

  void deallocate(value_type* ptr, std::size_t)
  {
    ::operator delete[](ptr, alignment);
  }
};

Os problemas surgem quando tento usar std::allocator_traitsmethed, rebindpois parece ser capaz de gerenciar apenas um parâmetro, o type T. Isso torna meu alocador incompatível com a biblioteca de contêineres padrão:

std::vector<AlignedAllocator<int, std::align_val_t{64}> 

não compila. Uma saída seria adicionar

template<typename U> {                                                                                                               
struct rebind {                                                                                                                       
  using other = AlignedAllocator<U, alignment>;                                                                                       
};

isso faz com que o código seja compilado. No entanto, a rebindestrutura está obsoleta em c++17 e removida em c++20.

PERGUNTA

Alguma sugestão para fazer meu código funcionar sem usar recursos obsoletos? Uma seria inicializar o alocador com o alinhamento, mas gostaria de manter esse parâmetro no tipo.