我有以下锈蚀代码

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);

我想使用宏来实现自动化。（我知道这不是最理想的，但这只是一个 MWE 来询问有关宏的问题）

特别是我想创建一个向下转换Any为给定类型的元组

我的第一次尝试是：

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

这是错误的，因为0硬编码。我尝试了几种方法来声明一个变量并沿着宏增加它，但都失败了。我该怎么办？

我是 Linux 网络方面的新手。我特别查看了一些 ICMP 协议的示例，特别是查看了 ping 请求和回复。通常都是从打开原始套接字开始的

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

然后就有了类似的东西（粗略的代码）

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

我想知道是否也可以打开其中两个原始套接字：一个仅用于sendto，另一个用于recvfrom并由两个不同的线程使用它们：

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

然后

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

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

它安全吗？

我使用创建了一个虚拟环境

python -m venv venv

现在我打开 Python shell，但不激活虚拟环境，运行

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

我明白了

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

这正是我所期待的。

如果我激活环境，则输出为

['', '/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

令我沮丧的是，即使在 venv内部，解释器似乎也首先在系统范围的位置搜索包，然后才在 venv 目录内搜索包。

这是真的吗？

我得到了std::variant几种类型的一个。我想编写一个特征，为另一个特征提供std::variant第一种类型的指针。

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

using MyVariantOfPointers = pointer_of_v<MyVariant>;

MyVariantOfPointer就是这样std::variant<int*, float*>。我尝试使用std::variant_size_v和，std::variant_alternative_t但我不知道如何递归构建新类型。

我正在编写一个分配器，它将对齐作为模板参数以及对齐：

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);
  }
};

当我尝试使用std::allocator_traitsmethed时，问题就来了rebind，因为它似乎只能管理一个参数，即 type T。这使得我的分配器与标准容器库不兼容：

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

不编译。一个出路是添加

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

这使得代码可以编译。然而，该rebind结构在 c++17 中已弃用，并在 c++20 中被删除。

问题

有什么建议可以让我的代码在不使用已弃用的功能的情况下工作吗？一种是使用对齐方式初始化分配器，但我想将此参数保留在类型中。