全部问题(coding)

我想我知道这个问题的答案，但我希望能进行一次理智检查。

迭代器无效是否适用于 std::back_insert_iterators？

#include <cassert>
#include <iterator>
#include <vector>

int main() {
    auto v = std::vector<int>{ 0, 1, 2 };
    auto iter = std::back_inserter(v);
    *iter++ = 3;
    v.clear();    // invalidates iterators, but
    *iter++ = 4;  //  back_insert_iterator is special?
    assert(v.size() == 1 && v[0] == 4);
    return 0;
}

这段代码对我来说是可行的，因为我的供应商提供的 std::back_insert_iterator 实现不包含迭代器（或指针或引用）。它只是调用容器的 push_back 方法。

但是标准是否要求实现该功能？其他供应商的 back_insert_iterator 是否可以保存并维护一个尾端迭代器，以便与容器的 insert 方法调用一起使用？这似乎可以满足要求。当然，这种差异在于它容易失效。

我知道 cppreference.com 不是权威的，但是它比标准更容易访问。

[向量的 clear 方法] [i] 使引用所含元素的任何 ... 迭代器无效。任何超出末尾的迭代器也将失效。 [ cppreference.com，重点补充]

std::back_insert_iterator 可能是末尾迭代器的典型代表。

我正在使用 netcat 传输数据并将输出传输到 gawk。以下是 gawk 将接收的示例字节序列：

=AAAA;=BBBB;;CCCC==DDDD;

数据几乎包含任意字符，但绝不会包含 NULL 字符，其中=和;保留为分隔符。在写入任意字符块时，每个块将始终以其中一个分隔符作为前缀，并始终以其中一个分隔符作为后缀，但可以随时使用任一分隔符：=并不总是前缀，也不;总是后缀。它永远不会在没有写入适当的前缀和后缀的情况下写入块。在解析数据时，我需要区分使用了哪个分隔符，以便我的下游代码可以正确解释该信息。

由于这是一个网络流，因此在读取此序列后，stdin 保持打开状态，因为它在等待未来的数据。我希望 gawk 读取直到遇到分隔符，然后使用找到的任何数据执行我的 gawk 脚本的主体，同时确保它正确处理连续的 stdin 流。我将在下面更详细地解释这一点。

迄今

这是我迄今为止尝试过的方法（zsh 脚本，使用 gawk，在 macOS 上）。对于这篇文章，我将主体简化为仅打印数据 - 我的完整 gawk 脚本的主体要复杂得多。我还将 netcat 流简化为cat一个文件（以及cat'ing stdin 以模仿流行为）。

cat example.txt - | gawk '
BEGIN {
    RS = "=|;";
}
{
    if ($0 != "") {
        print $0;
        fflush();
    }
}
'

example.txt

=AAAA;=BBBB;=CCCC;=DDDD;

我的尝试成功处理了大部分数据......直到最新的记录。它挂起等待来自 stdin 的更多数据，并且无法执行最新记录的脚本主体，尽管 stdin 中显然有适当的分隔符。

当前输出：（无法处理最新的记录DDDD）

AAAA
BBBB
CCCC
[hang here, waiting for future data]

期望输出：（成功处理所有记录，包括最近的记录）

AAAA
BBBB
CCCC
DDDD
[hang here, waiting for future data]

这个问题究竟可能是什么原因造成的？我该如何解决？我意识到这似乎是一种极端情况。非常感谢大家的帮助！

编辑：评论整合、其他澄清以及各种观察/认识

以下是我在调试过程中发现的一些杂项观察，包括我最初发布此帖子之前和之后。这些编辑还澄清了评论中出现的一些问题，并将分散在各个评论中的信息整合到一个地方。还包括我根据评论中极具洞察力的信息对 gawk 内部工作原理的一些认识。此编辑中的信息取代了评论中可能讨论的任何潜在冲突信息。

1. 我简单调查了一下这是否是操作系统强加的管道缓冲问题。在使用该stdbuf工具禁用所有管道缓冲后，似乎缓冲根本不是问题，至少不是传统意义上的问题（参见第 3 条）。

2. 我注意到，如果 stdin 已关闭并且RS 使用正则表达式，则不会出现问题。相反，如果 stdin 保持打开状态并且RS 不是正则表达式（即纯文本字符串），也不会出现问题。只有当 stdin 保持打开状态并且RS 是正则表达式时才会出现问题。因此，我们可以合理地假设它与正则表达式如何处理连续的 stdin 流有关。

3. 我注意到，如果我的带有正则表达式的 RS ( RS = "=|;";) 有 3 个字符长...并且 stdin 保持打开状态...它会在 stdin 中出现 3 个额外字符后停止挂起。如果我将正则表达式的长度调整为 5 个字符（RS = "(=|;)"），则从挂起返回所需的额外字符数量也会相应调整。结合与 Kaz 的极具洞察力的讨论，这确定挂起是正则表达式引擎本身的产物。就像 Kaz 所说的那样，当正则表达式引擎解析时RS = "=|;";，它最终会尝试从 stdin 读取其他字符以确保正则表达式匹配，尽管这种额外的读取对于所讨论的正则表达式而言并非绝对必要，这显然会导致在等待 stdin 时挂起。我还尝试向正则表达式添加惰性量词，这在理论上意味着正则表达式引擎可以立即返回，但遗憾的是它没有，因为这是正则表达式引擎的实现细节。

4. 此处和此处的gawk文档指出，当 RS 是单个字符时，它将被视为纯文本字符串，并导致 RS 匹配而不调用正则表达式引擎。相反，如果 RS 有 2 个或更多字符，它将被视为正则表达式，并将调用正则表达式引擎（随后引发第 3 项中讨论的问题）。但是，这似乎有点误导，这是 gawk 的实现细节。我尝试过RS = "xy";（并相应地调整了我的数据），并重新测试了第 3 项中的实验。没有发生挂起，并且打印了正确的输出，这一定意味着尽管 RS 是 2 个字符，但它仍然被视为纯文本字符串 - 正则表达式引擎从未被调用，并且挂起问题从未发生。因此，似乎对 RS 是被视为纯文本还是正则表达式进行了进一步的过滤。

5. 那么……既然我们已经找出了问题的根本原因……我们该怎么做呢？一个显而易见的想法是避免使用正则表达式引擎……但我的脚本仍然需要使用某种 OR 子句来匹配分隔符……因此，这似乎需要编写一个自定义数据解析器作为 C 程序或其他程序。虽然我可以这样做，而且它肯定会解决问题，但考虑到手头的任务，我宁愿不走这条杂草丛生的道路。

6. 这让我们想到了 Ed Morton 的解决方法，这很可能是最好的方法，或者可能是其一些衍生方法。下面总结了他的方法：

基本上，在将数据提供给主要 gawk 调用之前，使用其他 CLI 工具或 shell 读取循环，甚至多次调用 gawk，提前进行转换。就像 Ed 说的那样，将每个分隔符替换为全部以 NULL 字符为后缀。由于这是在 gawk 看到任何数据之前完成的，因此可以将 gawk 设置为使用 NULL 字符作为 RS，这将被视为纯文本字符串而不是正则表达式，这意味着正则表达式挂起问题永远不会发生。从那里，真正的分隔符和数据块可以以您想要的任何方式进行解码和处理。

gawk 本身甚至能够进行提前转换……只要可以使用纯文本 RS 而不是正则表达式 RS 找到每个相关分隔符。请小心包含正则表达式专用字符的分隔符，因为这可能会导致 gawk 在您不期望的情况下将其视为正则表达式。

虽然我现在已经将 Ed 的答案标记为解决方案，但我认为我最终的解决方案将是 Ed 的方法、Kaz 的洞察力以及我后来对他们的一些认识的结合。希望我能将两个答案标记为解决方案！谢谢大家的帮助，特别是 Ed Morton 和 Kaz！

在 R 中，假设我有一个如下向量：

vector<-c("Red", "   ", "", "5", "")

我想计算这个向量中有多少个元素只是空字符串，这些空字符串仅由空格或根本没有空格组成。对于这个非常短的向量，只有三个。第二、第三和第五个元素只是空格或根本没有空格。它们没有任何字符，如字母、数字、符号等。

是否有任何函数或方法可以计算这个？我想要一些可以在更大的向量上使用的东西，而不是仅仅查看向量的每个元素。

当我向对数图添加网格线时，它似乎会自动添加所有可能的网格线，而我只想包含主线。我尝试关闭次要刻度，但没有效果。

例如：

loglog([0.000001,0.1],[0.000001,0.1])
grid on
gca.YAxis.MinorTick = 'off'

我怎样才能在标记的轴刻度处显示网格线？

我有一个 C 头文件（.h）：

typedef uint8_t paraFunction(uint8_t paraVal, uint8_t paraNum);
paraFunction *paraCallTable[256];

我有一个 C 源文件 (.c)：

paraFunction *paraCallTable[] = {   fn1, fn2, ... fn255, fn256 };

但是，数组最终位于数据部分。我希望它位于代码/闪存中，因为函数地址（数组数据）是常量。该数组由其他源文件中的函数使用。

我该如何重写这些声明以使其全部不变？它们需要放在哪里（.c 还是 .h）？

我在 Google 上搜索并尝试了无数种不同的方法，但显然我还是不明白。

我正在尝试使用 Python (CPython 3.10.13) 进行元编程，并注意到一些奇怪的行为object.__new__（至少对我来说很奇怪）。看看以下实验（不是实际代码，只是一个实验）和评论。请注意，object.__new__似乎根据第一个参数改变了它的行为：

# Empty class inherit __new__ and __init__ from object
class Empty:
    pass

# Confirmation of inheritance
assert Empty.__new__ is object.__new__, "Different __new__"
assert Empty.__init__ is object.__init__, "Different __init__"

empty_obj = Empty()
uinit_empty_obj = object.__new__(Empty)

assert type(empty_obj) is type(uinit_empty_obj), "Different types"

try:
    object.__new__(Empty, 10, 'hi', hello='bye')
except TypeError as e:
    # repr(e) mentioned the Empty class
    print(repr(e))

# Overwrite the object __new__ and __init__ methods
# __new__ and __init__ with the same signature
class Person:
    def __new__(cls, name, age):
        """Does nothing bassicaly. Just overwrite `object.__new__`."""
        print(f'Inside {cls.__name__}.__new__')
        return super().__new__(cls)
    
    def __init__(self, name, age):
        print(f'Inside {type(self).__name__}.__init__')
        self.name = name
        self.age = age

a_person = Person('John Doe', 25)
uinit_person = Person.__new__(Person, 'Michael', 40)

try:
    # Seems an obvious error since object() doesn't take any arguments
    another_uinit_person = object.__new__(Person, 'Ryan', 25)
except TypeError as e:
    # Indeed raises TypeError, but now there isn't a mention of the Person class in repr(e)
    print('`another_uinit_person` :', repr(e))

# Now, some weird things happen (well, weird for me).
# Inherit __new__ from object and overwrite __init__.
# __new__ and __init__ with unmatching signatures.
# A basic Python class. Works just fine like suppose to.
class Vehicle:
    def __init__(self, model):
        self.model = model

# Confirmation of __new__ inheritance.
assert Vehicle.__new__ is object.__new__, "Nop, it isn't"

a_vehicle = Vehicle('Honda')

# I would understand if CPython autogenerated a __new__ method matching __init__
# or a __new__ method that accepts all arguments.
# The following try-except-else suggests the last, but the assert statement above 
# indicates that Vehicle.__new__ is actually object.__new__.
try:
    # Doesn't raise any exceptions
    uinit_vehicle = Vehicle.__new__(Vehicle, 'Honda', 10, ('four-wheels',), hello='bye')
except Exception as e:
    print(repr(e))
else:
    print('`uinit_vehicle` : constructed just fine', uinit_vehicle)

# Now the following runs just fine
try:
    # Doesn't raise any exceptions
    another_unit_vehicle = object.__new__(Vehicle, 'Toyota')
    another_unit_vehicle = object.__new__(Vehicle, 'Toyota', 100, four_wheels=True)
except Exception as e:
    print(repr(e))
else:
    print('`another_unit_vehicle` : constructed just fine:', another_unit_vehicle)

我得到了以下输出：

TypeError('Empty() takes no arguments')
Inside Person.__new__
Inside Person.__init__
Inside Person.__new__
`another_uinit_person` : TypeError('object.__new__() takes exactly one argument (the type to instantiate)')
`uinit_vehicle` : constructed just fine <__main__.Vehicle object at 0x00000244D15A7A90>
`another_unit_vehicle` : constructed just fine: <__main__.Vehicle object at 0x00000244D15A7A30>

我的问题：

1. 为什么第一个TypeError提到了Empty课程而第二个只是提到了object.__new__？
2. 为什么object.__new__(Person, 'Ryan', 25)提高了TypeError，object.__new__(Vehicle, 'Toyota')而object.__new__(Vehicle, 'Toyota', 100, four_wheels=True)没提高呢？

基本上：object.__new__引擎盖下面有什么？

在我看来，它正在对第一个参数__new__和/或__init__覆盖方法（如果有）执行有点奇怪的检查。

username我正在尝试根据子字典中的存在来过滤以下数据。

最佳解决方案是，当我不必提及每一个键时，例如agtsvcaccount, sqlsvcaccount, sapwd，因为这在其他模式中应该是通用的。

这是带有变量的示例输入input_parameters，此输出来自 Ansible 调试任务。

ok: [localhost] => {
    "msg": {
        "ansible": {
            "limit": [
                "vm1234.vmdomain.com",
                "vm5678.vmdomain.com"
            ]
        },
        "mssql": {
            "edition": "standard",
            "language": "en",
            "setupconfig": {
                "action": "Install",
                "agtsvcaccount": {
                    "type": "System User",
                    "username": "SQL_Agt",
                    "vault": "credvault",
                    "visibility": false
                },
                "agtsvcstartuptype": "Automatic",
                "features": [
                    "SQLENGINE"
                ],
                "forcereboot": false,
                "instancename": "MSSQLINSTANCE",
                "npenabled": true,
                "sapwd": {
                    "type": "Database",
                    "username": "sa",
                    "vault": "credvault",
                    "visibility": false
                },
                "securitymode": "SQL",
                "sqlcollation": "SQL_Latin1_General_CP1_CI_AS",
                "sqlsvcaccount": {
                    "type": "System User",
                    "username": "SQL_Svc",
                    "vault": "credvault",
                    "visibility": false
                },
                "sqlsvcstartuptype": "Automatic",
                "sqlsysadminaccounts": [
                    "Administrator"
                ],
                "tcpenabled": true
            },
            "version": "2022"
        }
    }
}

现在，我正在使用类似的东西，它不够通用/动态，而且我不想将其用于account_identifiers非常相似的其他原理图。

- name: 'Process credentials'
  ansible.builtin.include_role:
    name: 'mycollection.generic'
    tasks_from: 'user/{{ item.value.vault }}.yml'
  loop: '{{ input_parameters.mssql.setupconfig | dict2items }}'
  when: 'item.key in account_identifiers'
  vars:
    account_identifiers: ['sapwd','sqlsvcaccount','agtsvcaccount','ftsvcaccount','rssvcaccount','assvcaccount','issvcaccount']

有什么想法可以实现这一点吗？
我尝试从 Ansible 文档中获取想法，但我认为我遗漏了一些东西。

在 C++20 中，当我std::ranges::views::take()在 a 上使用时，迭代 take 视图之后std::ranges::istream_view()的下一个标记将被跳过。istream_view

考虑以下 C++20 代码片段：

#include <iostream>
#include <ranges>
#include <sstream>
#include <vector>
#include <algorithm>

namespace rn = std::ranges;

int main() {
    std::string input = "1 2 3 4 5 6 7 8 9 10";
    std::istringstream input_stream(input);

    std::vector<int> head;
    rn::copy(rn::istream_view<int>(input_stream) | rn::views::take(5),
             std::back_inserter(head));

    int next_int = 0;
    input_stream >> next_int;

    for(auto x : head) std::cout << x << " ";
    std::cout << next_int << std::endl;
}

当我在 g++14 或 clang++17 中编译并运行此代码时，会产生以下输出（注意缺少“6”）：

1 2 3 4 5 7

Godbolt 链接：https://godbolt.org/z/vdGvx9666

为什么会发生这种情况？这是预期的行为吗？可以做些什么来解决这个问题？

我创建了以下熊猫数据框

import pandas as pd
import numpy as np

ds = {
      'col1' : 
          [
              ['U', 'U', 'U', 'U', 'U', 1, 0, 0, 0, 'U','U', None],
              [6, 5, 4, 3, 2],
              [0, 0, 0, 'U', 'U'],
              [0, 1, 'U', 'U', 'U'],
              [0, 'U', 'U', 'U', None]
              ]
      }

df = pd.DataFrame(data=ds)

数据框如下所示：

print(df)
                                      col1
0  [U, U, U, U, U, 1, 0, 0, 0, U, U, None]
1                          [6, 5, 4, 3, 2]
2                          [0, 0, 0, U, U]
3                          [0, 1, U, U, U]
4                       [0, U, U, U, None]

对于中的每一行col1，我需要检查U列表中每个等于的元素是否后面（从左到右）跟着除和之外的任何值U：None在这种情况下，我将创建一个新列（称为iCount），其值为 1。否则为 0。

在上面的例子中，生成的数据框看起来如下：

                                      col1 iCount
0  [U, U, U, U, U, 1, 0, 0, 0, U, U, None]      1
1                          [6, 5, 4, 3, 2]      0
2                          [0, 0, 0, U, U]      0
3                          [0, 1, U, U, U]      0
4                       [0, U, U, U, None]      0

只有在第一行中，值后面U跟着一个既不是也不U是的值None（它是1）

我已经尝试过这个代码：

col5 = np.array(df['col1'])

for i in range(len(df)):
    iCount = 0

    for j in range(len(col5[i])-1):
        
        print(col5[i][j])
        
        if((col5[i][j] == "U") & ((col5[i][j+1] != None) & (col5[i][j+1] != "U"))):
            
            iCount += 1
            
        else:
            iCount = iCount
    

但是我得到了这个（错误的）数据框：

                                      col1  iCount
0  [U, U, U, U, U, 1, 0, 0, 0, U, U, None]       0
1                          [6, 5, 4, 3, 2]       0
2                          [0, 0, 0, U, U]       0
3                          [0, 1, U, U, U]       0
4                       [0, U, U, U, None]       0

有人能帮帮我吗？

我正在学习 SOLID 原则。在学习“依赖倒置原则”时发现类应该依赖于接口而不是具体类。

这是否意味着不允许组合？另外，聚合是否与 DIP 相同？

作品：

    class HPDesktop {
        private BluetoothMouse bluetoothMouse;
        private BluetoothKeyboard bluetoothKeyboard;
    
        public HPDesktop(){
            bluetoothMouse = new BluetoothMouse();
            bluetoothKeyboard = new BluetoothKeyboard();
        } 
     }

DIP：（这似乎是一种聚合）

class HPDesktop {
    private Mouse mouse;
    private Keyboard keyboard;

    public HPDesktop(Mouse mouse, Keyboard keyboard){
        this.mouse = mouse;
        this.keyboard = keyboard;
    }
}