Perguntas[c++](coding)

Estou tentando usar um unordered_map com uma struct personalizada a key. Sei por outros posts que preciso definir uma função hash personalizada e uma função de comparação. Meu problema é o seguinte: A compilação funciona sem erro para STATICuma SHAREDbiblioteca. Mas ao executar, test_execrecebo o seguinte erro quando construo uma STATICbiblioteca:

AddressSanitizer:DEADLYSIGNAL
=================================================================
==19573==ERROR: AddressSanitizer: FPE on unknown address 0x561e54882917 (pc 0x561e54882917 bp 0x7ffea9e6f580 sp 0x7ffea9e6f580 T0)
    #0 0x561e54882917 in std::__detail::_Mod_range_hashing::operator()(unsigned long, unsigned long) const (/home/TEST/minimal_example/build_DEBUG/test_exec+0x4917)
    #1 0x561e5488855f in std::__detail::_Hash_code_base<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, test::MyEnum>, std::__detail::_Select1st, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, true>::_M_bucket_index(unsigned long, unsigned long) const (/home/TEST/minimal_example/build_DEBUG/test_exec+0xa55f)
AddressSanitizer:DEADLYSIGNAL
AddressSanitizer: nested bug in the same thread, aborting

Como faço para que isso funcione para uma STATICbiblioteca?

teste_lib.h

#ifndef TEST_LIB_H
#define TEST_LIB_H

#include <string>
#include <unordered_map>

namespace test {

enum class MyEnum { A, B, C, D };

using enum MyEnum;
const std::unordered_map<std::string, MyEnum> string_to_enum = {
    {"A", A},
    {"B", B},
    {"C", C},
    {"D", D},
};
const std::unordered_map<MyEnum, std::string> enum_to_string = {
    {A, "A"},
    {B, "B"},
    {C, "C"},
    {D, "D"},
};

struct MyStruct {
  MyEnum my_enum;
  unsigned int num;

  bool operator==(const MyStruct &other) const {
    return (my_enum == other.my_enum) && (num == other.num);
  }
};

struct MyStructHash {
  std::size_t operator()(const MyStruct &s) const {
    return std::hash<MyEnum>{}(s.my_enum) ^
           (std::hash<unsigned int>{}(s.num) << 1);
  }
};

using MyMap = std::unordered_map<MyStruct, double, MyStructHash>;
MyMap get_map();
const MyMap MAP = get_map();

} // namespace test

#endif

teste_lib.cpp

#include "test_lib.h"

namespace test {
MyMap get_map() {

  MyMap map;

  map[MyStruct(string_to_enum.at("A"), 2)] = 4.5;

  return map;
}
} // namespace test

teste_exec.cpp

#include "test_lib.h"
#include <iostream>

using namespace test;
int main(int ac, char **av) {
  auto test = string_to_enum.at("A");

  std::cout << enum_to_string.at(test) << std::endl;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.15)

############################
# project name and version #
############################
project( Test VERSION 0.1 LANGUAGES CXX)

##############################
# set c++ flags and standard #
##############################
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS} -O0 -Wall -Wextra -Wpedantic -Wconversion -Wdouble-promotion -Wno-unused-parameter -Wno-unused-function -Wno-sign-conversion -fsanitize=address")

add_library(test_lib STATIC test_lib.cpp)
set_target_properties(test_lib PROPERTIES PUBLIC_HEADER test_lib.h)

add_executable(test_exec test_exec.cpp)
target_link_libraries(test_exec PUBLIC 
  test_lib 
  )

Até agora, construí este exemplo mínimo para descartar quaisquer outros problemas no meu código.

EDITAR:

Depois de definir

extern const MyMap MAP;

em test_lib.h e

const MyMap MAP = get_map();

em test_lib.cpp funciona.

Span se refere a uma memória contínua, por exemplo, uma matriz;

template <typename T>
class Span {
public:
    Span(T first, size_t s) ...;
    Span(T first, T lasst) ...;
public:
    // iterating underlying continuous memory;
    begin() ...
    end() ...
    T & operator[](idx) ...
private:
    T first;
    T last;
};

A função de loop pode iterar todos os intervalos de passagem, como um loop de bolhas aninhado;

template <typename Func, typename ...Spans>
void loop(Func func, Spans &&...spans) {
    // question: how to implements ?
}

exemplo

int main() {
    int arr[] {1, 2, 3};
    float arr2[] {1.1, 2.2};
    int arr3[] {-1, -2, -3};
    
    loop(func, Span(arr, 3), Span(arr2, 2));
    /*
        we can get:
        func(1, 1.1);
        func(1, 2.2);
        func(2, 1.1);
        func(2, 2.2);
        func(3, 1.1);
        func(3, 2.2);
    */

    loop(func, Span(arr, 3), Span(arr2, 2), Span(arr3, 3));
    /*
        we can get:
        func(1, 1.1, -1);
        func(1, 1.1, -2);
        func(1, 1.1, -3);
        func(1, 2.2, -1);
        func(1, 2.2, -2);
        func(1, 2.2, -3);
        func(2, 1.1, -1);
        func(2, 1.1, -2);
        ...
    */
}

como implementar a função de loop, usando recursos da linguagem C++ até C++20 está ok, mas sem biblioteca padrão ou biblioteca de terceiros, apenas implementando manualmente;

nenhuma chamada de função de recursão, melhor for loop; faz com que a recursão facilmente cause estouro de pilha;

usando vetor e tupla, a ligação de estrutura está ok;

Eu tenho o seguinte código.
O que ele faz é remover o nome do arquivo de um caminho relativo.
Meu resultado esperado seria ".\png", o que eu obtenho é uma string vazia...

#include <iostream>
#include <filesystem>
#include <string>

//using namespace std;
namespace fs = std::filesystem;

#define VNAME(xx) (#xx)

int main() {

  std::cout << "Hello World!" << "\n";

  std::string fpath = ".\\png\\DUMMY-AB-42-L.PNG";
  auto fs_fpath = fs::path(fpath);
  auto fs_fpath_str = fs_fpath.string();

  std::cout << VNAME(fpath) << ":=" << fpath << "\n";
  std::cout << VNAME(fs_fpath_str) << ":=" << fs_fpath_str << "\n";

  fs_fpath.remove_filename();
  fs_fpath_str = fs_fpath.string();
  std::cout << VNAME(fs_fpath_str) << ":=" << fs_fpath_str << "\n";

  return 0;
}

a saída é:

Hello World!  
fpath:=.\png\DUMMY-AB-42-L.PNG  
fs_fpath_str:=.\png\DUMMY-AB-42-L.PNG  
fs_fpath_str:=  

A pergunta simples é: Bug ou Recurso?

C++ 20 apresenta std::ranges::iota_view.

Pode ser usado como parte de um forloop, por exemplo.

for (auto i: std::ranges::iota_view(0, 10))

Parece levar dois parâmetros de template. Por exemplo, o seguinte será compilado.

std::ranges::iota_view<int64_t, int64_t>(0, 10)

O primeiro parâmetro do modelo é Wwhich should be std::weakly_incrementable. O segundo parâmetro do modelo é Boundwhich should be std::semiregular.

Qual é o propósito desses dois parâmetros de template? Eles podem ser usados ​​para controlar o tipo retornado por iota_view?

Em outras palavras, que efeito, se houver, eles têm no tipo deduzido auto ino exemplo acima?

Acho que a melhor maneira de descrever o que estou perguntando é com uma imagem. Digamos que eu tenha este código C++:

Digamos que eu queira pular rapidamente do ponto 1 para o ponto 2 (e vice-versa), existe um atalho no VS 2022 (código C++) para fazer isso?

Li o manual e naveguei na internet, mas não encontrei nada que mencionasse isso. Espero que esse recurso exista, porque o considero extremamente útil.

No momento tenho o seguinte código:

#include <iterator>
#include <vector>
struct bar{};
struct details {};
struct foo {
    details det;
    std::vector<bar> data;
};

template <std::input_iterator Iter>
foo create_foo(const details& details, Iter begin, Iter end) {
    return foo {
        .det = details,
        .data = {begin, end}
    };
}

int main() {

    std::vector<bar> bars = {bar{},bar{},bar{}};
    create_foo({}, bars.begin(), bars.end());
    return 0;
}

Demonstração do Godbolt

foo::dataé um Container para bars. Seu construtor recebe dois Iteradores.

Quero restringir os iteradores de entrada para serem iteradores de contêineres contendo barapenas, por exemplo, um std::vector<bar>::iteratorou umstd::list<bar>::iterator

Como eu conseguiria isso com conceitos?

Qual é o nome do recurso C++ que me permite, por exemplo, instanciar automaticamente um std::pairquando ele encontra {"key", "value"}na chamada push_back abaixo?

using thepair = std::pair<std::string, std::string>;
std::vector<thepair> myvec;
myvec.push_back({"key", "value"});

Entendo que o compilador chamará std::pair<std::string, std::string>{"key", "value"}nos bastidores antes de enviar para o vetor. Qual é o nome desse recurso? É algo como "autoboxing" ou "instanciação estruturada"?

Por que esse código é ambíguo começando com C++20?

template <typename T>
struct base_widget {
    bool operator==(T const&) const;
};

struct gadget : base_widget<gadget> {};

bool foo(gadget const& a, gadget const& b) {
    return a == b;
}

para MSVC isso é um erro:

error C2666: 'base_widget<gadget>::operator ==': overloaded functions have similar conversions  
    could be 'bool base_widget<gadget>::operator ==(const T &) const'
          with
          [
              T=gadget
          ]
     or 'bool base_widget<gadget>::operator ==(const T &) const' [synthesized expression 'y == x']
         with
         [
             T=gadget
         ]
    while trying to match the argument list '(const gadget, const gadget)'

para o GCC é um aviso:

In function 'bool foo(const gadget&, const gadget&)':
warning: C++20 says that these are ambiguous, even though the second is reversed:
      |     return a == b;
      |                 ^
note: candidate 1: 'bool base_widget<T>::operator==(const T&) const [with T = gadget]'
      |     bool operator==(T const&) const;
      |          ^~~~~~~~
note: candidate 2: 'bool base_widget<T>::operator==(const T&) const [with T = gadget]' (reversed)

E também um aviso para Clang:

warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'const gadget' and 'const gadget') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
      |     return a == b;
      |            ~ ^  ~
note: ambiguity is between a regular call to this operator and a call with the argument order reversed
      |     bool operator==(T const&) const;
      |  

Eu sei que C++20 permite isso:

Resolução de sobrecarga/operadores em expressões

[sobre.correspondência.oper]

Para os operadores de igualdade, os candidatos reescritos também incluem um candidato sintetizado, com a ordem dos dois parâmetros invertida, para cada candidato não reescrito para a expressão y == x.

Mas por que o operador reverso sintetizado é problemático neste caso?

EDIT: Fazer o operator==a friendcorrige o problema:

template <typename T>
struct base_widget {
    friend bool operator==(T const&, T const&);
};

Por que não há problema em reverter neste caso?

Continuando a pergunta de ontem: std::priority_queue pre-allocate memory erro de memória

Estou trabalhando em um projeto determinístico em tempo real que tem um ciclo de execução por iteração de algumas centenas de microssegundos.

Estou enfrentando um problema em que a operação push em um std::queue e std::priority_queue aleatoriamente está levando muito tempo. A operação push geralmente leva cerca de 5 a 25 microssegundos, mas aleatoriamente leva de 300 microssegundos a 5 milissegundos.

Para superar esse problema, decidi pré-alocar memória para meu std::queue e std::priority_queue.
Estou me referindo à seguinte resposta: https://stackoverflow.com/a/79433983/6319901
SO de desenvolvimento: Ubuntu 24.04 LTS.
Meu SO de destino: vxWorks 7
Linguagem: C++17

Código:

#include <queue>
#include <array>
#include <vector>
#include <string>
#include <cstdint>
#include <iostream>
#include <functional>

static const std::size_t MAX_PACKET_LENGTH = 512;

struct receive_t
{
    int             data1;
    float           data2;
    std::string     data;
    receive_t()
    {
        data.reserve(MAX_PACKET_LENGTH);
    }
};


int main(int argc, char const *argv[])
{
    std::cout << "Hello, World!!!\n";
    std::vector<receive_t> container;
    container.reserve(1000);
    std::queue<receive_t, 
        std::vector<receive_t>> q 
    (
        std::move(container)
    );
    std::cout << "sizeof(receive_t) : " << sizeof(receive_t) << std::endl;
    std::cout << "sizeof(q) : " << sizeof(q) << std::endl;
    std::cout << "q.size() : " << q.size() << std::endl;
    return 0;
}

Saída:

Hello, World!!!
sizeof(receive_t) : 40
sizeof(q) : 24
q.size() : 0

Tenho 2 perguntas:

1. Como verifico a memória total alocada para a fila? De acordo com meus cálculos ( sizeof(receive_t)+ 512) * 1000 bytes devem ser alocados.MAX_PACKET_LENGTH: 512
2. Posso anexar um retorno de chamada ou um gancho à minha rotina de alocação de memória para poder detectar quando minha fila solicita memória adicional?

Tenho uma construção semelhante ao CRTP:

class Derived : public Base<Derived>

Preciso calcular um ponteiro para um Derivedobjeto a partir de um ponteiro para Base<Derived>objeto via reinterpret_cast. Não posso usar dynamic_castporque não estou usando funções virtuais aqui.

Os tipos são fornecidos, eu tenho o ponteiro para o Base<Derived>objeto. Preciso do deslocamento de bytes entre os dois tipos, para poder usar reinterpret_cast. Como faço isso (sem comportamento indefinido)? É possível fazer em tempo de compilação / salvar como uma static constexprvariável (estou usando C++20)?