coding

Rust 中的结构体std::cell::Ref定义如下：

pub struct Ref<'b, T: ?Sized + 'b> {
    // NB: we use a pointer instead of `&'b T` to avoid `noalias` violations, because a
    // `Ref` argument doesn't hold immutability for its whole scope, only until it drops.
    // `NonNull` is also covariant over `T`, just like we would have with `&T`.
    value: NonNull<T>,
    borrow: BorrowRef<'b>,
}

评论// NB（我假设 Nota bene / Nasty Bug 或其他什么？）暗示以下定义不起作用，因为这会违反noalias（它们是否意味着后端的 LLVM 属性？）：

pub struct Ref2<'b, T: ?Sized + 'b> {
    value: &'b T,
    borrow: BorrowRef<'b>,
}

我不明白这一点，因为我的印象是非词汇生命周期语义在代码生成中得到了正确的保留。否则下面的简单示例（当然可以编译）也是非法的，对吗？：

struct Foo<'a> {
    v: &'a i32,
}
fn foo(x: &mut i32) {
    let f = Foo { v: x };
    *x = 5; // value modified while the `noalias` f.v pointer is still in scope
}

对内部结构有更多了解的人可以为我阐明这一点吗？我担心我在这里误解了一些关键的东西，导致我自己的不安全代码出现潜在问题。

我使用 C# 12。在 C# 12 中我可以使用主构造函数：

public class UserService(IUnitOfWork uow) : IUserService
{

}

在 C# 12 之前，我对构造函数中注入的项使用 null 检查：

public class UserService : IUserService
{
    private readonly IUnitOfWork _uow;

    public UserService(IUnitOfWork uow)
    {
        ArgumentNullException.ThrowIfNull(uow);
        _uow = uow;
    }
}

现在我如何在 C# 12 中进行 null 检查？
是否需要对主构造函数使用快速失败？

如何根据类模板参数值选择类模板成员函数的参数类型？

这是一个例子：

#include <memory>
template <class T, bool plainPointer=true>
class C
{
    // pseudocode below
    void f(plainPointer ? T * x : std::shared_ptr<T> x) { /*implementation*/ }
};  

也就是说，如果plainPointer==true，应该定义以下类成员函数：

void f(T * x) { /*implementation*/ }

否则，应定义该成员函数：

void f(std::shared_ptr<T> x) { /*implementation*/ }

我希望这两个函数都有一个实现，并且只有 的参数类型f应该是plainPointer依赖的。

这是 python 3.10 中列表理解的反汇编：

Python 3.10.12 (main, Jun 11 2023, 05:26:28) [GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import dis
>>> 
>>> dis.dis("[True for _ in ()]")
  1           0 LOAD_CONST               0 (<code object <listcomp> at 0x7fea68e0dc60, file "<dis>", line 1>)
              2 LOAD_CONST               1 ('<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_CONST               2 (())
              8 GET_ITER
             10 CALL_FUNCTION            1
             12 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x7fea68e0dc60, file "<dis>", line 1>:
  1           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                 4 (to 14)
              6 STORE_FAST               1 (_)
              8 LOAD_CONST               0 (True)
             10 LIST_APPEND              2
             12 JUMP_ABSOLUTE            2 (to 4)
        >>   14 RETURN_VALUE

据我了解，它创建了一个名为的代码对象listcomp，该对象执行实际迭代并返回结果列表，并立即调用它。我无法理解需要创建一个单独的函数来执行这项工作。这是一种优化技巧吗？

我正在尝试将std::chrono::duration对象格式化为 HH:MM::SS 格式，例如 16:42:02 是小时 (16)、分钟 (42) 和秒 (2)。

该库fmt为此提供了有用的格式说明符：

using namespace std::chrono;

auto start = high_resolution_clock::now();
auto end = start + 4s;
fmt::print("{:%H:%M:%S} \n", end);

不幸的是，它以小数形式打印秒

16:58:55.359425076 

我想将其四舍五入到最接近的整数，但无法弄清楚在哪里放置精度说明符（精度 2 仅在测试方面）：

fmt::print("{:.2%H:%M:%S} \n", end);  // error
fmt::print("{:.2f%H:%M:%S} \n", end);  // error 
fmt::print("{:%H:%M:.2%S} \n", end);  // nonsense: 17:07:.202.454873454 

我盯着chrono 格式规范的细节有点迷失......

上面的编译器资源管理器示例在这里。

library(ggplot2)
mydat <- data.frame(mean = c(23, 24, 15, 27, 18, 19, 23, 20, 32),
           lower = c(20, 19, 13, 15, 14, 18, 20, 17, 20),
           upper = c(25, 29, 17, 39, 22, 20, 26, 23, 40),
           class = c("A", "B", "C", "A", "B", "C", "A", "B", "C"),
           domain = c("North", "North", "North", "West", "West", "West", "South", "South", "South"))
mydat$class <- as.factor(mydat$class)
mydat$domain <- as.factor(mydat$domain)

mydat %>% ggplot(aes(x = mean, y = class, color = domain, Group = domain, xmin = lower, xmax = upper)) +
  geom_errorbar(width = 0.1, position = position_dodge(width = 0.5)) + theme_light() + geom_point(position = position_dodge(width = 0.5)) + xlab("Counts")

我想通过减小upper每个 s 内class和跨s 的误差条上限（即 ）的值来排序domain。期望的输出是这样的：

我尝试了以下代码，但没有达到预期的效果：

library(forcats)
mydat %>% ggplot(aes(x = mean, y = class, color = fct_infreq(domain), Group = fct_infreq(domain), xmin = lower, xmax = upper)) +
  geom_errorbar(width = 0.1, position = position_dodge(width = 0.5)) + theme_light() + geom_point(position = position_dodge(width = 0.5)) + xlab("Counts")

我正在学习conceptsC++ 20，并提出需要concept使用先前定义的concept.

因此，在下面的示例中，我预计f<pub_b>()会生成编译器错误，因为events_publishedinpub_b不满足publisher概念，因为ev_2不满足event概念。

看来在概念event中使用概念publisher并没有什么效果。

g++ version报告

g++ (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0
Copyright (C) 2021 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

我究竟做错了什么？

#include <concepts>
#include <tuple>

template <typename t>
concept event = requires {
  std::default_initializable<t>;
  std::copy_constructible<t>;
  std::move_constructible<t>;
};

struct ev_1 {
  ev_1() = default;
  ev_1(const ev_1 &) = default;
  ev_1(ev_1 &&) = default;
};

struct ev_2 {
  ev_2() = delete;
  ev_2(const ev_2 &) = default;
  ev_2(ev_2 &&) = default;
};

template <typename t>
concept publisher = requires {
  typename t::events_published;

  requires[]<std::size_t... t_idx>(std::index_sequence<t_idx...>) {
    return ((event<typename std::tuple_element_t<
                 t_idx, typename t::events_published>>)&&...);
  }
  (std::make_index_sequence<std::tuple_size_v<typename t::events_published>>());
};

struct pub_a {
  using events_published = std::tuple<ev_1>;
};

struct pub_b {
  using events_published = std::tuple<ev_2>;
};

template <publisher t_publisher> void f() {}

int main() {
  f<pub_a>();

  f<pub_b>();

  return 0;
}

给定两个任意大小的类型T和U，其中U: From<T>，标准库是否有理由不提供From<Option<T>> for Option<U>a where U: From<T>？我尝试这样做，但遇到了冲突的实现错误，所以显然存在限制，只是不确定在哪里。是的，我知道我可以用 a 来做到这一点Option::map()，但似乎 std 应该开箱即用。

enum Opt<T> {
    Some(T),
    None,
}

impl<T: From<U>, U> From<Opt<T>> for Opt<U> {
    fn from(opt: Opt<T>) -> Self {
        match opt {
            Opt::Some(t) => Opt::Some(t.into()),
            Opt::None => Opt::None,
        }
    }
}

struct A;
struct B;

impl From<A> for B {
    fn from(_: A) -> Self {
        B
    }
}

fn main() {
    let a = Opt::Some(A);
    let _b: Opt<B> = a.into();
}

错误

error[E0119]: conflicting implementations of trait `From<Opt<_>>` for type `Opt<_>`
 --> src/bin/main.rs:6:1
  |
6 | impl<T: From<U>, U> From<Opt<T>> for Opt<U> {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: conflicting implementation in crate `core`:
          - impl<T> From<T> for T;

在Thinking With Types练习11.2-i中，练习11.2-i将编写具有以下类型签名的函数。

weaken :: OpenSum f ts -> OpenSum f (x ': ts)

data OpenSum (f :: k -> Type) (ts :: [k]) where
  UnsafeOpenSum :: Int -> f t -> OpenSum f ts 

我认为练习之前的段落应该提供足够的上下文来了解这个函数的功能，但我不清楚。

在实践中，能够扩大开放总和的可能性也很有用。一个新功能，weak，将斧头类型固定在可能性列表的前面。

如果我有一些使用此函数的示例，这将对我完成此练习大有帮助。

以下代码片段在添加-pedantic和-Werror有点旧的编译器上生成编译错误。

#include <cstdint>
#include <iostream>

int add(int a, int b){
    return a + b;
}; // <-- stray semicolon

int main (){
    return 0;
}

然而，较新的编译器版本不会发生这种情况。请在https://godbolt.org/z/KWeb8WTxzgcc上找到(10.x, 11.x) 和(5.x, 6.x)的矩阵clang来演示差异。

我的问题有两个部分：

1. 为什么在最近的编译器中没有触发这个？
2. 是否可以在clang或的最新版本中启用旧行为gcc？

我需要你的帮助，我提供了下面的示例代码。我的问题涉及将“map2”放置在“map1”左上角的正方形中，并添加从“map2”到“map1”上特定位置的箭头。我搜索了该网站，但最常讨论的主题与合并两个数据层有关。

如果您能帮助我，我将不胜感激。

library (tidyverse)
 library (rnaturalearth)
 world <- rnaturalearth::ne_countries(scale = "medium", returnclass = "sf")
 
 map1<- ggplot(data = world) +
   geom_sf() +
   #annotation_scale(location = "bl", width_hint = 0.2) +
   #annotation_north_arrow(location = "tr", which_north = "true", 
   #                     pad_x = unit(0.83, "in"), pad_y = unit(0.02, "in"),
   #                   style = north_arrow_fancy_orienteering) +
   coord_sf(xlim = c(35, 48), ylim=c(12, 22))+
   xlab("Longtitude")+
   ylab("Latitude")
 
  

 map2<- ggplot(data = world) +
   geom_sf() +
   #annotation_scale(location = "bl", width_hint = 0.2) +
   #annotation_north_arrow(location = "tr", which_north = "true", 
   #                     pad_x = unit(0.83, "in"), pad_y = unit(0.02, "in"),
   #                   style = north_arrow_fancy_orienteering) +
   coord_sf(xlim = c(5, 45), ylim=c(5, 45))+
   xlab("Longtitude")+
   ylab("Latitude")

 map2 

我有一个 ggplot，其中使用了 geom_smooth(method='gam') 函数。我想知道是否有一种方法可以提取模型参数，例如解释的系数和偏差。

类似于 mgcv::gam() 输出的summary()：

> summary(gam)

Family: gaussian 
Link function: identity 

Formula:
mAODscale ~ s(numDate, bs = "cr")

Parametric coefficients:
            Estimate Std. Error t value Pr(>|t|)    
(Intercept) 0.041461   0.002198   18.86   <2e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Approximate significance of smooth terms:
             edf Ref.df     F p-value    
s(numDate) 8.731  8.979 74.54  <2e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

R-sq.(adj) =  0.379   Deviance explained = 38.4%
GCV = 0.0053239  Scale est. = 0.0052765  n = 1092

数据

test <- structure(list(numDate = c(1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 
5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 
11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 
16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 20, 20, 20, 21, 21, 21, 
22, 22, 22, 23, 23, 23, 24, 24, 24, 25, 25, 25, 26, 26, 26, 27, 
27, 27, 28, 28, 28, 29, 29, 29, 30, 30, 30, 31, 31, 31, 32, 32, 
32, 33, 33, 33, 34), mAODscale = c(0.0388813764134284, 0.0461877433707656, 
0.096886995092774, 0.0371438764134382, 0.0394419100374392, 0.0893994950927635, 
0.0413855430800965, 0.0418085767040992, 0.101328661759439, 0.0428313764134316, 
0.0403835767041016, 0.0978328284261067, 0.0444813764134295, 0.0566460767040979, 
0.136811995092771, 0.0404647097467716, 0.0461127433707702, 0.104611995092768, 
0.0391105430800991, 0.0388294100374367, 0.0883828284261057, 0.0377355430801032, 
0.0334335767040983, 0.0744786617594428, 0.0346647097467638, 0.0316752433707705, 
0.0691911617594343, 0.0365730430800966, 0.0329127433707725, 0.0721203284261094, 
0.0337897097467703, 0.0271960767041008, 0.0568703284261005, 0.0321188764134348, 
0.0226835767040967, 0.0467286617594311, 0.0389522097467676, 0.0317169100374315, 
0.0724911617594444, 0.0374147097467699, 0.0301335767041024, 0.066378661759444, 
0.0359688764134347, 0.0245710767041061, 0.0492828284261009, 0.0340355430801083, 
0.0208835767040938, 0.0401828284261114, 0.033193876413435, 0.0170627433707722, 
0.0363119950927739, 0.0320272097467722, 0.0147294100374324, 0.0298161617594417, 
0.0305563764134433, 0.0123752433707693, 0.0200744950927714, 0.0294522097467649, 
0.00966691003743847, 0.0144453284261061, 0.029439709746768, 0.00845441003743019, 
0.0127494950927769, 0.029218876413438, 0.00767941003742578, 0.0118203284260971, 
0.0283438764134303, 0.00608774337077023, 0.00807032842610056, 
0.027393235387791, 0.00498582029383954, 0.00612513611841337, 
0.0261313764134314, 0.004612743370771, 0.00541616175944171, 0.0260813764134298, 
0.00472524337077118, 0.00372449509276862, 0.0256522097467666, 
0.00535024337077061, 0.00356616175943714, 0.0250313764134376, 
0.0161044100374284, 0.00060366175944182, 0.0241147097467689, 
0.025246076704093, -0.00540050490722876, 0.0233022097467739, 
0.022454410037426, -0.00630883824055672, 0.0208772097467715, 
0.0152252433707645, -0.00819217157389573, 0.0194897097467646, 
-0.00307475662923196, -0.00896300490722979, 0.0178938764134386, 
0.00323774337076088, -0.00836717157389444, 0.0153022097467641
)), row.names = c(NA, -100L), class = c("data.table", "data.frame"
), .internal.selfref = <pointer: 0x000002cacef91f60>)

使用 geom_smooth() 进行编码和绘图

注意：这仅使用我的数据集的子集。

p <- ggplot(test50, aes(x=numDate, y=mAODscale)) +
  geom_point() +
  stat_smooth(method='gam',
              formula=y~s(x,bs="cs",fx=TRUE,k=10))

我正在编写一个简单的 C++ 程序，它生成一个正态分布的随机整数值列表，然后获取前 N 个生成的项目并过滤它们，使它们的绝对值大于 42。我编写的代码如下：

int main() {
//convenience
    namespace rng = std::ranges;
    namespace view = std::views;
//random generation boilerplate
    std::random_device r;
    std::mt19937 gen(r());
    std::normal_distribution<float> taps(-4, 15);
 //the filtering   
    for (const auto& value : view::repeat(0)
        | view::transform([&taps, &gen](auto _) { return std::round(taps(gen)); })
        | view::take(1005)
        | view::filter([](auto val) { return (val < -42 || val > 42); }))
    {
        std::cout << value << ' ';
    }
    return 0;
}

如果我删除该view::filter行，则序列似乎完全正常，并且大约有 3 个左右的值满足条件。然而，当应用过滤器时，输出似乎是一些随机垃圾，例如-12 -8 -14 2 -4 -11 -38. 这有什么意义呢？这些数字甚至不满足过滤条件。任何帮助表示赞赏。

注意：在 Windows 和 Linux 上均
使用 编译。如果我用views::iota(0)替换views::repeat(0)并用 编译，输出是相同的——一些随机垃圾。另外，如果有人建议从 lambda 生成列表的更好方法，我将非常感激。g++ -o test main.cpp -std=c++2b
-std=c++20

简介：我是 Rust 新手，所以我决定通过实现双链表来练习。出于调试目的，我实现了该get()方法，但未能从Rc<RefCell<_>>. （抱歉问了个愚蠢的问题）

问题：我试图返回一个Result<T, &'static str>in ，.get()其中T是节点中存储的数据的类型，&str是错误消息字符串。借用检查器告诉我，我无法返回对方法内变量的引用，因此我尝试将内部值复制出来并返回它，但失败了。

源代码：

use std::{rc::Rc, cell::RefCell};

struct Node<T> {
    data: Option<T>,
    prev: Option<Rc<RefCell<Node<T>>>>,
    next: Option<Rc<RefCell<Node<T>>>>,
}

impl<T> Node<T> {
    /// Instantiate a new dummy node.
    /// This node is used to mark the start and end of the list.
    /// It is not counted in the size of the list.
    fn new() -> Self {
        Node {
            data: None,
            prev: None,
            next: None,
        }
    }
    /// Instantiate a new content node.
    /// This node is used to store data.
    /// It is counted in the size of the list.
    fn from(data: T) -> Self {
        Node {
            data: Some(data),
            prev: None,
            next: None,
        }
    }
}

struct List<T> {
    head: Rc<RefCell<Node<T>>>,
    tail: Rc<RefCell<Node<T>>>,
    size: usize,
}

impl<T> List<T> {
    pub fn new() -> Self {
        let head = Rc::new(RefCell::new(Node::new()));
        let tail = Rc::new(RefCell::new(Node::new()));
        head.borrow_mut().next = Some(Rc::clone(&tail));
        tail.borrow_mut().prev = Some(Rc::clone(&head));
        List { head, tail, size: 0 }
    }
    pub fn prepend(&self, data: T) {
        let node = Rc::new(RefCell::new(Node::from(data)));
        let mut head = self.head.borrow_mut();
        
        node.borrow_mut().next = Some(head.next.take().unwrap());
        node.borrow_mut().prev = Some(Rc::clone(&self.head));
        head.next = Some(Rc::clone(&node));
        if let Some(next) = node.borrow().next.as_ref() {
            next.borrow_mut().prev = Some(Rc::clone(&node));
        };
    }
    pub fn append(&self, data: T) {
        let node = Rc::new(RefCell::new(Node::from(data)));
        let mut tail = self.tail.borrow_mut();
        
        node.borrow_mut().prev = Some(Rc::clone(&tail.prev.take().unwrap()));
        node.borrow_mut().next = Some(Rc::clone(&self.tail));
        tail.prev = Some(Rc::clone(&node));
        if let Some(prev) = node.borrow().prev.as_ref() {
            prev.borrow_mut().next = Some(Rc::clone(&node));
        };
    }
    pub fn get(&self, index: isize) -> Result<T, &'static str> {
        let mut current: Rc<RefCell<Node<T>>> = Rc::clone(self.head.borrow().next.as_ref().unwrap());
        for _ in 0..index {
            let tmp = Rc::clone(current.borrow().next.as_ref().ok_or("Index out of range")?);
            current = tmp;
        }
        let result = current.borrow().data.as_ref().ok_or("Index out of range")?;  // error[E0716]
        Ok(*result)  // error[E0507]
    }
}
/*
error[E0716]: temporary value dropped while borrowed
  --> src\linked.rs:74:22
   |
74 |         let result = current.borrow().data.as_ref().ok_or("Index out of range")?;
   |                      ^^^^^^^^^^^^^^^^                                           - temporary value is freed at the end of this statement
   |                      |
   |                      creates a temporary value which is freed while still in use
75 |         Ok(*result)
   |            ------- borrow later used here
   |
help: consider using a `let` binding to create a longer lived value
   |
74 ~         let binding = current.borrow();
75 ~         let result = binding.data.as_ref().ok_or("Index out of range")?;
   |

error[E0507]: cannot move out of `*result` which is behind a shared reference
  --> src\linked.rs:75:12
   |
75 |         Ok(*result)
   |            ^^^^^^^ move occurs because `*result` has type `T`, which does not implement the `Copy` trait
*/

我试过：

• 这篇关于对 value 进行引用的文章，但这就是我正在尝试做的事情，但失败了。
• 这篇文章关于修改 aRefCell，但这没有帮助。我试图归还它，而不是改变它。
• 这篇文章关于如何借用 aRefCell，但我无法归还借用的值，因为借用的值Rc是短暂的（但内部值不是）。
• 这篇关于如何在 a 中返回某些内容的文章RefCell和这篇关于如何用 来返回它的文章.map()，但是当我尝试使用.into()和借用检查器时，编译器说“特征绑定不满足”，如果我删除 . 则编译器抱怨“无法移出” .into()。
• 这篇关于使用 的文章Rc::try_unwarp()，但它不起作用，因为内部数据有多个所有者。

另外：我可能做错了，如果其中一篇文章解决了我的问题，但我没有以正确的方式实现它，请原谅我，并请教我如何正确地做到这一点。非常感谢。

我读过这个

整数提升：小整数类型（例如 char）的纯右值可以转换为较大整数类型（例如 int）的纯右值。- 第一行
[...详细信息 - 不重要...]
请注意，所有其他转化都不是促销；例如，重载决策选择 char -> int （提升）而不是 char -> Short （转换）。- 最后一行。

从 char -> int 的转换是 'promotion' ；很明显（从 1 个字节到 4 个字节）
从 char -> Short 的转换是“不升级”；为什么？
我一直认为char是一个字节，short（short int）是两个字节。为什么它不被视为促销？这似乎与第一行相矛盾 - 这不是意味着“从小类型转换为大类型”是升级吗？）
-----编辑：在寻找一些答案后：
我们可以考虑“促销是转换的特殊情况”吗？，我们是否可以说“所有促销都是转化，但并非所有转化都是促销”？
或者我们应该将它们视为两个不同且独立的概念？

假设我有一个数据集，其中包含有关在线商店客户的信息。该数据集包括客户名称、购买的产品、购买日期、付款金额以及客户居住的省份等列。我想创建一个分析报告，显示基于省份的总付款金额以及描述每月购买数量的图表。

我使用了分组操作，但没有得到任何结果。

我有一些遗留代码，其中包含一些使用全局变量的构造函数注册自身的单例类。这是一个很大的代码库，被编译成一个可执行文件。我尝试组织代码库并将代码重新分组到库中。当前代码的一个最小示例是

主程序

int main(int argc, char *argv[])
{
  return 0;
} 

哈希.cpp

#include <iostream>

class Hash
{
public:
    Hash()
    {
        std::cout << "Hash\n";
    }
};

Hash a;

当前的构建配置是

CMakeLists.txt

cmake_minimum_required(VERSION 3.26)
project(mcve)

add_executable(mcve main.cpp Hash.cpp)

构建代码并运行可执行文件

Hash

我已将构建配置修改为

cmake_minimum_required(VERSION 3.26)
project(mcve)

add_library(Hash Hash.cpp)
add_executable(mcve main.cpp)
target_link_libraries(mcve Hash)

这将创建一个静态库libHash.a并将其链接到可执行文件。编译相同的代码并运行可执行文件不会打印任何内容。为什么会出现这种差异？在哪里进行了描述？它是 C++ 标准的一部分还是编译器的一部分？它是特定于操作系统的（Linux 静态库）吗？这是未定义的行为吗？

背景：

我正在尝试移植一个库以在 MSVC 上进行编译。该库将数据存储在向量元组 ( std::tuple<std::vector<Ts>...>) 中，并使用自定义迭代器同时迭代所有向量（类似于 zip_iterator 的作用）。

迭代器定义的类型如下所示（假设Ts...-> <int, int>）：

`value_type` is `std::tuple<int, int>`  
`reference`  is `std::tuple<int&, int&>`

问题是，在最新的 MSVC (v. 19.35) 上，这个迭代器不满足 的概念std::input_iterator，而在 gcc/clang 上却满足它。

经过进一步调查，我发现失败是由于std::common_reference元组上的概念行为不一致造成的。

问题：

以下static_assert内容在 MSVC 上失败，而在 gcc/clang 上不会失败

using T = std::tuple<int, int>&;
using U = std::tuple<int&, int&>;
static_assert(std::common_reference_with<T, U>, "failed common_reference_with");

这是Godbolt上的（还有一个迭代器示例）

问题：

像这样的类型std::tuple<int, int>&应该有一个“ common_reference_with”std::tuple<int&, int&>吗？MSVC 说不，gcc 说可以。
根据 C++20 及以后的标准，这两种行为中的哪一种是预期的？

是否有任何简单的方法可以使该迭代器成功通过 MSVC 上的迭代器概念检查（即强制这两种类型具有共同的引用）？

我还在 Eric Niebler 的std::common_reference (SO)和代理迭代器（在他的博客上）上找到了一些很好的答案。

但是，我不清楚 C++20 及更高版本中应该发生什么。

考虑以下valarray类：

#include <stdlib.h>

struct va
{
    void add1(const va& other);
    void add2(const va& other);

    size_t* data;
    size_t  size;
};

void va::add1(const va& other) {
    for (size_t i = 0; i < size; ++i) {
        data[i] += other.data[i];
    }
}

void va::add2(const va& other){
    for (size_t i = 0, s = size; i < s; ++i) {
        data[i] += other.data[i];
    }
}

该add2函数针对不同的编译器（MSVC、Clang、GCC、ICC）进行了向量化，而add1并非如此。参见https://godbolt.org/z/c61qvrrbv

这是通过潜在的别名来解释的：编译器无法证明所指向的元素之一data不是其size本身。

data然而，和指向的元素也可能存在重叠other.data。对于 MSVC，这些元素和指针本身可能存在别名，因为它没有利用严格别名规则。这适用于add1和add2。

编译器正在检查他们怀疑的所有可能的别名，并执行向量化操作add2。

他们为什么不添加更多检查并进行优化add1？

CPP 参考文献中指出：

std::byte是一种独特的类型，它实现了 C++ 语言定义中指定的字节概念。

与 char 和 unsigned char 一样，它可用于访问其他对象（对象表示）占用的原始内存，但与这些类型不同的是，它不是字符类型，也不是算术类型。字节只是位的集合，并且只为其定义了按位运算符。

但这不是真的：因为它是枚举类型，所以比较操作（<, <=, >, >=, ==, !=）也是可能的。

这是故意的吗，例如std::byte也用作 等的密钥std::map？