小编pau*_*l23的帖子

在查看我的代码时,我看到我使用的一些"丑陋"结构,在一个类(称为"map")中我有一个包含"data"类的向量:

std::vector<PointerToHUGEClass> vector;

其中PointerToHUGEClass就像名称所描述的那样.(尽管指向的对象也由map类拥有,并且在构造函数中使用"new"参数创建).这一切都很好(目前).但是我仍然觉得这更像是一种解决方法.

我使用"PointerToHUGEClass"而不仅仅是"HUGEClass" 的唯一原因是因为我想确保不从堆栈声明对象.然而,在我理解分配器之前,这是做的.现在我觉得分配器的任务或多或少是为了确保不从堆栈声明内存.

我的问题:

• 假设分配器负责物品的内存管理,我是否正确？(并确保从堆栈/ freestore/heap /中声明它)
• std :: allocator做什么？ - 它是从堆栈还是从堆声明的？
• (从上一个问题开始跟进):如果我将堆栈中声明的项目复制到数据结构中,它是否仍在堆中声明？

再次感谢,paul23

好吧，我正在考虑一个有几个孩子的基类的情况。我有一个函数，该函数接受基类对象的列表，并返回包含这些对象的新列表。

现在，如果我显然要使用子类，则返回的是这些子类对象的列表：考虑以下简单情况：

from typing import Sequence, List, TypeVar


class BaseClass:
    def __init__(self, data=None, *args, **kwargs):
        super().__init__()
        self.CanCalculate = True
        if data is None:
            data = []
            self.CanCalculate = False
        self._mydata = list(data)
        self.multiplier = 1

    @property
    def data(self):
        return self._mydata


class ChildClass(BaseClass):
    def sum_mul_data(self):
        return self.multiplier * sum(self.data)


class SecondChildClass(BaseClass):
    def sum_div_data(self):
        return sum(self.data) / self.multiplier


def myFun(input: Sequence[BaseClass]) -> List[BaseClass]:
    out = []
    for n, i in enumerate(input):
        if i.CanCalculate:
            i.multiplier = 10**n
            out.append(i)
    return out


childs = [ChildClass([1,2,3,4]), …

好吧,我在执行以下操作时遇到链接器(未解析的外部符号)错误:

- 我有一个"对象"类 - 它在"object.h"中定义.

它有一个构造函数,如: explicit Object(double x, /* lots more */);

在文件"object.cpp"中我想给该构造函数一个体: Object::object(double x) : _x(x) {}

这工作..但是如果我在"object.cpp"文件中添加关键字"inline":

inline Object::Object(double x) : _x(x) {}

突然出现链接器错误!"错误LNK2019:未解析的外部符号"

为什么？ - 这是否意味着我不能使用内联构造函数？

编辑:实际上我注意到所有方法的情况.但是,如果我将所有方法移动到object.h头文件,它就可以工作了.您不能从定义对象的头文件外部内联函数？

EDIT2:好的更新,我决定构建一个快速测试用例:
main.cpp:

#include "a.h"
int main ()
{
    a t;
    t.test(5);
    return 0;
}

啊

class a {
public:
    void test (int x);
};

a.cpp

#include <iostream>
#include "a.h"
inline void a::test(int x) {
    std::cout << x << std::endl;
}

这会出现以下错误:

main.obj:错误LNK2019:函数_main中引用的未解析的外部符号"public:void __thiscall a …

是否有可能（更重要的是 -how-）将输出流重定向到 QTextBox。这样，如果我std::cout << "test"在应用程序中的任何位置写入，它都会被重定向到我定义的文本框？

我尝试了显而易见的（其中 ui.textEdit 是指向文本编辑框的指针）：

std::cout.rdbuf(ui.textEdit);
std::cout << "test";

然而这行不通。（明显地）。- 将 cout 重定向到 qDebug 也不起作用（甚至将 qDebug 定向到文本字段）。

我正在使用 qt4.8 顺便说一句...

编辑：所以我尝试了邮件列表中发布的解决方案。但是现在出现了访问冲突。

class MainInterface : public QMainWindow
{
    Q_OBJECT
....
private: 
    QDebugStream qout

使用构造函数：

MainInterface::MainInterface(QWidget *parent, Qt::WFlags flags)
    : QMainWindow(parent, flags),
    qout(std::cout, ui.textEdit)
{

在成员函数中，发布了以下行： std::cout << "Project Loaded" << std::endl;

该行现在会导致来自“qscoped_pointer”的访问冲突。（我应该将更多细节作为单独的问题发布吗？）

编辑：嗯，“解决方案”是在 ui.textEdit 完全创建后才声明 qout 。

假设我有一个商店，其中有一个组织列表，用户可以“选择”组织，然后将其存储在“filter”数组中。

export class OrganizationStore extends ArrayStore {
    //organizations = new Map();

    constructor( ...args) {
        super(args);
        this.organizations = new Map();
        this.filter = [];
        this.getter_url = '/organization/get-organizations';
    }

    async getData() {
        const full_url = new URL(this.getter_url);
        const options = {};
        options.method = 'GET';
        options.credentials = process.env.NODE_ENV === 'production' ? 'same-origin' : 'include';

        const response = await fetch(full_url, options);
        if (response.ok) {
            const d = await response.json();
            this.buildStore(d);
        }

    }

    buildStore(values) {
        this.organizations.clear();
        for (const {id, name} of values) {
            this.organizations.set(id, new Organization(id, …

在 pynput 上，我通过执行类似的操作来捕获一个键（例如空格键）：

from pynput import keyboard
from pynput.keyboard import Key

def on_press(key, ctrl):
    if key == Key.space:
        print('captured')


def main():
    with keyboard.Listener(on_press=on_press) as listener:
        listener.join()

但是我注意到这仍然将原始密钥代码发送到其他应用程序。我希望使用 python 将键（组合）“绑定”到其他键（或更高级的操作），因此需要防止这种情况。

如何才能做到这一点？或者这超出了操作系统允许 python 执行的范围？

在之前的 React 版本中，我们可以在状态更改后执行代码，方法如下：

setState( prevState => {myval: !prevState.myval}, () => {
    console.log("myval is changed now");
)

并确保第二个“位”仅使用更新后的代码执行。现在，其中一个示例描述了可以使用以下方法实现“类似”的效果React.useEffect：

const [myval, setMyval] = React.useState(false);
React.useEffect(() => {
    console.log("myval is changed now");
}

//somewhere
setMyval(o => !o);

虽然这看起来不错，但对我来说没有帮助：在我的情况下，“需要发生什么效果”取决于状态发生变化的位置，最初：

//somewhere
setState( prevState => {myval: !prevState.myval}, () => {
    console.log("myval is changed now");
)
//somewhere else 
setState( prevState => {myval: !prevState.myval}, () => {
    console.log("myval has changed somewhere else");
)

将它们更改为useState+setMyval将使相同的效果在两个位置触发，因此我们无法在 useEffect 中得出实际需要发生的操作。

在基于钩子的函数组件中我将如何执行上述操作？

更好的用例是一个有两个按钮的屏幕，一个用于加载上一个按钮，另一个用于加载下一个按钮。当状态为 true 时，按钮被禁用isLoading，并且仅在加载时执行操作。为了确保只发生单个负载，我们不能只是“行动”就好像状态立即改变一样：状态改变是异步的，因此可能会发生竞争条件。 …

好吧，虽然这并不理想（还），但我们目前正在通过 Synology 运行构建脚本。构建的一部分当然是安装所有软件包。但是，此时会发生很多错误。

我们安装使用：

npm ci --only=production（虽然与 相同的结果npm install）。并出现以下错误：

npm WARN tar zlib: invalid distance too far back

（像很多很多次一样）在某处跟随：

291 verbose stack ZlibError: zlib: invalid distance too far back
291 verbose stack     at Unzip.write (/usr/local/lib/node_modules/npm/node_modules/minizlib/index.js:147:22)
291 verbose stack     at Unpack.write (/usr/local/lib/node_modules/npm/node_modules/tar/lib/parse.js:313:19)
291 verbose stack     at PassThrough.ondata (_stream_readable.js:727:22)
291 verbose stack     at PassThrough.emit (events.js:210:5)
291 verbose stack     at addChunk (_stream_readable.js:309:12)
291 verbose stack     at readableAddChunk (_stream_readable.js:290:11)
291 verbose stack     at PassThrough.Readable.push (_stream_readable.js:224:10)
291 verbose stack     at PassThrough.Transform.push (_stream_transform.js:150:32) …

在 React 中，有一种简单的方法可以在多层组件中共享“信息”。这是通过使用上下文

import {UserCtx} from "./stores/UserCtx"; 
<UserCtx.Provider value={new user(info)}>
    <SomeComponent />
</UserCtx.Provider/>

然后在某个组件中：

import {UserCtx} from "./stores/UserCtx";
function SomeComponent() {
    const userData = React.useContext(UserCtx);
    return <div>JSON.stringify(userData)</div>
}

然而，这要求上下文对象定义对于所有对象都是可见的。因此，当创建组件库时，它不能真正被使用吗？

假设上面的“示例”SomeComponent是一个库组件，我如何将主应用程序的上下文共享给该组件？通过添加属性来共享似乎有些牵强，在这一点上我不妨直接提供用户（或上下文存储的任何内容）？

为了避免出现 XY 问题：目标是在 Synology dsm 上创建虚拟环境，因此不需要 apt-get，其中 pip 是手动安装的。

我正在尝试在上述环境中创建一个虚拟环境（手动安装 pip 的 Synology dsm package python 3.8）。

但这会产生以下错误：

$ python3 -m venv new_venv
Error: Command '['/volume1/docker/builder/new_venv/bin/python3', '-Im', 'ensurepip', '--upgrade', '--default-pip']' returned non-zero exit status 1.

在发现该错误的过程中，我发现它venv工作得“很好”：

$ python3 -m venv --without-pip new_venv 

按预期工作。pip 本身也按预期工作。但是我必须手动安装 pip。这也导致 Synology dsm 版本的 python 没有该模块ensurepip..

# python3 -c "import ensurepip; print(ensurepip.__file__);"
Traceback (most recent call last):
  File "<string>", line 1, in <module>
ModuleNotFoundError: No module named 'ensurepip'

这就产生了问题：如何手动安装ensurepip …