指向同一内存的两个 s 的比较begin()和迭代器是否定义明确？end()std::span

#include <span>
#include <cassert>

int main() {
    int arr[5]{1,2,3,4,5};
    std::span s1{arr};
    std::span s2{arr};
    assert(s1.begin() == s2.begin());
    assert(s1.end() == s2.end());
    assert(s1.begin() + s1.size() == s2.end());
}

到目前为止，所有断言都传递了所有实现std::span，但是我是否遗漏了什么，从而导致出现错误，例如 UB？

就上下文而言，如果您有一个试图用跨度隐藏其内部的类，则可能会出现这种情况。

class some_class
{
public:
  std::span<int> vec_view() { return vec; }
private:
  std::vector<int> vec;
};

int main() {
    some_class c;
    std::for_each(c.vec_view().begin(), c.vec_view().end(), [](auto&){});
}

这与当一个跨度是另一个跨度的子跨度时，C++ 是否允许在 std::span::iterators 之间进行比较？有关，但这个问题与 无关std::subspan，而且该std::span版本还通过了 MSVC 断言，与 的版本不同std::subspan。

我有一个 lambda 操作，std::array它在 lambda 内部初始化，有时重新初始化：

std::array<int, 10> nums; // indeterminate values
auto reinitNums{true};

const auto lambda{
    [&] (auto&&... args) {
        // always initialized before first use
        if (reinitNums) {
            // ...
            reinitNums = false;
        }

        // use nums

        if (condition) {
            regenerateNums = true;
        }
    }
};

// call the lambda a number of times

数组和reinitNums不在 lambda 之外使用，因此将它们移动到 init 捕获中可能是可取的：

const auto lambda{
    [
        nums = std::array<int, 10>{}, // filled with zeros
        reinitNums = true
    ] (auto&&... args) mutable {
        if (reinitNums) {
            // rewrite the zeros
            reinitNums = false;
        }

        // as before
    }    
};

问题是这会触发值初始化：

nums = std::array<int, 10>{}

带括号的版本也是如此：

nums = std::array<int, 10>()

不具备上述任何一项的版本nums = std::array<int, 10>无法编译。

是否有可能进行默认初始化的 init 捕获？

摘自K&R第99页：

“我们更喜欢后者，因为它更明确地表明该变量是一个指针。”

我需要澄清一下为什么“更明确地说明变量是指针”会有什么重要性？我预计原因是为了让程序更快而不是更明确，如第 97 页所述：

“指针版本通常会更快，但至少对于初学者来说，会更难理解”

但在这种情况下，为什么指针版本会更快？ 如果arr[i]只是相当于为什么*(a+i)程序会更快？ 是因为 C 不需要将数组转换为指针版本吗？

考虑：

typedef union 
{
    int intval;
    const int const_intval;
}myUnion_t;

int main(void)
{
    myUnion_t x = {0};

    x.intval = 5;

    printf("intval = %d\n", x.intval);
    printf("const_intval = %d\n", x.const_intval);
}

1. UB 本身的定义是否myUnion_t与此处相同？
2. 有intvalUB 的作业吗？

经过测试的所有编译器均未发出警告（使用 C++ 编译器编译时也如此）

编辑

重复仅与问题有关2，与主要问题无关。

我想删除多个向量中的所有重复项，不留下任何重复项。例如，对于这些向量：

a <- c("dog", "fish", "cow")
b <- c("dog", "horse", "mouse")
c <- c("cat", "sheep", "mouse")

预期结果是：

a <- c("fish", "cow")
b <- c("horse")
c <- c("cat", "sheep")

有没有办法实现这一点，而无需连接向量并再次拆分它们？

替换函数（例如names<-）在像 那样调用时似乎不使用惰性求值names(x) <- c("a", "b")。

为了演示，让我们定义一个函数来获取数字的小数部分和相应的替换函数 - 但在替换函数内部，包含一行来打印解除约束的value参数。

fractional <- function(x) { 
  x %% 1 
}

`fractional<-` <- function(x, value) {
  print(rlang::enexpr(value))
  invisible(x %/% 1 + value)
}

现在如果我们fractional<-直接调用，它会打印我们给出的表达式value：

x <- 10.1
`fractional<-`(x, 0.2 + 0.2)
#> 0.2 + 0.2

但是如果我们以赋值形式调用它，它会打印表达式的求值结果：

x <- 10.1
fractional(x) <- 0.2 + 0.2
#> [1] 0.4

语言定义解释了替换函数，例如：

names(x) <- c("a","b")

相当于

`*tmp*` <- x
x <- "names<-"(`*tmp*`, value=c("a","b"))
rm(`*tmp*`)

但这并不能重现这种行为：

x <- 10.1

`*tmp*` <- x
x <- "fractional<-"(`*tmp*`, value=0.2 + 0.2)
rm(`*tmp*`)

#> 0.2 + 0.2

其中内部发生了什么事情<-使得它在value评估后被传递，有什么方法可以规避这种行为？fractional<-

编辑： @SamR 指出使用substitute捕获了承诺中的表达式：

x <- 10.1
`fractional<-` <- function(x, value) {
  print(substitute(value))
  invisible(x %/% 1 + value)
}
fractional(x) <- 0.2 + 0.2

#> 0.2 + 0.2

因此，显然我错误地认为value在传递给之前对进行了评估fractional<-。但是，我仍然非常想知道为什么 base::substitute 在这里按预期工作，而 rlang::enexpr 和朋友却没有。毕竟，在内部enexpr使用substitute：

enexpr <- function(arg) {
  .Call(ffi_enexpr, substitute(arg), parent.frame())
}

在 R Studio 中进行调试表明，无论是以赋值形式调用fractional(x) <- 0.2 + 0.2还是以前缀形式调用时"fractional<-"(x, 0.2 + 0.2)，fractional<-都会传递一个未评估的承诺value：

当以前缀形式调用时，它仍未被计算：

但是在以赋值形式调用时，会在调用之后进行评估enexpr：

我想知道这是否与在赋值形式中该函数由原始函数调用有关<-？但不清楚为什么会有所不同。

我正在生成十六进制颜色代码。在 R3.6.2 中

paste(as.hexmode(c(213,94,0)))

生成

 "d5" "5e" "00"

而在R4.4.1中它会生成

 "d5" "5e" "0"

导致无效的十六进制代码（"#d55e0"）和损坏的代码

paste()现在似乎无法识别“hexmode”属性 - 相反，它将 as.hexmode() 的结果视为一个简单的整数。这种变化是可以预料的吗？

今天我在这里遇到了一个有点奇怪的语法 - where ()：
https ://github.com/binator/self/tree/80ba2ade?tab=readme-ov-file#example

fn hex_primary<Stream, Context>(stream: Stream) -> Parsed<u8, Stream, Context>
where
  (): IntRadixParse<Stream, Context, u8>,
{
  uint_radix(2, Radix::HEX).parse(stream)
}

在我看来，它看起来像是“绑定在单元类型（又名空元组）上”，但我无法理解。单元类型默认不会实现所有特征，对吗？不幸的是，官方文档太模糊，不够完整（同时过于冗长），我在其中找不到任何相关内容。

原始 RFC 的 forwhere子句也提到了这种语法，但没有适当的解释：
https://rust-lang.github.io/rfcs/0135-where.html#alternatives

fn increment<T>(c: T) -> T
    where () : Add<int,T,T>
{
    1 + c
}

但除此之外，我知道不仅可以在特征泛型中指定此类界限。
那么它是什么，何时使用，为什么需要它以及它解决了哪些问题？

考虑这个空程序：

int main()
{ return 0; }

如果我用 C++ 用 编译它g++ main.cpp && strace ./a.out，并用 分析输出strace，我观察到输出的最后几行是（你可以添加-O3效果是一样的）：

mprotect(0x7f71af154000, 45056, PROT_READ) = 0
mprotect(0x7f71af38b000, 4096, PROT_READ) = 0
brk(NULL)                               = 0xed2000
brk(0xf05000)                           = 0xf05000
exit_group(0)                           = ?
+++ exited with 0 +++

但是，如果我这样做：gcc main.cpp && strace ./a.out

mprotect(0x7f4114318000, 16384, PROT_READ) = 0
mprotect(0x7f4114547000, 4096, PROT_READ) = 0
exit_group(0)                           = ?
+++ exited with 0 +++

如您所见，在 C++ 中有一个额外的brk函数将堆扩展了 204KB（将两者均转换为十进制后，0xf05000 - 0xed2000 = 204KB）。可以通过将该程序替换为（coliru 链接）轻松验证这一点：

#include <iostream>
#include <unistd.h>

int main()
{
    char buf[1024];
    sprintf(buf, "pmap -XX %u", getpid());
    std::system(buf);
    
    return 0;
}

您可以轻松观察到，使用 进行编译的g++大小[heap]为 204KB，并且gcc行[heap]甚至从pmap输出中消失了。

注意：顺便说一下，令我惊讶的是，gcc 对于 include 和in<iostream>的存在完全没有问题。stdstd::system

这 204KB 是用来做什么的？我对这 204KB 一点也不担心，但它引起了我的注意，现在我很好奇。

考虑以下代码：

library(dplyr)
a = data.frame(a = 1:3)
abc = \(x) data.frame(x/2, x/3)
a %>% 
  mutate(abc(a))

返回

  a x.2       x.3
1 1 0.5 0.3333333
2 2 1.0 0.6666667
3 3 1.5 1.0000000

但我无法控制名称，因为我想为它们分配其他名称。

解决这个问题的一种方法是将返回类型abc命名为，但这并不理想，因为我可能想要abc在两组变量上运行

a %>% 
  mutate(abc(a), abc(b))

另一种方法当然是rename在每次运行后都进行，abc但这可能会不稳定。

有没有办法给输出命名abc？例如

a %>% 
  mutate(c("a1","a2") := abc(a), c("b1","b2") := abc(b))

但上述:=语法不起作用。