Perguntas[c++](coding)

Digamos que eu tenha um banco de dados simples (POD) structcontendo vários campos numéricos.

Quero sobrecarregar os operadores de comparação para poder comparar duas instâncias do meu POD.

O problema é que preciso de uma sobrecarga para esses operadores - digamos, operador less()- para cada um dos campos numéricos no POD.

Obviamente, o abaixo não funciona porque o compilador não tem como distinguir as duas versões:

struct my_struct{
    int a;
    int b;
    int c;
};

bool operator<(const my_struct& one, const my_struct& two) {
    return one.a < two.a;
}

bool operator<(const my_struct& one, const my_struct& two) {
    return one.b < two.b;
}

Então escrevi minha própria função personalizada lessThan(), que aceita um sinalizador e faz o trabalho, mas não gosto particularmente dessa solução (no MWE abaixo), pois não posso usá-la <como faria facilmente com um operador de comparação.

#include <iostream>
#include <iomanip>

struct my_struct{
  int a;
  int b;
  int c;
};

bool lessThan(const my_struct& one, const my_struct& two, const char flag) {
  switch (flag) {
    case 'a':
      return one.a < two.a;
      break;
    case 'b':
      return one.b < two.b;
      break;        
    case 'c':
      return one.c < two.c;
      break;
    default:
      throw("Either case a, b, or c\n");
      break;
  }     
}

int main()
{
  my_struct one{1, 3, 4};
  my_struct two{2, 2, 4};
  std::cout << "one < two: " << std::boolalpha 
            << lessThan(one, two, 'a') << std::endl;

  return 0;
}

Existe uma maneira de criar múltiplas sobrecargas de operadores de comparação para PODs personalizados structcom muitos campos numéricos, com cada sobrecarga comparando um desses campos?

(Para lhe dar mais contexto, preciso dessas sobrecargas para classificar uma matriz de arquivos de acordo com qualquer uma de suas características: como por dimensão, por data da última modificação, por número de arquivos contidos ou subdiretórios, etc.

No exemplo simplificado acima, cada instância POD abstrai um arquivo.)

EDITAR:

Esboço do uso pretendido:

sortAccordingToFieldA(std::vector<my_struct>& my_vec, int a){
  for (auto i : my_vec) {
    for (auto j : [std::find(my_vec.begin(), my_vec.end(), i)+1, my_vec.end()] ) {
      if (i < j)  // here '<' is overloaded according to field 'a'
        // sorting operations
    }
  } 
}

Estou escrevendo uma biblioteca C++, que trabalha com dados que têm alguns valores de tempo neles - valores que não se originam no sistema em que a biblioteca é executada. Quero colocar esses valores em std::chrono::time_point's (que serão expostos aos usuários da biblioteca).

Agora, para fazer isso, preciso especificar um Clocktipo. Ok, isso não deve ser um problema, certo? Posso atender a todos os requisitos de , não posso? ... hmm, não, não realmente, tenho um obstáculo: a now()função. Não posso fornecer um now()valor para o sistema onde os valores de ponto de tempo que estou olhando foram gerados! Não tenho acesso a ele, e talvez ele nem exista mais; e pode ter parado, ou sido reiniciado, ou deixado de existir completamente.

Isso significa que eu não devo usar std::chronotipos? Ou devo criar um tipo de relógio cuja now()função retorna um valor fictício fixo? Ou um valor artificialmente crescente?

Problema:

Tenho um QQuickWidget dentro de um QWidget e estou adicionando esse widget a uma QMdiArea. Estou tentando chamar uma função QML (plusBtn())de C++ usando QMetaObject::invokeMethod. No entanto, meu aplicativo trava quando tento invocar o método. Essa trava acontece somente quando a janela é adicionada à QMdiArea. Quando removo o widget da QMdiArea, tudo funciona bem.

Aqui está meu código simplificado:

QML (Mapa.qml):

import QtQuick
import QtLocation
import QtPositioning

Rectangle {
    id: rectangle

    Plugin {
        id: mapPlugin
        name: "osm"
    }

    Map {
        id: mapView
        anchors.fill: parent
        plugin: mapPlugin
        zoomLevel: 15
        minimumZoomLevel: 2
        activeMapType: supportedMapTypes[0]
    }

    function plusBtn() {
        if (mapView.zoomLevel < mapView.maximumZoomLevel) {
            mapView.zoomLevel = Math.round(mapView.zoomLevel + 1);
        }
    }
}

C++ (Implementação MainWindow):

#include <QDebug>
#include <QMainWindow>
#include <QPushButton>
#include <QQmlEngine>
#include <QQuickItem>
#include <QQuickWidget>
#include <QVBoxLayout>
#include <QWidget>
#include <QApplication>
#include <QMDIArea>

class QmlWindow : public QWidget
{
public:
    QmlWindow(QWidget* parent = nullptr)
        : QWidget(parent)
    {
        QVBoxLayout* layout = new QVBoxLayout(this);

        // Create and initialize the QQuickWidget
        quickWidget = new QQuickWidget(this);
        quickWidget->setSource(QUrl(QStringLiteral("qrc:/Map.qml")));
        quickWidget->setResizeMode(QQuickWidget::SizeRootObjectToView);

        auto rootObj = quickWidget->rootObject();

        // Create a button to invoke the QML method
        QPushButton* button = new QPushButton("Call QML Method");
        connect(button, &QPushButton::pressed, this, [=]() {
            if (!rootObj) {
                qWarning() << "Root object is null!";
                return;
            }
            QMetaObject::invokeMethod(rootObj, "plusBtn");
        });

        layout->addWidget(quickWidget);
        layout->addWidget(button);
        setLayout(layout);
    }

private:
    QQuickWidget* quickWidget;
};

class MainWindow1 : public QMainWindow
{
public:
    MainWindow1(QWidget* parent = nullptr)
        : QMainWindow(parent)
    {
        mdiArea = new QMdiArea(this);
        setCentralWidget(mdiArea);

        QPushButton* openWindowBtn = new QPushButton("Open QML Window", this);
        connect(openWindowBtn, &QPushButton::clicked, this, &MainWindow1::openQmlWindow);

        setMenuWidget(openWindowBtn);
    }

private:
    void openQmlWindow()
    {
        QmlWindow* window = new QmlWindow();
        QMdiSubWindow* subWindow = mdiArea->addSubWindow(window);
        window->show();
    }

    QMdiArea* mdiArea;
};

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    MainWindow1 mainWindow;
    mainWindow.show();
    return app.exec();
}

O crash ocorre quando tento invocar plusBtn() depois que a janela é adicionada à QMdiArea. Às vezes, o aplicativo trava com Segmentation Fault, e outras vezes recebo a mensagem: QMetaObject::invokeMethod:No such method QQuickPinchHandler::plusBtn()

O que eu tentei: Eu verifiquei se o QQuickWidget foi inicializado corretamente, e setSource(QUrl("qrc:/Map.qml")) carrega o arquivo QML sem problemas. O arquivo QML carrega corretamente, rootObject() não é nullptr, e o método plusBtn() existe no objeto QML. A falha ocorre somente quando o widget é adicionado ao QMdiArea — se eu invocar plusBtn() antes de adicioná-lo, ele funciona bem, mas uma vez que o widget está dentro do QMdiArea, chamar plusBtn() às vezes causa uma falha de segmentação.

Saída de depuração antes da falha:

auto rootObj = ui->quickWidget->rootObject();
if (!rootObj) {
    qWarning() << "Root object is null!";
    return;
}

qDebug() << "Root object type:" << rootObj->metaObject()->className();
for (int i = 0; i < rootObj->metaObject()->methodCount(); ++i) {
    qDebug() << "Method:" << rootObj->metaObject()->method(i).methodSignature();
}

Saída:

Root object type: Map_QMLTYPE_0  
Method: "plusBtn()"  

Eu apreciaria qualquer informação sobre o porquê disso estar acontecendo e como posso resolver o problema.

Eu escrevi o código abaixo...

#include <iostream>
using namespace std;

struct Error {
   Error() { cout << "Constructor called\n"; }
   Error(const Error&) { cout << "Copy Constructor called\n"; }
};
void test() {
   throw Error();
}
int main() {
   try {
      test();
   }
   catch (Error e) {
   }
}

Estou obtendo a seguinte saída no C++17 e versões posteriores...

Constructor called
Copy Constructor called

Até mesmo a elisão de cópia garantida do C++17 diz "Copy elision is mandatory in Throwing and catching exceptions by value". Estou obtendo a "Copy Constructor called"saída as.

Estou esquecendo de alguma coisa?

Tenho uma coleção de struts, cada um com um data_ttipo de membro (outros membros omitidos):

struct A { using data_t = int; };
struct B { using data_t = double; };
struct C { using data_t = bool; };
// etc.

Em tempo de compilação, uma seleção destes é escolhida para preencher um tipo composto (também, com um data_tmembro correspondente):

#include <tuple>

using base_t = std::tuple<A, B, A, C>;

struct Foo : public base_t {
  using data_t = std::tuple<A::data_t, B::data_t, A::data_t, C::data_t>;
};

Atualmente, estou usando o CMake configure_filepara preencher tanto a sequência de structs que define base_t, quanto o conteúdo que o acompanha de Foo::data_t. É possível derivar o último base_tusando modelos variádicos e/ou expressões fold?

Usando uma expressão fold, posso simplificar um pouco a construção de Foo::data_t, em vez de precisar apenas fornecer uma sequência de inteiros (do mesmo comprimento):

#include <utility>

template<size_t... idx>
using helper = std:: tuple<
  typename std::tuple_element_t<idx, base_t>::data_t ...
>;

struct Bar : public base_t {
  using data_t = helper<0, 1, 2, 3>;
};

No entanto, isso ainda requer que o conteúdo Bar::data_tseja configurado manualmente/CMake (o que o torna potencialmente propenso a erros). Eu esperava que uma construção adequada std::index_sequencepudesse ser usada para preencher o helpermodelo, mas isso produz um erro do compilador (Intel C++ 2023.02)

struct Baz : public base_t {
  static constexpr auto indices{std::make_index_sequence<std::tuple_size_v<base_t>>};

  using data_t = helper<indices>;  // error: cannot convert std::index_sequence to size_t
};

Li um pouco sobre modelos variadic, mas não consegui descobrir como eles podem ser aplicados a uma usingdeclaração. Estou perdendo um truque?

Obrigado

Estou em um estágio muito inicial na escrita de um programa em C++ replicando as funções mais básicas do lscomando bash.

Eu uso o <filesystem>cabeçalho.

O std::filesystem::directory_iteratore std::filesystem::recursive_directory_iteratordessa biblioteca me ajudam a percorrer o caminho do arquivo de entrada de maneira superficial ou recursiva, respectivamente.

A entrada recebe um argv[1], que deve ser composto de um hífen inicial -, seguido por letras representando sinalizadores de opção. Flag Rrepresenta travessia recursiva de todos os subdiretórios, caso contrário, olhe apenas para o caminho fornecido.

argv[2]é o caminho do arquivo a ser explorado.

Minha dúvida, no entanto, é sobre como executar isso de forma padronizada ou se isso é possível.

Como teste, estou usando std::variantuma função option_R()que seleciona o correto directory_iteratordependendo se o -Rsinalizador está presente na entrada ou não.

Como isso seria polimorfismo de tempo de execução, estou cético quanto à possibilidade de implementar algo como o abaixo:

#include <iostream>
#include <vector>
#include <string>
#include <filesystem>
#include <variant>

#include <type_traits>
#include <concepts>

using namespace std;
using namespace std::filesystem;

template<typename T> concept isIter = 
  is_same<T, directory_iterator>::value || is_same<T, recursive_directory_iterator>::value;

template <isIter dirIterator>
dirIterator option_R(std::string_view options, const path &my_path) {
  variant<directory_iterator, recursive_directory_iterator> my_iter;
  if (options.find('R') != string::npos) {
    my_iter.emplace<recursive_directory_iterator>(my_path, directory_options::skip_permission_denied);
    return get<recursive_directory_iterator>(my_iter);
  } else {
    my_iter.emplace<directory_iterator>(my_path);
    return get<directory_iterator>(my_iter);
  }
}

template <isIter dirIterator>
void traverse(isIter &my_iter, vector<string> &my_vec) {
  cout << "This function traverses the given dir path, "
       << "stores all filenames found inside a vector." << endl;
  for (const auto &entry : my_iter)
    my_vec.push_back(entry.path().string());
}

int main(int argc, const char **argv) {
  const path sys_path{argv[2]};
  const string options{argv[1]};

  vector<string> files;
  if (options[0] == '-') {
    if (is_directory(sys_path)) {
      isIter file_iterator = option_R(options, sys_path);
      traverse(file_iterator, files);
    }
    cout << "after this the program will parse other options" << endl;
  } else {
    cout << "simply print all files" << endl;
  }
}

O acima não compila, entre outros motivos porque eu uso vagarosamente o conceito isIterpara invocar option_R()em main.

Haveria uma maneira de escrever option_R(), de modo que ele fizesse apenas uma coisa: selecionar o correto directory_iteratorde acordo com o sinalizador -Rfornecido ou não - e passá-lo de volta para main()?

Seria fácil agrupar option_R()e traverse()reunir em apenas uma função, mas isso faria várias coisas e o código seria mais difícil de entender.

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?