全部问题(coding)

给定以下函数

void foo(float* result, int size, float y, float delta) {
    for (int t = 0; t < size; ++t) {
        result[t] = y + delta * t;
    }
}

Clang-O2 生成以下 x86-64 程序集：

.LCPI0_0:
        .long   0
        .long   1
        .long   2
        .long   3
.LCPI0_1:
        .long   4
        .long   4
        .long   4
        .long   4
.LCPI0_2:
        .long   65535
        .long   65535
        .long   65535
        .long   65535
.LCPI0_3:
        .long   1258291200
        .long   1258291200
        .long   1258291200
        .long   1258291200
.LCPI0_4:
        .long   1392508928
        .long   1392508928
        .long   1392508928
        .long   1392508928
.LCPI0_5:
        .long   0x53000080
        .long   0x53000080
        .long   0x53000080
        .long   0x53000080
.LCPI0_6:
        .long   8
        .long   8
        .long   8
        .long   8
foo(float*, int, float, float):
        test    esi, esi
        jle     .LBB0_7
        mov     eax, esi
        cmp     esi, 7
        ja      .LBB0_3
        xor     ecx, ecx
        jmp     .LBB0_6
.LBB0_3:
        mov     ecx, eax
        and     ecx, 2147483640
        movaps  xmm2, xmm1
        shufps  xmm2, xmm1, 0
        movaps  xmm3, xmm0
        shufps  xmm3, xmm0, 0
        mov     edx, eax
        shr     edx, 3
        and     edx, 268435455
        shl     rdx, 5
        movdqa  xmm4, xmmword ptr [rip + .LCPI0_0]
        xor     esi, esi
        movdqa  xmm5, xmmword ptr [rip + .LCPI0_1]
        movdqa  xmm6, xmmword ptr [rip + .LCPI0_2]
        movdqa  xmm7, xmmword ptr [rip + .LCPI0_3]
        movdqa  xmm8, xmmword ptr [rip + .LCPI0_4]
        movaps  xmm9, xmmword ptr [rip + .LCPI0_5]
        movdqa  xmm10, xmmword ptr [rip + .LCPI0_6]
.LBB0_4:
        movdqa  xmm11, xmm4
        paddd   xmm11, xmm5
        movdqa  xmm12, xmm4
        pand    xmm12, xmm6
        por     xmm12, xmm7
        movdqa  xmm13, xmm4
        psrld   xmm13, 16
        por     xmm13, xmm8
        subps   xmm13, xmm9
        addps   xmm13, xmm12
        movdqa  xmm12, xmm11
        pand    xmm12, xmm6
        por     xmm12, xmm7
        psrld   xmm11, 16
        por     xmm11, xmm8
        subps   xmm11, xmm9
        addps   xmm11, xmm12
        mulps   xmm13, xmm2
        addps   xmm13, xmm3
        mulps   xmm11, xmm2
        addps   xmm11, xmm3
        movups  xmmword ptr [rdi + rsi], xmm13
        movups  xmmword ptr [rdi + rsi + 16], xmm11
        paddd   xmm4, xmm10
        add     rsi, 32
        cmp     rdx, rsi
        jne     .LBB0_4
        cmp     ecx, eax
        je      .LBB0_7
.LBB0_6:
        xorps   xmm2, xmm2
        cvtsi2ss        xmm2, ecx
        mulss   xmm2, xmm1
        addss   xmm2, xmm0
        movss   dword ptr [rdi + 4*rcx], xmm2
        inc     rcx
        cmp     rax, rcx
        jne     .LBB0_6
.LBB0_7:
        ret

我试图了解这里发生了什么。这似乎.LBB0_4是一个循环，每次迭代都覆盖原始循环的 8 次迭代（有 2mulps条指令，每条指令覆盖 4float次并rsi增加 32）。最后的代码可能是为了解决size不能被 8 整除的情况。我遇到麻烦的是其余的代码。循环内的所有其他指令.LBB0_4和开头的常量在做什么？是否有工具或编译器参数可以帮助我理解 SIMD 矢量化的结果？也许可以使用 SIMD 内在函数将其转换回 C++？

如果我将代码改为这样

void foo(float* result, int size, float y, float delta) {
    for (int t = 0; t < size; ++t) {
        result[t] = y;
        y += delta;
    }
}

Clang 生成更少的汇编代码并一次循环 16 个值。

编辑：我刚刚意识到这个版本根本没有矢量化，因此更小而且可能更慢。

编写此代码的最快方法是什么？

高级问题：我想更新现有表，用随机生成的 32 字节、base64 编码的数据填充现有列。每行的随机数据应该不同。

暂时忽略 base64 编码要求，解决方案很简单，如以下示例代码所示：

DECLARE @table TABLE (
    id int,
    bin varbinary(max) null
)

-- put a few rows in the table
insert into @table (id) values (1)
insert into @table (id) values (2)
insert into @table (id) values (3)

-- perform the update
update @table
set bin =  CRYPT_GEN_RANDOM(32)

-- check result
select *
from @table

这按预期工作。CRYPT_GEN_RANDOM(32)为每个更新的行生成不同的值。现在尝试添加 base64 编码要求：

DECLARE @table TABLE (
    id int,
    txt nvarchar(max) null
)

-- put a few rows in the table
insert into @table (id) values (1)
insert into @table (id) values (2)
insert into @table (id) values (3)

-- perform the update
update @table
set txt =  (SELECT CRYPT_GEN_RANDOM(32) FOR XML PATH(''), BINARY BASE64)

-- check result
select *
from @table

这不起作用：它会在每一行中放置相同的值。我尝试将 base64 编码打包到 UDF 中，看看是否有帮助：

CREATE FUNCTION ConvertBytesToBase64
(
    @bytes varbinary(max)
)
RETURNS nvarchar(max)
AS
BEGIN
    DECLARE @result nvarchar(max)
    SET @result = (SELECT @bytes FOR XML PATH(''), BINARY BASE64)
    RETURN @result
END
GO

然后更新语句变成：

update @table
set txt = ConvertBytesToBase64(CRYPT_GEN_RANDOM(32))

但这仍然会在每一行产生相同的值。

我根本不明白的是，既然 SQL Server 会评估CRYPT_GEN_RANDOM(32)每一行（这似乎是合理的），为什么不评估ConvertBytesToBase64(CRYPT_GEN_RANDOM(32))每一行？我怎样才能让它评估每一行？（也许相关，在 SQL Server 2019+ 中是否有更好的方法进行 base64 编码？）

我在 javafx 中编写了一个类，其中有两个双向绑定的属性，并且正在测试一些边缘情况。我发现，如果您从无效侦听器内部更改其中一个属性的值，则会导致属性不同步。这是一个小例子：

static class A {
    IntegerProperty x = new SimpleIntegerProperty(this, "x", 0);
    IntegerProperty y = new SimpleIntegerProperty(this, "y", 0);
    A() {
        x.bindBidirectional(y);
    }
}

static void testA() {
    A a = new A();
    a.x.addListener( o -> { //InvalidationListener
        if (a.x.get() < 0) a.x.set(0);
    });
    // after y is set to a negative value, x and y hold different values
    // until either y is set to a value that's >= 0 or x is set to any value
    a.y.set(-2);
    System.out.println(a.x.get());
    System.out.println(a.y.get());
}

输出：

0
-2

我假设使用双向绑定时，更改一个属性总是会导致另一个属性更新。编写这样的无效侦听器似乎很少见（并且可能不明智），但我在这里是出于防御考虑。如果至少有一个这些属性被暴露，我不希望它有可能破坏我的类的任何不变量。我认为这里有三种可能的解释：

1. 双向绑定的约定并不是它们始终保持同步（要么它们保持相同的值，要么它们被标记为无效），而只是基于尽力而为。因此，类不变量不应基于这一事实。

2. 更改失效侦听器中的值会破坏双向绑定的前提条件，应避免这样做。否则它们始终保持同步。因此，您可以根据这一事实制定类不变量，因为要求客户端不应编写这样的失效侦听器是合理的。

3. 这是一个错误，无论如何它们实际上应该是同步的。我猜如果这是真的，那么你很容易产生无限循环的更改通知（比如向 y 添加一个始终将值设置为 < 0 的无效侦听器）。因此，由客户端来防止这种情况发生。

这些解释中是否有任何接近事实的解释，或者我是否遗漏了其他内容？另外，我很想知道是否存在其他类型的绑定操作可以考虑到这些情况。

我知道这std::is_constant_evaluated()对于确定 C++20 中的编译时评估很有用。

但是从 C++23 开始我们就有了if consteval。

但是没有提到弃用std::is_constant_evaluated()。

从 C++23 开始它有实际用途吗？

我正在阅读 上的文档std::expected::operator==，显然它对 SFINAE 不友好。它不是说“如果 [类型不可等价比较]，则不参与过载解析”，而是说“程序格式不正确 [在这种情况下]”。

确实如此：

#include <concepts>
#include <expected>

struct A {};

static_assert(!std::equality_comparable<std::expected<A, A>>);

此断言在 MSVC 和带有 libc++ 的 Clang 上失败，并在带有 MSVC STL 的 Clang 上导致硬错误。

但为什么它不适合 SFINAE 呢？

std::expected<T,U>无论如何都需要T并且U是完整的，所以似乎没有什么可以阻止对其的所有操作以实现 SFINAE 友好性。

当列表本身不改变地址时，lobstr::obj_addr 会出现奇怪的行为，这是由于其对列表进行矢量化所致

我刚刚开始学习 Wickham 的《高级 R》（第二版），并完成了 2.2.2 练习的第一个练习。我认为，鉴于：

a <- 1:10; b <- a; c <- b

它们都将具有与lobstr::obj_addr函数检索到的相同的内存地址。如果我们仅使用 a、b 或 c 作为输入，情况确实如此，但由于我很懒，想一次获得所有值，所以我这样做了：

list(a, b, c) |> lapply(obj_addr) # lapply or sapply 

然后，每次运行该函数时，我们都会在不同的名称中获得一组不同的值。如果我们x <- list(a, b, c)在调用函数之前通过lapply、 和进行设置，这种情况仍然会发生obj_addr(x[[1]]) == obj_addr(x[[2]]) == obj_addr(x[[3]]) == obj_addr(a)，因此这不是每次都创建新列表的问题。有人知道这是怎么回事吗？我理解，在某个点上，每次调用都会生成一个具有自己内存地址的新输出对象，但我不知道如何lapply干扰给定对象的常量函数，例如obj_addr。

先感谢您！

为什么在以下情况下throw e允许，但不允许？throw a

  void test() {
    try {
      System.out.println();
    } catch (Error | RuntimeException e) {
      var a = e;
      //throw a; unreported exception Throwable; must be caught or declared to be thrown
      throw e;
    }
  }

所有这些直观上都是有道理的，但从JLS 14.20

多 catch 子句可以看作是一系列单 catch 子句。也就是说，异常参数类型表示为联合的 catch 子句等同D1|D2|...|Dn于一系列n 个catch 子句，其中异常参数的类型分别为类类型。在每个n 个D1, D2, ..., Dncatch 子句的 Block 中，异常参数的声明类型为。lub(D1, D2, ..., Dn)

因为lub(Error,RuntimeException)是Throwable，上面的代码应该等同于：

    try {
      System.out.println();
    } catch (Error e) {
      Throwable lub = e;
      throw lub;
    } catch (RuntimeException e) {
      Throwable lub = e;
      throw lub;
    }

（这显然不能编译）

此外， 的类型“当被视为未出现在赋值上下文中时”a是 的类型（ JLS 14.4.1），但如上所示，它与 的类型不同。ee

我是否忽略了什么？

编辑：这不是为什么在某些情况下重新抛出 Throwable 而不声明它是合法的？的重复，因为这个问题特定于多重捕获（这里没有讨论），并且由于对 JLS 中解决多重捕获的特定片段的误解而出现。这个问题提供的答案帮助我把这些点联系起来:)

我偶然发现了来自https://github.com/nothings/stb/的图像处理库，当我尝试使用 C++ 模块时，我尝试使用 stb_image.h“作为模块”。

为此，我编写了一个小型包装模块（与 glm 演示的技术相同， https://github.com/g-truc/glm，它将其库包装为 glm.cppm 内的 C++ 模块），它似乎运行良好：

module;

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

export module stb_image;

// this "seems" correct
export using ::stbi_uc;

// this should be correct
export stbi_uc *stbi_load(char const *filename,int *x,int *y,int *comp,int req_comp);
export void stbi_image_free(void *retval_from_stbi_load);

// is this the correct way to export enum values?
export using ::STBI_default;
export using ::STBI_grey;
export using ::STBI_rgb;
export using ::STBI_rgb_alpha;

我完全不确定如何处理 stb_image.h 中作为未命名枚举提供的这些 STBI 值：

enum
{
   STBI_default = 0, // only used for desired_channels

   STBI_grey       = 1,
   STBI_grey_alpha = 2,
   STBI_rgb        = 3,
   STBI_rgb_alpha  = 4
};

我进行了上述实验，至少 Visual C++ 2022“接受”了我的想法，并且代码可以正确执行，可以从导入此模块“stbi_image”的其他代码中使用这些值。

但是在互联网上搜索时我找不到任何关于“是否可以以及如何”将未命名枚举中的枚举值导出到 C++ 模块的描述。

我所做的是正确的吗？

我在 Excel 中有一系列值。

最上面一行是基数。第二行是该系列中每个数字有多少个值。第三行是该系列中该数字的总值。

请注意，在我的示例中，第三行中的数字相加为 42（完全是侥幸！）。

我想像这样扩展这些数字：

系列号是基数加上从 1 到第二行数字的序列。那么该值就是值的编号除以当前序列中的编号。

请注意，最后一行添加的内容与输入行相同。我将平均分配这些数字。

这里的真正应用是将每月完成的预算值按该月的天数展开，并按天分配数字。然后我打算按周分组。

我正在努力让最基本的扩展发挥作用：

=HSTACK(BYCOL(R8C3:R8C5,LAMBDA(n,SEQUENCE(n,1))))

我很乐意指出正确的方向。

我尝试创建一个不可复制且不可移动的类，其对象构造只能通过创建函数而不是公共构造函数来完成。create 函数将返回一个std::expected包含已创建对象或错误对象的对象。为了通过创建函数强制构造，我想将所有可用的构造函数设为私有。这种方法的主要目的是无例外地构造对象。

这是一个简单的例子：

class Foo
{
    int val_{};

public:
    Foo() = delete;
    Foo(const Foo&) = delete;
    Foo& operator=(const Foo&) = delete;

    static auto
    create(int val) noexcept -> std::expected<Foo, std::error_code>
    {
        if (val == 42)
            return std::unexpected<std::error_code>(std::in_place, EINVAL, std::generic_category() );

        return std::expected<Foo, std::error_code>{ std::in_place, val };
    }

private:

    friend class std::expected<Foo, std::error_code>;

    explicit Foo(int val) noexcept
    : val_{ val }
    {};

};

请注意，我做了std::expected<Foo, std::error_code>一个friend以便允许它调用私有构造函数。但我仍然收到编译器错误。这是编译器资源管理器中的代码。