yrHeTateJlb提出的问题

yrHeTateJlb

Asked: 2020-10-01 20:00:09 +0800 CST

初始化类字段的最佳方法。move vs const &

1

有一个带有一些复制字段的类。

class Foo{
    Bar _bar;
    //...
};

在移动语义之前，我会说初始化_bar它的最好方法是传递一个常量引用：

Foo::Foo(const Bar &bar) : 
    _bar(bar)
{}

但为了让我们的生活~~变得更加艰难~~和美好，移动语义出现了。我有一个问题。现在初始化类字段的最佳方法是什么？粗略地说，这一切都归结为：

Foo::Foo(const Bar &bar) : 
    _bar(bar)
{}

对比

Foo::Foo(Bar bar) : 
    _bar(std::move(bar))
{}

很明显，在某些情况下，一个构造函数更好，而在其他情况下，另一个构造函数更好。关于这个主题是否有任何“经验法则”或最佳实践？

yrHeTateJlb

Asked: 2020-02-14 21:42:12 +0800 CST

在空指针处调用方法

6

今天又发生了与同事的争执。他们认为这样的代码没有问题，并且在任何地方都可以正常工作：

#include <iostream>

struct S{
    int a;
    void foo(){
        std::cout << "hello";
    }
};

int main(){
    S *p = nullptr;
    p->foo();  //hello
}

他们说我们不访问数据 => 我们没有爬入地址 0 的内存 => 没有问题。我用嘴巴向他们证明，如果你调用任何非静态方法，nullptr这将立即成为未定义的行为，在这个方法中发生什么并不重要。

问题：

谁是对的？
它在标准中写在哪里？
标准中是否有关于如何实施的内容this？

yrHeTateJlb

Asked: 2020-01-24 19:47:36 +0800 CST

统一初始化

4

C++11 有一个新的初始化语法。这是 Scott Myers 在他的《Effective Modern C++》一书中所写的：

class Widget {
public:
  Widget();                                   // default ctor
  Widget(std::initializer_list<int> il);      // std::initializer_list ctor
  …                                           // no implicit conversion funcs
}; 

Widget w1;          // calls default ctor
Widget w2{};        // also calls default ctor
Widget w3();        // most vexing parse! declares a function!    

Widget w4({});      // calls std::initializer_list ctor with empty list
Widget w5{{}};      // ditto

如果我们以他的例子为例，去掉多余的部分，并将 print 添加到构造函数Widget中，事实证明Widget w4({});这Widget w5{{}};不是一回事：

#include <iostream>
#include <initializer_list>

class Widget{
public:
    Widget(){

    }
    Widget(std::initializer_list<int> l){
        std::cout << "l.size = " << l.size() << std::endl;
    }
};

int main(){
    Widget w4({}); //l.size = 0
    Widget w5{{}}; //l.size = 1
}

例子

我有两个问题：

斯科特在骗我们吗？
到底发生了什么？

yrHeTateJlb

Asked: 2021-01-01 03:41:21 +0800 CST

阻塞进程直到线程/子进程退出

5

有这个代码：

if(pid_t pid = fork()) // spawn child process
{
    // parent process
    LOG("Try to execute smth. in child process");
    return;
}
else
{
    // child process
    doWork();
    std::terminate();
}

这里产生了一个子进程，其中执行了一些工作。在其他地方（即在流程结束时）有这样的：

// wait childern(some code may call fork())
const pid_t pid{::wait(nullptr)};

在这里，该进程正在等待子进程（之前分叉的）终止。所以，所有这些乐趣都不能与 key 一起使用-fsanintize=thread。代码挂起是wait因为编译器添加了一些不会自行终止的子进程。

问题。如何在没有的情况下实现类似的行为wait？这样任务异步运行，主进程在终止时等待这些任务完成。也许使用线程，而不是进程。如果我有 Qt 可供我使用，我会将它们doWork放入QThreadPool其中，他会等待析构函数中所有任务的完成。但我没有 Qt，但我有 C++14 和 pthread。有人可以提出任何解决方案吗？

yrHeTateJlb

Asked: 2020-12-20 19:52:23 +0800 CST

函数参数的数量

10

最近有一个问题是关于如何用给定类型的 n 个参数声明一个函数。我有相反的问题。如何找到函数的参数数量？

#include <iostream>

void foo(float, int){

}

int main(){
    std::cout << doTemplateMagic(foo); //2
}

yrHeTateJlb

Asked: 2020-09-30 17:48:12 +0800 CST

Qt 4.8 文档显示错误

0

从 Qt Creator 4.2.1 开始，Qt 4.8 的文档如下所示：

Qt 5.8 的文档一切正常：

在旧版本的 Qt Creator 上，这两个文档都很好。

有人遇到过这个问题吗？也许您可以在某个地方下载更正的文档文件？或者以某种方式通过 qhelpgenerator 收集 *.qch 文件？

yrHeTateJlb

Asked: 2020-08-10 18:46:09 +0800 CST

整个表达式的类型

6

我最近写了这个函数：

template<class T>
bool isAvailableSpace(int size, int capacity){
    return capacity - size - sizeof(T) >= 0;
}

capacity- 一些缓冲区的容量
size- 使用的字节数。
该函数检查缓冲区中是否有足够的空间用于类型对象T。问题原来是表达式的结果capacity - size - sizeof(T)是无符号的，因为sizeof. 所以函数总是返回true。

实际上是一个问题：为什么会这样？表达式涉及有符号和无符号变量，为什么编译器优先考虑无符号变量？

yrHeTateJlb

Asked: 2020-03-09 15:18:22 +0800 CST

使用 std::find_if 不用于搜索

5

我会立即为这么模糊的名字道歉，我不知道如何概括地描述这个任务。

假设我们有一个类可以做一些工作：

class Worker{
public:
    bool doWork(int arg);
};

如果作业成功完成，该方法doWork将返回。true现有员工之一必须完成这项工作。为此，我想使用std::find_if

struct DoWork{
    int arg;
    explicit DoWork(int arg):
        arg(arg)
    {}
    bool operator()(Worker &worker) const{
        return worker.doWork(arg);
    }
};

std::vector<Worker> workers;
//...
std::find_if(workers.begin(), workers.end(), DoWork(42));

这个想法是这样的。该算法将遍历工人，直到有人完成工作或他们用完为止。但我被模糊的怀疑所折磨，是否有可能这样做。这里有未定义的行为吗？这段代码在不同的 stl 实现上总是工作相同吗？

yrHeTateJlb

Asked: 2020-03-03 00:59:20 +0800 CST

将点插入多边形

2

有一些折断的曲线作为一组点给出。我正在尝试提出一种算法，用于将新点插入到该曲线中。我只是想不出一种方法来确定插入位置。

首先想到的是考虑一个新点和一对已有的相邻点组成的三角形，选择周长最小的三角形。然而，对于这种情况，算法将认为有必要在第一个和第二个之间插入一个新点。虽然第二个和第三个明显更好。

我也想过考虑同样的三角形，选择高度最小的那个。但即使在这里，该算法在某些情况下也无法正常工作。例如这里

该算法将选择点 3 和 4 之间的位置，而不是 1 和 2。

为了排除这种情况，我决定只考虑底部有锐角的三角形。但即使在这里也有例外。两个候选三角形的底角都是钝角。

基本上，我被困住了。这个问题肯定有一些解决方案，或者至少有一个可以用 google 搜索到的名称。毕竟，人们会编写各种 autocad 之类的东西。

yrHeTateJlb

Asked: 2020-12-30 02:56:38 +0800 CST

使用新的（这个）

8

阅读C++ 超级常见问题解答。在构造函数部分，我看到了以下语句：

顺便说一句，不要试图通过放置新的来实现这一点。有些人认为他们可以在 Foo::Foo(char) 的主体内说 new(this) Foo(x, int(x)+7) 。然而，那是不好的，不好的，不好的。请不要写信告诉我它似乎适用于您的特定编译器的特定版本；这不好

关键是绝对不可能这样做：

class Foo{
public:
    Foo(char x){
        new (this) Foo(x, int(x)+7); 
    }
    Foo(char x, int y){
        //...
    }
};

任何人都可以更详细地解释这个技巧威胁到什么吗？

UPD：我怀疑在这个例子中一切都会好起来的，问题将从继承、动态资源分配等开始。

yrHeTateJlb

Asked: 2020-12-08 21:19:08 +0800 CST

将父子对转换为路由

2

我需要在无向未加权图上找到从每个人到每个人的最短路径。经过一番谷歌搜索后，我发现了 Dijkstra 算法。该算法的输出类似于QMap<int, int>。第一个int是父节点，第二个是最短路径中的后继节点。

例如，如果您在这样的图中寻找从零开始的顶点路径：

我会得到这个集合：
0 - 0
1 - 0
2 - 3
3 - 1
4 - 1

现在的问题是如何有效地将其转换为路径？

现在我这样做：

//Поиск родителя
QMap<int, int>::ConstIterator findParent(const QMap<int, int> &map,
                                         int child){
    QMap<int, int>::ConstIterator parent = map.find(child);

    if(child == *parent){
        return map.end();
    }

    return parent;
}
//-----------------------------------------------------------------------
//Построение маршрута
QVector<int> route(const QMap<int, int> &map,
                   int start){
    QVector<int> route;
    route.append(start);

    forever{
        QMap<int, int>::ConstIterator parent = findParent(map, route.last());

        if(parent == map.end()){
            break;
        }

        route.append(*parent);
    };

    return route;
}
//-----------------------------------------------------------------------
//Построение маршрутов
QVector<QVector<int> > routes(const QMap<int, int> &map){
    QVector<QVector<int> > routes;
    QMap<int, int>::ConstIterator begin = map.begin();
    QMap<int, int>::ConstIterator end = map.end();

    for(; begin != end; ++begin){
        routes.append(route(map, begin.key()));
    }

    return routes;
}

它可以工作，甚至可以正常工作。但我怀疑这是最有效的方法。我多次在地图中寻找相同的值。也许有可能以某种方式在一次通过QMap<int, int>中构建路由，或者在执行算法时立即构建路由？

一个最小的例子，如果突然有人需要它

yrHeTateJlb

Asked: 2020-11-22 20:47:52 +0800 CST

在 QVariant 中进行类型转换

3

可能标题看起来有点乱，直接上例子：

double d = 3.14;
QVariant v(d);
qDebug() << v.value<int>();  //3

QVariant进行了演员表double-> int。

我想做同样的事情，但要有指针：

class Foo : public QObject{
    Q_OBJECT;
};
Q_DECLARE_METATYPE(Foo*)
static const int __idFoo = qRgisterMetaType<Foo*>("Foo*");

//...

Foo *foo = new Foo();
QVariant v = QVariant::fromValue(foo);
qDebug() << v.value<QObject*>();  //QObject(0x0)

类型转换没有发生。
问题：有什么方法可以将指向派生类对象的指针放入QVariant，并检索指向基类对象的指针？

UPD：代码与我的几乎相同：

class IRow : public QObject{
//...
};

class FirstRow : public IRow{
//...
};

class SecondRow : public IRow{
    FirstRow *_first
    Q_PROPERTY(FirstRow* first READ first WRITE setFirst)
public:
    FirstRow* first() const{
        return _first;
    }
    void first(FirstRow *first){
        _first = first;
    }
//...
};

在其他地方有一个函数对特定的接口实现一无所知IRow。她必须读取表单中出现的对象的所有可用属性QVariant（没有其他方法，可以使用模型），并将结果值转换为接口类型 ( IRow)。这里没有显示。在 Qt5 中它应该，但在 Qt4 中不是。如果您使用@ixSci 解决方案，那么该类SecondRow将如下所示：

class SecondRow : public IRow{
    FirstRow *_first
    Q_PROPERTY(FirstRow* first READ _first WRITE _setFirst)
public:
    FirstRow* first() const{
        return _first;
    }
    void first(FirstRow *first){
        _first = first;
    }
private:
    IRow* _first() const{
        return first();
    }
    void _setFirst(IRow *first){
        _setFirst(qobject_cast<FirstRow*>(first));
    }
//...
};

它有效，但是 setter 和 getter 的数量增加了一倍

yrHeTateJlb

Asked: 2020-11-16 18:52:08 +0800 CST

断言 CRTP

3

我正在使用CRTP。在代码中它看起来像这样：

template<class T>
class Base{
    //...
};
class Derived : public Base<Derived>{
    //...    
};

复制/粘贴错误开始出现：

class Foo : public Base<Foo>{
    //...    
};
class Bar : public Base<Foo>{   //Ой
    //...    
};

我决定写一个断言来检查这个案例。

想出了这个选项：

template<class T>
class Base{
protected:
    typedef T TemplateType;
    typedef Base<T> BaseType;
    //...
};
class Derived : public Base<Derived>{
public:
    Derived(){
        Q_ASSERT(typeid(*this) == typeid(Base::TemplateType));
    }
    //...    
};

但是他有点丑。在运行时工作，需要一些模糊的 typedef。

我在这里。如何使用 C++03 和 Qt 编写这样的断言？因此，同时也不羞于向人们展示。

yrHeTateJlb

Asked: 2020-08-04 16:12:55 +0800 CST

QRegexp 惰性量化

2

格式中有一个字符串x-y。我们需要一个正则表达式来捕获 x 和 y。我立即选择了这个选项：

QRegExp regexp("(.+)-(.+)");

但对于这种情况-100--500，它不能正常工作，捕获-100-和500.
例子

第一个想法是让第一个捕获的组“偷懒”

QRegExp regexp("(.+?)-(.+)");

理论上，一切正常（example），但实际上QRegExp它不支持惰性量化。所以你必须这样做

QRegExp regexp("(.+)-(.+)");
regexp.setMinimal(true);

但是现在我有两个组都“懒惰” (.+?)-(.+?)。当然没有任何作用。例子。
好吧，没关系，你可以指定第二组应该继续到行尾。

QRegExp regexp("(.+)-(.+)$");
regexp.setMinimal(true);

理论上，一切正常。例子。实际上，没有。QRegExp现在，出于某种原因，它不再“懒惰”并捕获-100-and 500。对于这样的正则表达式setMinimal，它根本没有任何作用。

#include <QCoreApplication>
#include <QRegExp>
#include <iostream>

int main(int argc, char *argv[]){
    QCoreApplication a(argc, argv);
    QString str("-100--500");
    QRegExp regexp("(.+)-(.*)$");

    regexp.setMinimal(true);
    regexp.indexIn(str);
    std::cout << "1)" << regexp.cap(1).toStdString() << std::endl; //-100-
    std::cout << "2)" << regexp.cap(2).toStdString() << std::endl; //500

    regexp.setMinimal(false);
    regexp.indexIn(str);
    std::cout << "1)" << regexp.cap(1).toStdString() << std::endl; //-100-
    std::cout << "2)" << regexp.cap(2).toStdString() << std::endl; //-500

    return a.exec();
}

实际上问题是，如何x-y使用从字符串中提取 x 和 y QRegExp？带有 boost、C++11、Qt 4.6.3+ 和 replacement 的选项。\d 不匹配。

初始化类字段的最佳方法。move vs const &

在空指针处调用方法

统一初始化

阻塞进程直到线程/子进程退出

函数参数的数量

Qt 4.8 文档显示错误

整个表达式的类型

使用 std::find_if 不用于搜索

将点插入多边形

使用新的（这个）

将父子对转换为路由

在 QVariant 中进行类型转换

断言 CRTP

QRegexp 惰性量化

我看不懂措辞

请求的模块“del”不提供名为“default”的导出

"!+tab" 在 HTML 的 vs 代码中不起作用

我正在尝试解决“猜词”的问题。Python

可以使用哪些命令将当前指针移动到指定的提交而不更改工作目录中的文件？

Python解析野莓

问题：“警告：检查最新版本的 pip 时出错。”

帮助编写一个用值填充变量的循环。解决这个问题

尽管依赖数组为空，但在渲染上调用了 2 次 useEffect

数据不通过 Telegram.WebApp.sendData 发送

yrHeTateJlb's questions