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.