问题列表 - 第318038页

#include<stdio.h>\n#include<stdlib.h>\n\nint main(int argc, char** argv) {\n  char *str5=malloc(10);\n  *str5="xxxxx\\0";\n  printf("%s\\n",str5);\n  return 0;\n}\n

编译成以下程序集（使用“gcc source.c”）：

=> 0x555555555179 <main+4>:     sub    rsp,0x20\n   0x55555555517d <main+8>:     mov    DWORD PTR [rbp-0x14],edi\n   0x555555555180 <main+11>:    mov    QWORD PTR [rbp-0x20],rsi\n   0x555555555184 <main+15>:    mov    edi,0xa\n   0x555555555189 <main+20>:    call   0x555555555040 <malloc@plt>\n   0x55555555518e <main+25>:    mov    QWORD PTR [rbp-0x8],rax\n   0x555555555192 <main+29>:    lea    rax,[rip+0xe6b]        # 0x555555556004\n   0x555555555199 <main+36>:    mov    edx,eax\n   0x55555555519b <main+38>:    mov    rax,QWORD PTR [rbp-0x8]\n   0x55555555519f <main+42>:    mov    BYTE PTR [rax],dl\n   0x5555555551a1 <main+44>:    mov    rax,QWORD PTR [rbp-0x8]\n   0x5555555551a5 <main+48>:    mov    rdi,rax\n …

我有一个返回类似 的函数Result<Option<Value>, Error>，我想检查是否有一个值以及它是否与条件匹配。有两种简单的方法：

if let Ok(Some(value)) = func() {
    if /* condition */ {
        /* do something */
    }
}

和

if func().is_ok_and(|option| option.is_some_and(|value| /* condition */ )) {
    /* do something */
}

第一个对我来说似乎更具可读性，但在某些情况下，我可以想象会出现很多嵌套。第二种可读性较差，并且引入了极长的行，但可以防止过度嵌套。其中一个比另一个更可取吗？或者还有其他我不知道的更简单的方法吗？

通过执行以下操作，类似于此 github 问题中讨论的内容将非常有帮助：

if let Ok(Some(value)) = func() && /* condition */ {
    /* do something */
}

防止过度嵌套并保持可读性，但我发现目前 Rust 中不存在类似的功能。

我注意到Parallel::Loops模块用作$_其 subref 的参数。这个问题与Parallel::Loops本身无关，而是与 coderef 调用约定有关。

这是他们的示例，请注意$_传递给子：

$pl->foreach( \@parameters, sub {
    # This sub "magically" executed in parallel forked child
    # processes
 
    # Lets just create a simple example, but this could be a
    # massive calculation that will be parallelized, so that
    # $maxProcs different processes are calculating sqrt
    # simultaneously for different values of $_ on different CPUs
    # (Do see 'Performance' / 'Properties of the loop body' below)
 
    $returnValues{$_} = …

使用 C++ 命名空间，我可以将任何文件中的任何内容放在任何位置，并且在编译时它们将“合并”到单个命名空间中。因此，这个文件结构：

/* src/main.cpp */\nint main() {\n    nsfoo::foo();\n}\n/******/\n\n/* src/foo/function.cpp */\nnamespace foo {\n    void foo(nsfoothing thing) {}\n}\n/******/\n\n/* src/foo/structures.cpp */\nnamespace foo {\n    struct nsfoothing {};\n\n    void nsfooprocessthing(nsfoothing thing) {}\n}\n/******/\n

相当于有一个包含以下内容的文件：

/* src/main.cpp */\nnamespace nsfoo {\n    struct nsfoothing {};\n    void foo(nsfoothing thing) {}\n    void nsfooprocessthing(nsfoothing thing) {}\n}\n\nint main() {\n    nsfoo::foo();\n}\n/******/\n

或这个文件结构：

/* src/main.cpp */\nint main() {\n    nsfoo:foo();\n}\n/******/\n\n/* src/foo/foo.cpp */\nnamespace nsfoo {\n    struct nsfoothing {};\n    void foo(nsfoothing thing);\n    void processnsfoothing(nsfoothing thing);\n}\n/******/\n

或这个文件：

/* tmp/quickndirtytesting.cpp */\nnamespace foo …

我注意到，当我编写以下代码时，编译器会生成missing return statement error：

// Similar loops make sense in retry patterns
// but this is just a simple example
func TestMethod() int {
    for i := 0; i < 10; i++ {
        return 0
    }
}

这是在编译时没有任何错误的情况下：

func TestMethod() int {
    for {
        return 0
    }
}

第一个代码在逻辑上和技术上都很好，因为该方法不可能无法返回。编译器显示该错误有什么原因吗？或者这是某种缺失的逻辑或错误？

大多数时候，powershell 中的错误报告非常有用。我看到错误，看到起源，但我注意到 ForEach-Object 管道中的任何错误都会丢失其起源行，并且错误堆栈仅指向带有ForEach-Object.

错误位置示例

Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

[cultureinfo]::CurrentUICulture = 'en-US'

function Test-Something($val)
{
    # var is not defined here
    Write-Host($undefined_variable)
}

@("a","b") | ForEach-Object{
    $entry = $_

    Test-Something $entry
}

结果是

ForEach-Object : The variable '$undefined_variable' cannot be retrieved because it has not been set.
In D:\dummy.ps1:12 Line:14
+ @("a","b") | ForEach-Object{
+              ~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (undefined_variable:String) [ForEach-Object], RuntimeException
    + FullyQualifiedErrorId : VariableIsUndefined,Microsoft.PowerShell.Commands.ForEachObjectCommand

该线12指向@("a","b") | ForEach-Object{，这显然不是错误位置。

foreach 的更有用的示例 …

我有一个由地图渲染的列表组件，这就是我在反应函数组件中定义数据的方式：

const [projMap, setProjMap] = useState<Map<number, FolderModel>>(new Map<number, FolderModel>());

当我在反应功能组件中设置地图时，如下所示：

React.useEffect(() => {
    if (folderProjList && folderProjList.length > 0) {
        if (currFolder) {
            let cachedExpand = projMap.get(currFolder.id)?.expand;
            let folderModel: FolderModel = {
                expand: cachedExpand ? cachedExpand : true,
                projects: folderProjList
            };
            projMap.set(currFolder.id, folderModel);
            setProjMap(projMap);
        }
    }
}, [folderProjList]);

使用 projMap 渲染 UI 时未触发重新渲染。然后我像这样改变样式：

React.useEffect(() => {
        if (folderProjList && folderProjList.length > 0) {
            if (currFolder) {
                setProjMap((prevMapState) => {
                    const newMapState = new Map<number, FolderModel>(prevMapState);
                    let cachedExpand = newMapState.get(currFolder.id)?.expand;
                    let …

因此，我正在制作一款数独游戏，其中每个方格都会指向其行、列和 3x3“区域”中的所有其他方格。在sudoku构造函数中，我连接了相关的方块。行和列连接不会给我任何意外的结果 \xe2\x80\x93 有 1296 个连接需要建立，当该部分完成时，打印显示count正好 1296。太棒了！

现在，当我对 3x3 区域执行相同操作时，我遇到了问题。当使用 时option 2，count结束于 324，当打印板时我得到了想要的结果。然而，当将函数的结果存储get_node在临时变量 ( option1) 中时，我得到 648，并且每个方块的连接计数是正确的（16 而不是 20）。情况不应该是这样，因为该get_node函数所做的只是return _board[(I * dim) + J]. 有谁知道这样的问题可能来自哪里？

提前致谢！

PS 是的，我暂时禁用了编译器警告，因此goto语句将编译 \xe2\x80\x93 这不是问题，这只是为了让这里的人们更清楚地看到:)

// areas\nint count(0);\nfor (int a = 0; a < 3; ++a) {\n    for (int b = 0; b < 3; ++b) {\n        for (int i = 0; i < …

我正在 R 工作，如果可能的话，我更喜欢 dplyr 解决方案。

样本数据：

data.frame(
  col1 = c("a", "b", "c", "d"),
  col2 = c("a", "b", "d", "a"),
  col3 = rep("a", 4L),
  col4 = c("a", "b", "d", "a"),
  col5 = c("a", "a", "c", "d"),
  col6 = rep(c("b", "a"), each = 2L)
)

在 Visual Studio 中阅读标准库算法的实现时，他们根本不使用[[likely]]/属性。[[unlikely]]对我来说，应该使用的教科书示例[[unlikely]]是例如std::find_if(...)，微软已经这样实现：

// Note that some noise are removed from the code
template <class _InIt, class _Pr>
_InIt find_if(_InIt _First, const _InIt _Last, _Pr _Pred) {
    for (; _First != _Last; ++_First) {
        if (_Pred(*_First)) {
            break;
        }
    }
    return _First;
}

如前所述，find_if(...)这是 if 子句的 true 分支不太可能的教科书示例，因为大多数情况下它会在谓词验证为 true 之前迭代几个元素，因此 [[unlikely]] 将是一个优化机会。Microsoft 没有[[unlikely]]在这里使用该属性有什么原因吗？