maestro's questions

应用程序是用户在其 PC 上运行的常规可执行程序。它没有数据库，但是它确实有用户不能更改的数据。假设文件中有一个 JSON 对象，models程序在启动时读取该对象并在进一步的工作中使用它。由于 JSON 是原始文本，用户将能够打开此文件并更改其中的任何内容。目的是使得没有密码就无法执行此操作，但仍然允许程序读取和解释文件。文件的内容对于用户来说应该是难以理解的，但是如果他检查它并恢复存储在那里的原始文本，那就没问题了。

plain_text = 'plain text'
def encrypt_string(plain_text: str, password: str) -> str:
    """
    Принять новый текст для записи в файл и зашифровать его
    """
    ...

def decrypt_string(encrypted_text: str) -> str:
    """
    Расшифровать содержимое файла
    """
    ...

非对称加密是不言而喻的。文本用私钥加密，用公钥解密。两个密钥都存储在程序中，但私钥用密码加密。在尝试实现这样的事情时，我遇到了问题：

1. RSA算法的经典概念是使用公钥加密，使用私钥解密。这正是它在库中的实现方式cryptography，没有其他不同的方法。

2. 虽然从数学上来说可以交换公钥和私钥，但是却没有办法这样做。

3. 没有办法在没有密码的情况下序列化私钥，例如自己实现对称密码加密。

4. 私钥加密和公钥解密用于生成签名，但如果没有散列则无法创建签名。当执行逆向操作时，只需调用签名验证函数，该函数会将传递的字符串与加密的哈希值进行比较。

我对这个问题的看法正确吗？您能提出什么解决方案？

您需要为对数图的点着色，但就好像它们不是对数的一样。

z让图表上显示的某个值取值从a到b。我编译了 colormap - 一个函数，它根据传递给它的 0 到 1 范围内的数值来计算并返回颜色。让我们这样说：

table = [
    # x  R     G     B
    [0, 0.01, 0.043, 1],
    [0.2, 0.641, 0.164, 0.725],
    [0.3, 0.988, 0.051, 0.11],
    [0.5, 1, 0.975, 0.5],
    [0.8, 1, 1, 1],
    [1, 1, 1, 1]
]

为了计算每个特定点的颜色，我将其调整到所需的范围：

并绘制图表（以下为伪代码）：

plot(values=z, colormap=colormap) # значения x для цвета рассчитываются внутри построителя

所有点的颜色都正确：

现在我取该值的对数z并绘制图表：

plot(values=ln(z), colormap=colormap)

该图绘制正确，但我想让颜色与不使用对数时的颜色相同。

由于颜色是由构建器计算的，我只能更改颜色图。因此，我们需要以某种方式更改第一个颜色图列的值。

该值z'=ln(z)可以取从a'=ln(a)到 的值b'=ln(b)。我们得到：

接下来，我命令我的家养小精灵弄清楚如何x'用已知x和未知来表达z，，，但无论克利切如何努力a，b他都做不到。例如，如果将这两个方程相加，您将得到：

没有办法将z其删除。我的直觉告诉我有一个解决方案，但我没有看到。ab

其中一个分支switch-case包含对未标有 . 的不可返回函数（设备重启）的调用[[noreturn]]。它是一个图书馆（OSRV MAX）。这是一个代码片段：

ALARM_ACTION MyApp::OnAlarm(ALARM_REASON reason)
{
    switch (reason)
    {
    case AR_STACK_OVERFLOW:
        return AA_RESTART_TASK;
    case AR_NMI_RAISED:
    case AR_HARD_FAULT:
        System::McuReset();  //Фактически - noreturn, но не помечена атрибутом
        //?
    default:
        return Application::OnAlarm(reason);    
    }
}

实际上，该写什么来代替问题？如果你写break，那么会有一个警告“Not all code branches return a value”。如果你什么都不写，静态分析器会警告你掉落。当然，您可以在这里写一个属性[[fallthrough]]，但事实并非如此。那怎么对呢？

有一个张量保存在.npy我这样读的文件中：

x = np.load('x.npy')

任务是用它执行数学转换并将其保存到另一个文件中。

x = process(x)
np.save('x_processed.npy', x)

初始张量放在 RAM 中，process函数的返回值不是。

可以部分转换数据：将函数process应用于张量的切片x，但格式.npy不支持追加。

我试着这样申请numpy.memmap：

x = np.load('x.npy', mmap_mode='r+')

预期行为 - 张量不会加载到 RAM 中，而是会创建文件到 RAM 的映射。如果您稍后在 tensor 中编辑数据x，那么它们将在文件中进行编辑。

但是该函数的process构建方式是它返回新创建的张量，因此它在 RAM 中创建并完全吃掉它。

不过，有一些方法可以处理部分（切片）中的原始张量吗？

假设有两个通过函数处理切片获得的文件process，然后加载mmap：

x1 = np.load('x1.npy', mmap_mode='r')
x2 = np.load('x2.npy', mmap_mode='r')

以及要写入结果的文件：

x_targ = np.memmap(filename, dtype='float32', mode='w+', shape=full_tensor_shape)

那么是否可以这样做：

x_targ[0:x1.shape[0], :, :, :] = x1
x_targ[0:x2.shape[0], :, :, :] = x2

或者如何将它们合并到一个文件中？

有一个字符串表示为一对迭代器或一个指针char和一个长度。这条线的特殊之处在于它

• 可能包含一个数字，但只有一个；
• 可能包含错误值（额外字符或溢出的数字）；
• 可能什么都没有（begin+1 = end）。

我所知道的 C 和 C++ 标准库函数atoi,需要一个以 null 结尾std::stoi的sscanf字符串。C 和 C++ 库中是否有类似的标准函数？这些功能还需要：

• 该函数不得在堆上动态分配内存；
• 该函数不得使用 VLA；
• 该函数不得抛出异常。

虽然声明 IAR EWARM 8.40.1 支持 C++17，但它不std::string_view包含std::from_chars. 后者看起来是最合适的，尽管它没有写任何地方是否在堆上分配内存以满足内部需求。

有一个智能指针容器。您想通过所有权转移将它们写入另一个容器。但是当您尝试insertParameter在循环内调用函数时，调用远程构造函数时会发生错误。

void Module::insertParameter(unique_ptr<Parameter> p)
{
    some_list.append(move(p));
}
void Module::insertParameter(initializer_list<unique_ptr<Parameter>> plist)
{
    for (auto &p : plist)
    {
        insertParameter(move(p));
    }
}

实际上，如何组织智能指针在for循环范围内的移动？

我正在制作一个系统，用于注册来自硬件设备的回调并将它们翻译成 c++。c 文件中有一个松散耦合的库函数，当某些硬件事件发生时会调用该函数。我在我的文件中重新定义它，并将调用重定向到某个类的方法。

也就是说，有一个被调用的函数（Callable），以及该函数所属的类的一个对象（Object）。这两个实体必须以某种方式存储，以便以后可以调用它们。

使用std::function和类似类型的变体不适合，因为它们在堆上分配内存。这就是我所做的：

template<class Callable, class Object>
struct Callback {
    
    Callback(Callable f, Object o) :
        func(f),
        object(o)
        {}
    
    Callable func;
    Object object;
};

class CallbackRegistry {
public:
    template<class Callable, class Object>
    static void setCallback(Object object, Callable func)
    {
        Callback1<Callable, Object> = Callback<Callable, Object>(func, object);
    }
    
    //Здесь надо хранить объект this и функцию. Возможно, надо уйти от шаблонности.
    template<class Callable, class Object>
    static Callback<Callable, Object> Callback1; 
};


template<class Callable, class Object>
Callback<Callable, Object> CallbackRegistry::Callback1 = Callback<Callable, Object>(nullptr, nullptr);

//Эта функция вызывается аппаратно. В библиотечном файле она объявлена со слабым связыванием.
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    //Как определить эти типы? Если уходить от шаблонности переменной Callback1, то их здесь не будет
    std::invoke(CallbackRegistry::Callback1<?, ?>.func, 
                CallbackRegistry::Callback1<?, ?>.object /* this */);
}

CallbackRegistry::setCallback(someObject, comeMethodOfObject);

问题是，为了实现所需的行为，您需要以某种方式摆脱Callback1. 在某个地方单独存储类型？但是如何- 我还是不明白。

我不认为我会在这里询问未定义的引用，因为我不再认为自己是初级，但无论如何我必须这样做。我恳请您不要在这里重复一个众所周知的问题，我试图弄清楚并在这里带来尽可能多的信息。

让我们从我有一个特定的硬件平台的事实开始：NMC4。SDK 是从开发者的网站下载的，安装没有问题。编译时，出现链接器错误：

nmc-g++ main.o -mnmc4 -fexceptions "D:\lab\NMC\nmpp\lib\libnmpp-nmc4d.a" "D:\lab\NMC\hal\lib\libhal-mc12101.a" -o FixPoint / cygdrive/c/Program Files/Module/NMC-SDK/nmc4-ide/lib/gcc/nmc/4.8.3/../../../../nmc/lib/nmc4/libc.a(lib_a -timesr.o): 在函数 `__times_r': (.text.__times_r+0xd): 未定义的对 `__times' 的引用

该符号__times在库中定义libc.a。纳米输出：

         U __times_r
lib_a-systimes.o:
         U __times_r
00000000 T _times
lib_a-timesr.o:
         U __times
00000000 T __times_r

该库libc.a是由工具链自动连接的，但是在编译器设置中强制连接时，情况并没有改变。必须假设链接器看到了这个库：毕竟，它不会对这个库中的其余符号发誓。

该库libc.a仅存在于发布版本中。将项目配置从 Debug 更改为 Release 的尝试没有给出任何结果。

尝试在代码中定义符号 __times

int __times;

也没有给出任何结果。我是否正确理解没有访问修饰符，在 c 文件中声明的符号具有公共绑定？

技术支持仍然保持沉默。

/*
 * main.cpp
 *
 *  Created on: 9    . 2021  .
 *      Author: Alouette
 */

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

#define SIZE 64

//Вот эта строка, предложенная Fat-Zer, решает проблему, но использовать её - не лучшая идея
//extern "C" int _times(struct tms *buf) {   return -1; }

int main()
{
//Если закомментировать выделение памяти, то программа компилируется.
//Но запускать тогда нет смысла.
//Видимо, вызов __times спрятался где-то в недрах функции nmppsMalloc_8s.

    nm8s *vec1 = (nm8s*)nmppsMalloc_8s(SIZE);
    nm8s *vec2 = (nm8s*)nmppsMalloc_8s(SIZE);

    nm8s *result = (nm8s*)nmppsMalloc_8s(SIZE);

    nmppsRandUniform_8s(vec1, SIZE);
    nmppsRandUniform_8s(vec2, SIZE);

    nmppsAdd_8s(vec1, vec2, result, SIZE);

    for (int i = 0; i < SIZE; i++)
    {
        std::cout << nmppsGet_8s(vec1, i) << "+" << nmppsGet_8s(vec2, i) << "=" << nmppsGet_8s(result, i) << std::endl;

    }

    std::cout.flush();

    nmppsFree(vec1);
    nmppsFree(vec2);
    nmppsFree(result);

    return 0;
}

基类有一个指针QChart *m_chart。在派生类中，它必须具有QPolarChart派生自QChart. 基类和派生类都可以访问此字段。覆盖构造函数的正确方法是什么，以便m_chart使用 type 构造派生类中的字段QPolarChart，同时替换基类构造函数构造的值？

class PlotView : public QAbstractItemView
{
    Q_OBJECT
public:
    explicit PlotView(QWidget *parent = nullptr);
    ~PlotView();

protected:
    QChart *m_chart;
    QChartView m_chartView;
};

PlotView::PlotView(QWidget *parent) :
    QAbstractItemView(parent),
    m_chart(new QChart),
    m_chartView(m_chart)
{
}


class PolarPlotView : public PlotView
{
    Q_OBJECT
public:
    explicit PolarPlotView(QWidget *parent = nullptr);
};

PolarPlotView::PolarPlotView(QWidget *parent) :
    PlotView(parent),
    m_chart(new QPolarChart)//?
{
}

我正在为微控制器编写一个程序，并在其中使用该库来处理 Meschach 矩阵。该库未针对使用微控制器进行优化。特别是，有很多字符串文字要发送到标准输出。我不需要它，并且文字在可执行文件中占用了太多空间。它们可以被移除吗？在库的配置文件中，我没有找到允许您禁用标准输出的宏定义。

“删除”是指以下内容：

• 要么删除所有 printf 调用，以便文字变得未使用并且优化器将它们丢弃；
• 或将这样的线char *a = "aaaa";变成char *a = "";
• 应用一些可以删除所有行的编译器设置；

编译器：用于 ARM 7.50 的 IAR Embedded Workbench。

有什么选择？

FreeRTOS 只有mallocand free，没有callocand realloc。我需要它realloc并且我尝试自己实现它。这里一切都好吗？内存管理模块本身可以在这里找到。

void *pvPortRealloc(void *ptr, size_t s)
{
uint8_t *puc = ( uint8_t * ) ptr;
BlockLink_t *pxLink;
void *newBlock;
    if (ptr != NULL)
    {
        puc -= heapSTRUCT_SIZE;
        pxLink = (void*) puc;
        vTaskSuspendAll();
        {
            newBlock = pvPortMalloc(s);
            memcpy(newBlock, ptr, pxLink->xBlockSize);
            vPortFree(ptr);         
        }
        xTaskResumeAll();
        return newBlock;
    }
    return NULL;
}

这是 AnT 的评论后创建的新版本。

void *pvPortRealloc(void *ptr, size_t s)
{
uint8_t *puc = ( uint8_t * ) ptr;
BlockLink_t *pxLink;
void *newBlock;
extern void memcpy( void*, void*, size_t );
size_t blockSize;

    if (ptr == NULL)
    {
        newBlock = pvPortMalloc(s);
    }
    else
    {
        puc -= heapSTRUCT_SIZE;
        pxLink = (void*) puc;
        blockSize = pxLink->xBlockSize - heapSTRUCT_SIZE;
        if (s == 0)
        {
            newBlock = NULL;
        }
        else if (s > blockSize)
        {
            vTaskSuspendAll();
            {
                newBlock = pvPortMalloc(s);
                if (newBlock != NULL)
                {
                    memcpy(newBlock, ptr, blockSize);
                    vPortFree(ptr);         
                }
            }
            xTaskResumeAll();

        }
        else //s < blockSize
        {
            vTaskSuspendAll();
            {
                size_t newBlockSize = s + heapSTRUCT_SIZE + ( portBYTE_ALIGNMENT - ( s & portBYTE_ALIGNMENT_MASK ) );
                //if right segment is to few, do nothing
                if (pxLink->xBlockSize - newBlockSize > heapSTRUCT_SIZE)
                {
                    //split current block
                    pxLink->xBlockSize = newBlockSize;
                    BlockLink_t *blockToFree = (void*)((uint8_t*)pxLink + pxLink->xBlockSize);
                    blockToFree->xBlockSize = blockSize + heapSTRUCT_SIZE - pxLink->xBlockSize;
                    //free second part
                    prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) blockToFree ) );
                    xFreeBytesRemaining += blockToFree->xBlockSize;
                }
                newBlock = ptr;
            }
            xTaskResumeAll();           
        }
    }
    return newBlock;
}

我正在 SPI 主机上编写一个必须与从机交互的程序：发送和接收数据。发送没有问题，但在接收方面存在未解决的、文献中未涵盖的问题。

SPI主机发送一个字节：一个时钟信息信号。从机看到时钟信号并开始接收该字节。但是如果它有数据要传输，它能不能在同一个时钟信号下传输呢？控制器会接受它们吗？而如果此时slave没有在传输数据，controller会接受0xff吗？

现在情况不同了。从机已经准备好响应主机的请求发送数据，并等待时钟信号发送它。时钟信号将如何出现在线路上？高手应该发送0xff？毕竟，主机中没有寄存器可以在没有数据传输的情况下发出时钟信号，读取缓冲寄存器只会返回最后接收到的字节，不会发出时钟信号。

但是假设从机在主机的时钟信号下开始传输数据。此时他会接受 0xff 吗？

使用控制器 1982BE92U (Milander)。

已在对象上调用该方法QObject::moveToThread。因此，当信号到达时，相应的槽会在指定的线程中执行。有时添加信号只是为了调用适当的插槽是不合理的：它会使代码混乱。我发现这种方法可以在没有信号的情况下调用插槽：

QMetaObject::invokeMethod(obj, "slot1", Qt::QueuedConnection);

但在这里我不喜欢使用文本方法名称。我想在编译时检查方法是否存在。如何才能做到这一点？

更新。也许有一种方法可以QtConcurrent::run指定特定的线程？

我有这个数据框：

    X0  X1  X2  X3
0   3,7465759356    3,9929524521    3,7290598962    3,9416020757
1   2,9405285627    3,0125809054    2,9256071617    3,0370817644
2   2,3907682395    2,4959628959    2,4203315485    2,5123345286
3   2,667769289     2,8169243037    2,7067755525    2,819941095
4   3,5174069746    3,6947015318    3,6031473706    3,7293446909
5   3,4971753456    3,6318386869    3,6087157237    3,7127634955
6   3,2799369789    3,4026277202    3,3287014594    3,4729836704
7   2,4688361461    2,5931613428    2,5884721857    2,654343142
8   4,9480920436    5,2618326433    4,8367411213    5,200340321
9   2,5839918711    2,6564664314    2,6567353365    2,7084738201
10  3,0235179227    3,1846965709    3,1420435571    3,226176654
11  3,0255560454    3,1951865571    3,0625562893    3,2035708459
12  2,7435363038    2,903039071     2,8066417483    2,8831451723
13  3,0989225389    3,2759484764    3,1365404027    3,2829481328
14  2,8791101525    3,022431196     2,9171600354    3,0358254158
15  2,7738942062    2,9198893522    2,8638428564    2,9505456377
16  2,9773768478    3,1439135641    3,0404570931    3,1432559901
17  3,797767158     3,9607999032    3,8791070242    3,996404042
18  3,2645562122    3,4412127816    3,3172450423    3,4297893267
19  3,3094225229    3,466520235     3,3665861539    3,4687251807
20  3,2254435518    3,3669423406    3,277272531     3,364696979
21  2,8072222974    2,9509018409    2,8844643202    2,9489983818
22  2,7158702035    2,8557259219    2,7866183624    2,8580161063
23  3,8817612736    4,0851040662    3,9423929322    4,0888494407
24  3,728452702     3,8862195997    3,8077051346    3,855946951

如何统计每一行中满足条件的值的个数？例如，如果条件是大于三的数字，则结果为：

4
2
0
0
4
4
4
0
4
0 и т.д.

更新。结果DataFrame通过长计算接收。我认为没有理由在这里展示整个计算。对于那些提供帮助的人，我建议使用这个 DataFrame：

F = pd.DataFrame(np.random.randn(15, 4), columns=['X0', 'X1', 'X2', 'X3'])

如果一个应用程序使用进程之间共享的内存，它可以在这个内存中存储一​​个类对象吗？这个对象有什么要求？它可以有虚拟方法吗？如果这个对象开始动态分配内存会发生什么？

这是一个将对象放在共享内存中的示例，我认为其中应该没有陷阱。

QSharedMemory InteropMemory("name1");
QSystemSemaphore InteropSemaphore("name2", 1);
InteropSemaphore.acquire();
if (!InteropMemory.attach())
{
    bool created = InteropMemory.create(sizeof(InteropData));
    if (!created)
        qDebug() << InteropMemory.errorString();
    InteropMemory.lock();
    char *data = (char*)InteropMemory.data();
    InteropData *object = new InteropData();
    memcpy(data, object, sizeof(InteropData));
    delete object;
    InteropMemory.unlock();
}
InteropSemaphore.release();

class InteropData
{
public:
    InteropData();
    bool nextPointAllowed();

    int attach();

    void detach(int procNumber);

    void allow(int procNumber);

    void reset();
private:
    bool m_allowNextPoint[INTEROP_MAX_PROC_COUNT];
    bool m_procTerminated[INTEROP_MAX_PROC_COUNT];
    int m_count;
};

在代码中，此对象的使用方式如下：

InteropMemory.lock();
InteropData *object = (InteropData*)InteropMemory.data();
object->allow(1);
InteropMemory.unlock();

更新。还有一个问题，当共享内存被释放时，对象的析构函数不会被调用。可以自己调用吗？在这种情况下有必要吗？

在 DataFrame 中，每一行都是一个向量。如何计算每个向量的长度？

使用以下代码可以实现类似的行为：

import pandas as pd
import numpy as np
from scipy.spatial.distance import cdist
X = pd.DataFrame(...)
Zero = pd.DataFrame(0, index=np.arange(X.shape[0]), columns=X.columns)
L = cdist(X, Zero)

但我认为这可能更容易。该示例生成一个与 形状相同的空 DataFrame X，并计算两个 DataFrame 之间的欧几里德度量。

更新。示例初始数据集：

A       B       C
2       3       4 
2       1       2
5       4       2

结果示例：

sqrt(2^2+3^2+4^2)
sqrt(2^2+1^2+2^2)
sqrt(5^2+4^2+2^2)

有一个类派生自QObject.

class MyClass : public QObject
{
    Q_PROPERTY(int a READ...)
}

如果将此类的对象添加到列表中QList<QObject*>，则它们会在 QML 中拾取并显示在ListView. 如果你使用QList<MyClass*>，ListView结果是空的。但我想在 C++ 代码中使用 exactly QList<MyClass*>, but rather QList<QSharedPointer<MyClass>>, 否则你将不得不使用上游类型转换，这可能会导致错误。有哪些检查方法？

该程序从外部设备的闪存中读取一个数字（整数，1 字节，无符号）。对于其编程解释，使用枚举：

enum BoardType {
    Classic = 0,
    Static = 1,
    Smart = 2
}
BoardType t = (BoardType)getBoardType();

问题是肉眼可见的：内存中包含的数字不一定包含在枚举中。而且我认为在运行时没有办法检查返回的数字是否正确，但这将是强制性的，因为闪存在擦除状态下存储值 0xFF，而其他数字最终在那里因为我的歪手也可以到达那里。那么，有没有办法检查返回的数字是否包含在枚举中，如果没有，以编程方式解释这个数字的正确方法是什么？

原始表如下所示：

CREATE TABLE public.psi_humsensor (
  id           serial NOT NULL,
  sensorblock  integer NOT NULL,
  psi_act      integer NOT NULL,
  chamber_hum  real,
  sensor_hum   real,
  /* Keys */
  CONSTRAINT psi_humsensor_pkey
    PRIMARY KEY (id),
  /* Foreign keys */
  CONSTRAINT foreign_key01
    FOREIGN KEY (psi_act)
    REFERENCES public.psi_humsensor_acts(id)
    ON DELETE RESTRICT, 
  CONSTRAINT foreign_key02
    FOREIGN KEY (sensorblock)
    REFERENCES public.sensorblock(id)
) WITH (
    OIDS = FALSE
  );

该表填充了以下数据：

我正在尝试从此表生成报告。为此，您需要创建一个查询，返回室内传感器的湿度为 25%、被测传感器的湿度为 25%、室内传感器的湿度为 95%、湿度被测传感器的 95%。写了这个查询：

SELECT
      sb.serial_number
     ,t.label_number 
     ,round(CAST(psi1.chamber_hum as numeric), 2) AS ch25
     ,round(CAST(psi1.sensor_hum as numeric), 2) AS sh25
     ,abs(round(CAST((psi1.chamber_hum - psi1.sensor_hum) as numeric), 2)) as delta25
     ,round(CAST(psi2.chamber_hum as numeric), 2) AS ch95
     ,round(CAST(psi2.sensor_hum as numeric), 2) AS sh95
     ,abs(round(CAST((psi2.chamber_hum - psi2.sensor_hum) as numeric), 2)) as delta95
FROM psi_humsensor psi1
     JOIN psi_humsensor psi2 ON (psi1.psi_act = psi2.psi_act AND psi1.sensorblock = psi2.sensorblock)
     JOIN sensorblock sb ON (sb.id = psi1.sensorblock)
     JOIN termistors t ON (t.id = sb.termistor)
WHERE 
      psi1.id <> psi2.id 
  AND psi1.psi_act = 3

运行此查询会导致重复条目，例如：

1 | 1 | 25.2 | 25.3 | 0.1 | 95.3 | 95.5 | 0.2

2 | 2 | 95.3 | 95.5 | 0.2 | 25.2 | 25.3 | 0.1

如果添加到查询SELECT DISTINCT(psi1.chamber_hum + psi2.chamber_hum)中，则重复消失，但有时记录会混淆：表的左侧有 95% 的数据，右侧有 25% 的数据。如何提出这样的要求？

这是 .pro 文件的一部分，其中列出了要安装的文件。

install_it.path = $$OUT_PWD/../Deploy
install_it.files = sgip/sgip.json sgip/psi.tpl sgip/sgip_template.json \
    sgip_sokol_dll/usb_sgip_dll/release/usb_sgip_dll.dll \
    sgip/release/sgip.exe \
    $$PWD/sgip/3rdparty/postgres/bin/*

#

install_qtbin.path = $$OUT_PWD/../Deploy
install_qtbin.files = $$[QT_INSTALL_BINS]/icu* \
    $$[QT_INSTALL_BINS]/libgcc_s_dw2-1.dll \
    $$[QT_INSTALL_BINS]/libstdc++-6.dll \
    $$[QT_INSTALL_BINS]/libwinpthread-1.dll \
    $$[QT_INSTALL_BINS]/Qt5Concurrent.dll \
    $$[QT_INSTALL_BINS]/Qt5Core.dll \
    $$[QT_INSTALL_BINS]/Qt5Gui.dll \
    $$[QT_INSTALL_BINS]/Qt5PrintSupport.dll \
    $$[QT_INSTALL_BINS]/Qt5Widgets.dll \
    $$[QT_INSTALL_BINS]/Qt5Sql.dll

install_img.path = $$OUT_PWD/../Deploy/img
install_img.files = ../img/*

#

install_sqldrivers.path = $$OUT_PWD/../Deploy/sqldrivers
install_sqldrivers.files = $$[QT_INSTALL_PLUGINS]/sqldrivers/qsqlpsql.dll

INSTALLS += \
    install_it \
    install_img \
    install_qtbin \
    install_sqldrivers

有两个问题。首先，没有复制 libstdc++-6.dll 文件。文件存在但无法复制：复制实用程序返回“找不到文件”错误。如果我在命令行上运行相同的命令，我会得到同样的错误。如果您在命令行的文件名中指定 libstdc*，则文件会正常复制，但此技巧在 .pro 文件中不起作用，因为完整的文件名最终会出现在 Makefile 中。这怎么能解决？

第二。如果在 qmake 执行时某个文件不存在，那么这个文件将不会进入 Makefile。但是有些文件，例如sgip.exe 或usb_sgip_dll.dll，是在make 期间创建的，因此在运行qmake 时它们是否存在并不重要。无论如何，我如何让 qmake 将这些文件放入 makefile 中？

更新程序

发现 xcopy 实用程序正确地复制了这个文件。手动替换Makefile中的COPY、INSTALL_FILE等参数后，项目安装无误。但我希望 qmake 本身能够替代 Makefile 中的 xcopy 实用程序。