小编luc*_*0ni的帖子

假设我有一个如下定义的整数数组:

static constexpr int IntArray[] = {1, 5, 10, 12, 17};

有没有办法在编译时获得最小值或最大值？

问题只是出于教育目的:

在两个对象(例如两个线程)之间使用30-50或更多对信号和插槽是否会影响应用程序性能,运行时或响应时间？

实际上我正在尝试对嵌入C++对象的QML组件进行一些测试.不幸的是,当我执行测试时,我遇到了一些错误.QML文件无法识别C++对象.这也很有意义,因为在main.cpp文件中设置了C++对象.

我的问题是:我如何模拟上下文属性来执行QML测试？或者其他人说,我怎样才能用混合Qt/QML代码进行单元测试？

有没有办法得到关于函数声明和它的定义之间的参数名称不匹配的警告？

宣言

double divide(int a, int b);

定义

double divide(int b, int a)
{
    return a / b;
}

对于使用该函数的用户,divide将期望a/b作为结果而不是b/a.

我知道,编译器不能这样做,但有一些静态分析工具可以做到吗？如果是的话,哪些？

前言

鉴于我有不同类型的N个参数(uint,int和float),并且每个参数都有自己的有效值范围(即从2.5到20.0).还给出了一些参数来自其他参数.对于那些参数,我使用不同的函数(f1,f2,f3,...).

为了能够计算派生参数的有效值范围(最小值和最大值),我为每个派生参数定义了两个新函数f_min和f_max.在这些函数中,我使用min和max参数值的正确组合调用f来获取派生参数的限制边界.

我们举一个简单的例子:

f(a, b) = a / b
min = f(a_min, b_max)
max = f(a_max, b_min)

如何解决它

首先,我将所有最小和最大参数值存储到两个容器中.然后我定义一个deriveLimit模板函数,它作为模板参数获取指向函数的指针,该函数用于派生限制以及它依赖的参数索引列表.作为函数参数,deriveLimit模板函数获取最小和最大参数值的两个列表.

template <ParamIndex ...Indexes, typename ParamType, typename ...Args>
static ParamData deriveLimitUtil(const ParamData minParams[], const ParamData maxParams[],
                                 ParamValue<ParamType> (*function)(ParamValue<Args>...))
{
    ParamValue<ParamType> result = function(ParamValue<Args>(minParams[Indexes])..., ParamValue<Args>(maxParams[Indexes])...);
    return result.getData();
}

template <typename FuncType, FuncType function, ParamIndex ...Indexes>
static ParamData deriveLimit(const ParamData minParams[], const ParamData maxParams[])
{
    return deriveLimitUtil<Indexes...>(minParams, maxParams, function);
}

例如,为了得出参数2的上限,我打电话deriveLimit如下:

deriveLimit<typeof(&DeriveTest::deriveMaxLimit2), &DeriveTest::deriveMaxLimit2, ParamIndex::PARAM_2_INT, ParamIndex::PARAM_3_FLOAT_1>(minParams, maxParams);

其中deriveMaxLimit2声明如下: …

我试图在运行时通过按下按钮来添加新的小部件（在下面的示例中我使用标签）。这里是例子：

import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

class Widget(QWidget):

    def __init__(self, parent= None):
        super(Widget, self).__init__()

        btn_new = QPushButton("Append new label")
        self.connect(btn_new, SIGNAL('clicked()'), self.add_new_label)

        #Container Widget       
        self.widget = QWidget()
        #Layout of Container Widget
        layout = QVBoxLayout(self)
        for _ in range(20):
            label = QLabel("test")
            layout.addWidget(label)
        self.widget.setLayout(layout)

        #Scroll Area Properties
        scroll = QScrollArea()
        scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        scroll.setWidgetResizable(False)
        scroll.setWidget(self.widget)

        #Scroll Area Layer add
        vLayout = QVBoxLayout(self)
        vLayout.addWidget(btn_new)
        vLayout.addWidget(scroll)
        self.setLayout(vLayout)

    def add_new_label(self):
        label = QLabel("new")
        self.widget.layout().addWidget(label)


if __name__ == '__main__':
    app = …

有没有办法指示 VS Code 使用虚拟环境进行非 python 操作？目标是在打开新终端或使用调试工具时能够使用nodeenv？

nodeenv是一个工具，允许创建安装节点生态系统的隔离环境。

使用 nodeenv 时，npm 或其他-g已安装的 CLI 仅在激活环境后才可用。那么有没有办法配置 VSCode 来告诉它要使用哪个 PATH、要激活哪个 virtualenv 或 CLI 工具在哪里？

请注意，这个想法是在 virtualenv 中使用通过nodeenvpython.pythonPath安装的非 python 工具，因此VSCode 配置不起作用。

除了生成代码的大小之外,使用reset()初始化函数的共享指针有什么区别make_shared()？

案例1使用reset()

boost::shared_ptr<A> pA;
pA.reset(new A());

案例2使用make_shared()

boost::shared_ptr<A> pA;
pA = boost::make_shared<A>();

一般来说,使用resetover make_shared来减少可执行文件的大小是一个好习惯吗？

我在某处找到了这段代码：

boost::shared_ptr<const Foo> pFoo = boost::make_shared<const Foo>();

这里关键字的目的是什么const？

基本上,下面的脚本可以以三种不同的方式使用:call foo

1. .bat boot_up "path"
2. .bat halt "path"
3. .bat ssh "path" "command"

我不能保证路径或命令没有空格.

当我使用foo.bat执行我的子程序时ssh,一切正常.相反,当我尝试调用我的子程序时,boot_up或者halt出现错误:

( was unexpected at this time.

但是,如果我向boot_upor 添加第三个参数halt,那么一切都会再次起作用.

所以我的问题是,如何使用变量长度的参数来管理批处理文件的调用？

:main
    echo Argument 1: (%1)
    echo Argument 2: (%2)
    echo Argument 3: (%3)

    call :set_cygwin_env || exit /b 1

    if not "%1"=="" if not %2=="" (
        if "%1"=="boot_up" (
            call :boot_up %2
        ) else if "%1"=="halt" (
            call :halt %2
        ) else if "%1"=="ssh" if not %3=="" …

在我的应用程序中，我必须用自定义的 QLineEdit 替换所有 QLineEdit 元素。为此，有不同的解决方案：

1. 修改从 pyuic4 生成的 py 文件，并将所有 QLineEdit 对象替换为我的一个 LineEdit。这个解决方案并不是最好的，因为每次运行 pyuic4 时，我都会丢失对生成的输出文件所做的修改。
2. 编写一个新类，在我的窗口或对话框中递归搜索 QLineEdit 小部件类型，并将其替换为我的一个 LineEdit。这个解决方案要好得多。它允许我对其他对象执行相同的操作或根据需要扩展它，而无需关心对话框或窗口。

到目前为止，我可以编写一个模块（WidgetReplacer），它递归地搜索 QGridLayout 项目并搜索是否有 QLineEdit 子项。如果是的话，那就换成我的吧。

问题是，当我尝试访问我的 LineEdit 对象之一时，出现以下错误：

RuntimeError: wrapped C/C++ object of type QLineEdit has been deleted

如果我查看输出，我会注意到修改后的 QLineEdit 对象具有旧的 id：

old qt_obj <PyQt4.QtGui.QLineEdit object at 0x0543C930>
Replaced txt_line_1 with LineEdit
new qt_obj <LineEdit.LineEdit object at 0x0545B4B0>
----------------------------------
...
----------------------------------
<PyQt4.QtGui.QLineEdit object at 0x0543C930>

问题

为什么会出现这种情况呢？如何在运行时替换 QWidgets？

更新

这里有一些关于对象包装的其他细节：在模块 WidgetReplace 中，如果我转储 QEditLine 和 LineEdit 对象，我会得到：

<PyQt4.QtGui.QLineEdit object at 0x05378618>
    Reference …

我需要定义一个具有由模板类组成的元组的结构.

用法:

TestStruct<A, float, float, int32_t> test_a = { std::make_tuple(A(1.0), A(2.0), A(3)) };
TestStruct<B, float, float, int32_t> test_b = { std::make_tuple(B(1.0), B(2.0), B(3)) };

目前我的实现看起来像:

template<typename ClassBase, typename... ParamType>
struct TestStruct
{
    std::tuple<typename ClassBase<ParamType>...>  m_testValues;
};

通过编译我得到以下错误:

error: ‘ClassBase’ is not a class template
     std::tuple<class ClassBase<ParamType>...>  m_testValues;
                      ^

我如何定义我的结构？

是否可以使用lambda函数为模板类函数创建别名？像这样的东西:

#include <iostream>
using namespace std;

int calcDouble(int a) { return a * 2; }
int calcMultiply_10(int a) { return a * 10; }

struct foo
{
    template<void (*func)(int)>
    int generic(int value)
    {
        return func(value);
    }

    static auto double_10 = [this] { generic<calcDouble>(10); };
    static auto double_20 = [this] { generic<calcDouble>(20); };
    static auto multiply_10_20 = [this] { generic<calcMultiply_10>(20); };
}


int main() {
    foo f;

    cout << "double_10: " <<f.double_10() << endl;
    cout << "double_20: " <<f.double_20() << endl; …