问题[c++](coding)

假设我有一个struct包含多个数字字段的普通旧数据（POD）。

我想重载比较运算符，以便可以比较我的 POD 的两个实例。

问题是我需要对这些运算符（比如，运算符less()）进行重载，以适应 POD 中的每个数字字段。

显然，下面的代码不起作用，因为编译器无法区分这两个版本：

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

因此，我编写了自己的自定义函数lessThan()，它接受一个标志并执行该作业，但我并不特别喜欢这个解决方案（在下面的MWE中），因为我无法<像使用比较运算符那样轻松地使用它。

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

有没有办法以某种方式为struct具有许多数值字段的自定义 POD 创建多个比较运算符重载，每个重载比较其中一个字段？

（为了给您提供更多背景信息，我需要这些重载来根据文件的任何特征对文件数组进行排序：例如按维度、按最后修改日期、按包含的文件或子目录的数量等。

在上面的简化示例中，每个 POD 实例抽象一个文件。）

编辑：

预期用途草图：

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

我正在编写一个 C++ 库，它处理包含一些时间值的数据 - 这些值不是源自运行该库的系统。我想将这些值放入 中std::chrono::time_point（将向库的用户公开）。

现在，要做到这一点，我需要指定一个Clock类型。好的，那应该不是问题，对吧？我可以满足所有的要求，不是吗？...嗯，不，不是真的，我有一个障碍：now()功能。我无法now()为生成我正在查看的时间点值的系统提供值！我无法访问它，也许它不再存在；它可能已经停止，或被重置，或完全不复存在。

这是否意味着我不应该使用std::chrono类型？或者我应该创建一个时钟类型，其now()函数返回一个固定的虚拟值？或者人为增加值？

问题：

我在 QWidget 中有一个 QQuickWidget，我正在将此小部件添加到 QMdiArea。我正尝试(plusBtn())使用 从 C++调用 QML 函数QMetaObject::invokeMethod。但是，当我尝试调用该方法时，我的应用程序崩溃了。只有当窗口添加到 QMdiArea 时才会发生此崩溃。当我从 QMdiArea 中删除小部件时，一切都正常。

这是我的简化代码：

QML（地图.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++（主窗口实现）：

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

当我在窗口添加到 QMdiArea 后尝试调用 plusBtn() 时，会发生崩溃。有时应用程序会因分段错误而崩溃，有时我会收到消息：QMetaObject::invokeMethod:No such method QQuickPinchHandler::plusBtn()

我尝试的方法：我检查了 QQuickWidget 是否正确初始化，并且 setSource(QUrl("qrc:/Map.qml")) 加载 QML 文件没有问题。QML 文件加载正确，rootObject() 不为 nullptr，并且 QML 对象中存在方法 plusBtn()。只有当将小部件添加到 QMdiArea 时才会发生崩溃 — 如果在添加之前调用 plusBtn()，它会正常工作，但是一旦小部件位于 QMdiArea 内，调用 plusBtn() 有时会导致分段错误。

崩溃前的调试输出：

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

输出：

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

我将非常感激任何关于为什么会发生这种情况以及如何解决它的见解。

我已经写了下面的代码......

#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) {
   }
}

我在 C++17 及更高版本上获得以下输出...

Constructor called
Copy Constructor called

甚至 C++17 保证的复制省略也说"Copy elision is mandatory in Throwing and catching exceptions by value"。我得到了"Copy Constructor called"as 输出。

我是否遗漏了什么？

我有一组struts，每个都有一个data_t成员类型（省略其他成员）：

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

在编译时，选择其中的一些来填充复合类型（也带有相应的data_t成员）：

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

目前，我正在使用 CMake来填充定义configure_file的 序列和 的附带内容。是否可以使用可变模板和/或折叠表达式来派生后者？structbase_tFoo::data_tbase_t

使用折叠表达式，我可以稍微简化的构造Foo::data_t，而只需要提供一个整数序列（长度相同）：

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

但是，这仍然需要Bar::data_t手动/CMake 配置的内容（这使得它可能容易出错）。我曾希望std::index_sequence可以使用适当构造的内容来填充helper模板，但这会产生编译器错误（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
};

我读过一些关于可变参数模板的文章，但不知道它们如何应用于using语句。我是不是错过了什么窍门？

谢谢

我正处于编写 C++ 程序的早期阶段，该程序复制了 bash 命令的最基本功能ls。

我使用<filesystem>标题。

该库中的std::filesystem::directory_iterator和std::filesystem::recursive_directory_iterator分别帮助我以浅层或递归的方式遍历输入文件路径。

输入接收一个argv[1]，它应该由一个首连字符-和后面代表选项标志的字母组成。标志R代表递归遍历所有子目录，否则，只查看给定的路径。

argv[2]是要探索的文件路径。

然而我的问题是如何以模板化的方式运行它，或者是否完全可能。

作为测试，我正在使用std::variant一个函数，该函数根据输入中是否存在标志来option_R()选择正确的。directory_iterator-R

由于这将是运行时多态性，我怀疑我是否可以实现类似下面的内容：

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

上述内容无法编译，其中一个原因是因为我随意使用概念isIter来option_R()调用main。

有没有办法编写option_R()，以便它只做一件事：directory_iterator根据是否-R给出标志来选择正确的 - 然后将其传回main()？

将其打包option_R()并traverse()放在一个函数中很容易，但是这会做多件事，并且代码会更难理解。

我正在尝试使用带有自定义结构 a 键的 unordered_map。我从其他帖子中知道，我需要定义自定义哈希函数和比较函数。我的问题如下：编译STATIC和SHARED库均无错误。但在执行时，test_exec当我构建库时出现以下错误STATIC：

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

我怎样才能让它为STATIC图书馆服务？

测试库

#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

测试库.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

测试执行文件

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

到目前为止，我已经构建了这个最小的示例来排除我的代码中的任何其他问题。

编辑：

定义后

extern const MyMap MAP;

在 test_lib.h 和

const MyMap MAP = get_map();

在 test_lib.cpp 中它可以工作。

Span 指一段连续的内存，例如一个数组；

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

loop 函数可以迭代所有通过的 span，就像嵌套的冒泡循环一样；

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

例子

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);
        ...
    */
}

如何实现循环函数，使用c++语言特性到c++20都可以，但是没有标准库或者第三方库，只能手动实现；

没有递归函数调用，最好使用 for 循环；因为递归容易导致堆栈溢出；

使用向量和元组，结构绑定就可以了；

我有以下代码。
它的作用是从相对路径中删除文件名。
我预期的结果是“.\png”，但我得到的是一个空字符串...

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

输出为：

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

简单的问题是：错误还是功能？

C++ 20 引入std::ranges::iota_view。

for例如，它可以用作循环的一部分。

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

它似乎需要两个模板参数。例如，下面的代码可以编译。

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

第一个模板参数是Wwhich should be std::weakly_incrementable。第二个模板参数是Boundwhich should be std::semiregular。

这两个模板参数有什么用处？能用来控制 返回的类型吗iota_view？

换句话说，如果有的话，它们对auto i上面例子中推导的类型有什么影响？