Dominik Kaszewski's questions

Tenho uma base de código C que usa uniões para trocadilhos de tipos. Estou então testando esse código em C++ com o gmock.

Sei que o trocadilho baseado em união é ilegal em C++ , então queria ter certeza de que meu uso é seguro:

// sum_halves.h
#include <stdint.h>
uint32_t sum_halves(unit64_t i);

// sum_halves.c
#include "sum_halves.h"
uint32_t sum_halves(unit64_t i) {
    union {
        uint64_t u64;
        uint32_t u32[2];
    } u;
    u.u64 = i;
    return u.u32[0] + u.u32[1];
}

// sum_halves_test.cpp
extern "C" {
#include "sum_halves.h"
}
#include <gtest/gtest.h>

TEST(sum_halves_test, two_plus_two_is_five) {
    EXPECT_EQ(sum_halves(0x0000'0002'0000'0003), 5);
}

Pelo que entendi, como sum_halves.cé compilado como um programa em C, o trocadilho baseado em união está correto, mesmo que eu posteriormente chame essa função a partir de código C++. Mas se eu criasse sum_halvesuma função inline, ela seria compilada como código C++ em *.cpparquivos, resultando em Comportamento Indefinido. extern "C"Isso não ajuda, pois afeta apenas a vinculação, não a compilação.

Se estiver correto, existe alguma solução alternativa para o caso inline? Uma flag do compilador GCC ou Clang ou #pragmapara permitir trocadilhos baseados em união em uma função específica?

Tenho experimentado std::ranges::viewse notado que cada visualização encadeada fica maior. Para iteradores de visualização, esse padrão é simples: cada um é sempre 8 bytes maior que o anterior. Mas para as visualizações em si, o transformtamanho não aumenta em nada, mas filteraumenta em uma quantidade que não consigo entender. No MSVC, esse padrão é um pouco diferente, mas ainda imprevisível para mim.

Código de teste:

#include <iostream>
#include <ranges>
#include <string>

int main() {
    static constexpr auto printed = [](auto&& v) {
        std::cout << "sizeof(v): " << sizeof(v) << ", ";
        std::cout << "sizeof(it): " << sizeof(v.begin()) << ", ";
        std::cout << "values: { ";
        for (auto&& x : v) {
            std::cout << x << ", ";
        }
        std::cout << "}\n";
        return v;
    };

    using namespace std::ranges::views;
    auto hundred = printed(iota(0ull, 100ull));
    auto small = printed(hundred | filter([](auto i) { return i < 50; }));
    auto times_seven = printed(small | transform([](auto i) { return i * 7; }));
    auto even = printed(times_seven | filter([](auto i) { return i % 2 == 0; }));
    auto as_string = printed(even | transform([](auto i) { return std::to_string(i); }));
    auto no_twos = printed(as_string | filter([](auto s) { return s.find('2') == s.npos; }));
}

Execute-o no GodBolt

Resultados:

Meu código não se importa muito com o tamanho das visualizações, já que elas nunca são armazenadas em lugar nenhum. Só estou me perguntando por que elas não podem ser constantes, dependendo apenas do tamanho do lambda (aqui sempre vazio). Tentei analisar o código-fonte, mas acho muito difícil de ler com todas as camadas de classes base, especialização de modelos e restrições de conceitos.

Há algum tempo, portei alguns contêineres de biblioteca padrão C++ para um ambiente onde a biblioteca padrão não estava disponível. Embora iteradores para contêineres contíguos e baseados em nós fossem fáceis, fiquei sem saber como implementar um iterador unordered_mapsem armazenar uma referência ao mapa ou ao enditerador.

O problema principal era operator++, que tem que pular baldes vazios sem ao mesmo tempo estourar o buffer subjacente:

AB_C_
^     ++
 ^    non-empty, done

AB_C_
 ^    ++
  ^   empty, move over
   ^  non-empty, done

AB_C_
   ^  ++
    ^ empty, move over
     ^overrun, how can it know to stop?

Isso pressupõe que você pode determinar se um bucket está vazio apenas por um ponteiro para ele, o que pode não ser o caso se unordered_mapusar um bitset separado para otimizar o espaço (fazendo com que o bucket { bool, Key, Value }desperdice alignof(Key) - 1bits).

Acabei desistindo e criei o iterador { bucket*, unordered_map& }, para que ele operator++possa chamar bucket* unordered_map::get_next_occupied_bucket(bucket*), já que o mapa sabe quais baldes estão vazios e quantos deles existem. Tive problemas semelhantes ao tentar implementar filter_view, mas também não encontrei uma boa solução para isso.

Como os fornecedores de bibliotecas padrão (e outros implementadores) tendem a superar esse problema? O exemplo acima usa endereçamento aberto, mas me parece que o encadeamento incorrerá no mesmo problema, já que o contêiner superior ainda é um array com alguns elementos ausentes.

O principal motivo pelo qual não quero armazenar referências é que isso parece pouco elegante e ingênuo, a exemplo de implementar std::vector::iteratorcomo { vector&, size_t index }, sugerindo que deveria existir uma solução melhor.

Tenho uma biblioteca compartilhada expondo uma função:

const char* foo(const char* s);

Para chamá-lo do Python usando ctypes, posso fazer o seguinte:

import ctypes

foo = ctypes.cdll.LoadLibrary('foo.so')
foo.foo.argtypes = [ctypes.c_char_p]
foo.foo.restype = ctypes.c_char_p

print(foo.foo('Hello World!'.encode('utf8')).decode('utf8'))

Existe uma maneira de incorporar o texto encode/decode('utf8')dentro do próprio tipo? Quero fazer o seguinte:

foo.foo.argtypes = [c_utf8_p]
foo.foo.restype = c_utf8_p

print(foo.foo('Hello World!'))

Consegui lidar argtypescom o seguinte:

class c_utf8_p:
    @classmethod
    def from_param(cls, obj: str):
        return obj.encode('utf8')

Mas não consigo descobrir o tipo de retorno. restypeA documentação diz que atribuí-lo a qualquer coisa que não seja um ctypestipo está obsoleto, além de truncar o valor, into que destrói ponteiros de 64 bits. Gostaria de evitar o uso, errcheckpois, logicamente, não estou verificando nenhum erro, além de exigir a definição de dois atributos para cada função.

Estou portando um aplicativo de console que foi escrito em C visando Linux. Quero tornar o código o mais portátil possível, para que ele também possa ser usado no Windows e outros sistemas operacionais. Até agora, consegui substituir todo o código específico do Linux, como pthreads, semáforos e operações de sistema de arquivos, com cabeçalhos stdlib C++ correspondentes.

Um dos recursos que o aplicativo tem é executar como arquitetura cliente-servidor, para permitir cálculos em segundo plano e persistir e reutilizar o estado quando o cliente CLI sai. Eu li sobre vários métodos IPC, como sockets, pipes e memória compartilhada, mas eles sempre usam syscalls não portáveis.

Existe alguma maneira de fazer isso usando apenas C++ e stdlib? A única solução que consigo pensar é a comunicação baseada em arquivo, mas parece muito difícil manter a atomicidade, especialmente com vários clientes, e o servidor tem que pesquisar o arquivo para alterações, pois todos os métodos de notificação parecem ser específicos do SO também. A última pergunta no Stackoverflow sobre isso tem 15 anos, então talvez algo tenha sido proposto para resolver isso em C++23 e posteriores.