coding

我正在处理一个相当统一的供应商提供的 API，并且希望以统一的方式检查和处理任何故障。为此，我编写了以下包装器：

template <typename Func, typename... Args>
auto awrap(Func &func, Args&&... args)
{
    auto code = func(args...);

    if (code >= 0)
        return code;

    ... handle the error ...
};
...
awrap(handlepath, handle, path, NULL, 0, coll, NULL);

上面的代码可以通过 clang 编译，但是 g++13 和 Microsoft VC++ 都对两个 NULL 参数提出抱怨：

... error: invalid conversion from 'int' to 'const char*' [-fpermissive]
   87 |                 auto code = func(args...

用 替换两个NULLs 可以nullptr解决问题，但是这有什么关系呢？

很可能，预处理器NULL会将 转换为0x0，甚至0在某个地方，但原始调用从未引起“注意”。在以下情况下，使用 NULL 非常合适：

handlepath(handle, path, NULL, 0, coll, NULL);

为什么在包装器中使用时会出现问题（对于某些编译器而言）？

更新：/usr/include/sys/_null.h我的 FreeBSD 系统上有以下代码：

#ifndef NULL

#if !defined(__cplusplus)
#define NULL    ((void *)0)
#else
#if __cplusplus >= 201103L
#define NULL    nullptr
#elif defined(__GNUG__) && defined(__GNUC__) && __GNUC__ >= 4
#define NULL    __null
#else
#if defined(__LP64__)
#define NULL    (0L)
#else
#define NULL    0
#endif  /* __LP64__ */
#endif  /* __GNUG__ */
#endif  /* !__cplusplus */

#endif

所以：

1. 对于 C，NULL是(void *)0；

2. 对于 clang++ 来说NULL和nullptr是同一件事，而对于 GNU 来说可能不是......

代码显示：

const fn = (length, label, callback) => {
  console.time(label);
  for (let i = 0; i < length; i++) {
    callback && callback(i);
  }
  console.timeEnd(label);
};

const length = 100000000;
fn(length, "1", () => {})  // very few intervals
fn(length, "2", () => {})  // regular
fn(length, "3", () => {})  // regular

然后我删除了第三个参数callback，它们的执行时间非常接近..

const fn = (length, label, callback) => {
  console.time(label);
  for (let i = 0; i < length; i++) {
    callback && callback(i);
  }
  console.timeEnd(label);
};

const length = 100000000;
fn(length, "1")  // regular
fn(length, "2")  // regular
fn(length, "3")  // regular

为什么？？？

假设我有以下代码（https://godbolt.org/z/MW4ETf7a8）：

犃

#include <iostream>

struct X{
    void* operator new(std::size_t size)
    {
        std::cout << "new X\n";
        return malloc(size);
    }

    void operator delete(void* ptr)
    {
        std::cout << "delete X\n";
        return free(ptr);
    }

    virtual ~X() = default;
};

struct ArenaAllocatedX : public X {
    void* operator new(std::size_t size)
    {
        std::cout << "new ArenaAllocatedX\n";
        return malloc(size);
    }

    void operator delete(void* ptr)
    {
        std::cout << "delete ArenaAllocatedX\n";
        return free(ptr);
    }
};

主程序

int main() {
    X* x1 = new X();
    delete x1;

    X* x2 = new ArenaAllocatedX ();
    delete x2;    
}

使用 GCC 10.3.1， x1调用的new和delete操作符class X，同时x2调用class ArenaAllocatedX。

我理解它将如何选择new运算符，因为它的右边有实际的类名，但我不明白delete在被指向时如何为子类选择运算符X*。

new/运算符是否被delete视为虚拟表内的函数（我使用转储了 VTablegcc -f-dump-lang-class但没有看到任何删除运算符）？

VTable转储：

Vtable for X
X::_ZTV1X: 4 entries
0     (int (*)(...))0
8     (int (*)(...))(& _ZTI1X)
16    (int (*)(...))X::~X
24    (int (*)(...))X::~X

Class X
   size=8 align=8
   base size=8 base align=8
X (0x0x7f38cd807780) 0 nearly-empty
    vptr=((& X::_ZTV1X) + 16)

Vtable for ArenaAllocatedX
ArenaAllocatedX::_ZTV15ArenaAllocatedX: 4 entries
0     (int (*)(...))0
8     (int (*)(...))(& _ZTI15ArenaAllocatedX)
16    (int (*)(...))ArenaAllocatedX::~ArenaAllocatedX
24    (int (*)(...))ArenaAllocatedX::~ArenaAllocatedX

Class ArenaAllocatedX
   size=8 align=8
   base size=8 base align=8
ArenaAllocatedX (0x0x7f38cd848680) 0 nearly-empty
    vptr=((& ArenaAllocatedX::_ZTV15ArenaAllocatedX) + 16)
X (0x0x7f38cd807cc0) 0 nearly-empty
      primary-for ArenaAllocatedX (0x0x7f38cd848680)

C++ 如何选择delete在所提供的代码中使用哪个运算符？

这不是一个特定的错误，而是一个一般的 C++ 设计问题。考虑以下场景：

struct MyInterface {};

struct Data : MyInterface{};

struct DataWrapper
{
    SomeContainerOf<MyInterface*> getData()
    {...}
private:
    std::vector<Data> dataStorage;
};

根据我的要求，我需要访问器函数来DataWrapper返回值的容器MyInterface*（指针，因为我们真正返回Data值）。

理想情况下，我们希望在不复制的情况下完成此操作。我想知道做到这一点的最佳方法。据我所知，如下是惯用的 C++ 方法：

auto DataWrapper::getData()
{
    return dataStorage
        | std::ranges::views::transform(
            [](Data& d) -> MyInterface* { return &d; }
        );
}

但问题是，很明显这个访问器方法对其返回值是明确的 - 我需要知道这个方法返回这个列表，并且我担心在创建返回类型时auto，它会有点阻碍。看起来（我在这里可能是错的）你不应该知道 a 的类型view是什么（与 lambda 类似）

我正在考虑的替代方案是制作一个自定义视图（我可以使类型更加清晰），但重新实现标准中如此明确的东西确实让我很痛苦。对于这种情况，建议采取什么行动？现代 C++ 是否说我应该保留返回值auto？

我不相信这SortedSet.IsSubsetOf会按预期工作。给出这段代码，不应该ss.IsSubsetOf(l)返回 True 吗？

我怀疑问题出在我的CompareTo函数中，但我看不到问题所在。

我还添加了一个单独的循环，认为必须在otherIEnumerable 内找到该集合并进行排序。。。但这也行不通。

谁能解释为什么会发生这种行为？

List<Point> l = new();
SortedSet<Point> ss = new();
HashSet<Point> h = new();

for (int i = 0; i < 100; i++)
{
    var p = new Point(i, i);
    l.Add(p);
    l.Add(p);
    h.Add(p);
    h.Add(p);
    ss.Add(p);
    ss.Add(p);
}

// additional loop to get a sorted set.
for (int i = 0; i < 100; i++)
{
    l.Add(new Point(i, i));
}

Console.WriteLine(l.Count); // 300
Console.WriteLine(h.Count); // 100
Console.WriteLine(ss.Count); // 100
Console.WriteLine(h.IsSubsetOf(l));  // True (as expected)
Console.WriteLine(h.IsProperSubsetOf(l)); // False

// This is the line in question
Console.WriteLine(ss.IsSubsetOf(l)); // False ?????????

Console.WriteLine(ss.IsProperSubsetOf(l)); // False

readonly struct Point : IComparable<Point>, IEquatable<Point>
{
    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }

    public double X { get; }
    public double Y { get; }

    public int CompareTo(Point other)
    {
        if (X == other.X)
        {
            return Y.CompareTo(other.Y);
        }
        else
        {
            return X.CompareTo(other.X);
        }
    }

    public bool Equals(Point other)
    {
        return X == other.X && Y == other.Y;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(X, Y);
    }
}

作为计算机安全入门课程的一部分，我们有一个关于 SQL 注入的简短单元。其中一项作业是一个基本的未经清理的登录页面。预期的解决方案是沿着经典路线的' or 1=1; -- ，但我们始终欢迎学生找到非传统的解决方案。

最近向我提出了这样的解决方案：输入'--'密码似乎执行了成功的 SQL 注入。这将导致查询被评估为如下所示：
SELECT * FROM users WHERE name='admin' AND password=''--'';

这里，--'';不被解析为注释，因为 MariaDB 要求注释后面跟空格。事实上，如果双破折号被解析为注释，则该查询根本不会返回任何内容；password=''同样地，假设密码非空，我们将得到，其计算结果为 false。

末尾的额外一对引号似乎是必要的：将其保留为password=''--;或在其后面插入其他数据 ( password=''--1;) 会导致条件被评估为 false，如预期的那样。

一些快速测试无法在其他数据库中重现这种行为——据我所知，这是 MariaDB 特有的行为。该文档确认两个不带空格的破折号不会被解析为注释，但没有详细说明它们被解析为什么。编辑：不知何故，我设法忽略了 MySQL 中也发生这种情况的事实。事实上，这种行为发生在任何 MySQL 分支（不仅仅是 MariaDB）中。

--当它后面没有空格时会发生什么？为什么它会导致比较结果为 true？

一个玩具示例：

CREATE TABLE users (
  userid INTEGER PRIMARY KEY,
  username TEXT NOT NULL,
  password TEXT NOT NULL
);

INSERT INTO users VALUES (0001, 'admin', 'S3cur3P4ssw0rd!');
INSERT INTO users VALUES (0002, 'generic_user', 'Password');

SELECT * FROM users WHERE username='admin' AND password=''; -- empty password, query returns no users
SELECT * FROM users WHERE username='admin' AND password=''-- ''; -- parsed as comment, equivalent to above query, returns no users
SELECT * FROM users WHERE username='admin' AND password=''--''; -- query returns admin user
SELECT * FROM users WHERE username='admin' AND password=''--; -- query returns zero users
SELECT * FROM users WHERE username='admin' AND password=''--1; -- query returns zero users

通常，如果您尝试为同一关键字参数传递多个值，您会收到 TypeError：

In [1]: dict(id=1, **{'id': 2})
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [1], in <cell line: 1>()
----> 1 dict(id=1, **{'id': 2})

TypeError: dict() got multiple values for keyword argument 'id'

但是，如果您在处理另一个异常时执行此操作，则会收到 KeyError：

In [2]: try:
   ...:     raise ValueError('foo') # no matter what kind of exception
   ...: except:
   ...:     dict(id=1, **{'id': 2}) # raises: KeyError: 'id'
   ...: 
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [2], in <cell line: 1>()
      1 try:
----> 2     raise ValueError('foo') # no matter what kind of exception
      3 except:

ValueError: foo

During handling of the above exception, another exception occurred:

KeyError                                  Traceback (most recent call last)
Input In [2], in <cell line: 1>()
      2     raise ValueError('foo') # no matter what kind of exception
      3 except:
----> 4     dict(id=1, **{'id': 2})

KeyError: 'id'

这里发生了什么？一个完全不相关的异常如何影响dict(id=1, **{'id': 2})抛出什么样的异常？

对于上下文，我在调查以下错误报告时发现了此行为：https://github.com/tortoise/tortoise-orm/issues/1583

这已在 CPython 3.11.8、3.10.5 和 3.9.5 上重现。

请投票给问题跟踪器 https://issuetracker.google.com/issues/330368298

我刚刚通过查看 Firebase Crashlytics 注意到我的应用程序发生了一些崩溃，这似乎与尝试使用SharedPreferences但由于强制转换异常而无法获得首选项的 Google AdMob 库相关：

代码文字：

Fatal Exception: java.lang.ClassCastException
java.lang.Integer cannot be cast to java.lang.String
android.app.SharedPreferencesImpl.getString (SharedPreferencesImpl.java:302)
com.google.android.gms.ads.internal.scionintegration.a.onSharedPreferenceChanged (:com.google.android.gms.policy_ads_fdr_dynamite@[email protected]:73)
com.google.android.gms.ads.internal.scionintegration.m.a (:com.google.android.gms.policy_ads_fdr_dynamite@[email protected]:106)
com.google.android.gms.ads.nonagon.a.s (:com.google.android.gms.policy_ads_fdr_dynamite@[email protected]:439)
com.google.android.gms.ads.nonagon.a.b (:com.google.android.gms.policy_ads_fdr_dynamite@[email protected]:5)
com.google.android.gms.ads.ChimeraMobileAdsSettingManagerCreatorImpl.getMobileAdsSettingManager (:com.google.android.gms.policy_ads_fdr_dynamite@[email protected]:52)
com.google.android.gms.ads.internal.client.bx.bR (:com.google.android.gms.policy_ads_fdr_dynamite@[email protected]:40)
m.ajn.onTransact (:com.google.android.gms.policy_ads_fdr_dynamite@[email protected]:21)
android.os.Binder.transact (Binder.java:1173)
obj.gL (:com.google.android.gms@[email protected] (190400-607434947):8)
com.google.android.gms.ads.internal.client.ay.getMobileAdsSettingManager (:com.google.android.gms@[email protected] (190400-607434947):12)
com.google.android.gms.ads.MobileAdsSettingManagerCreatorImpl.getMobileAdsSettingManager (:com.google.android.gms@[email protected] (190400-607434947):42)
com.google.android.gms.ads.internal.client.az.fL (:com.google.android.gms@[email protected] (190400-607434947):40)
obk.onTransact (:com.google.android.gms@[email protected] (190400-607434947):101)
android.os.Binder.transact (Binder.java:1173)
com.google.android.gms.internal.ads.zzavg.zzbh (com.google.android.gms:play-services-ads-base@@22.6.0:1)
com.google.android.gms.ads.internal.client.zzcp.zze (zzcp.java:169)
com.google.android.gms.ads.internal.client.zzeq.zza (zzeq.java:169)
com.google.android.gms.ads.internal.client.zzaq.zzc (com.google.android.gms:play-services-ads-lite@@22.6.0:169)
com.google.android.gms.ads.internal.client.zzax.zzf (com.google.android.gms:play-services-ads-lite@@22.6.0:126)
com.google.android.gms.ads.internal.client.zzax.zzd (com.google.android.gms:play-services-ads-lite@@22.6.0:126)
com.google.android.gms.ads.internal.client.zzej.zzA (com.google.android.gms:play-services-ads-lite@@22.6.0:17)
com.google.android.gms.ads.internal.client.zzej.zzm (zzej.java:53)
com.google.android.gms.ads.MobileAds.initialize (com.google.android.gms:play-services-ads-lite@@22.6.0:53)
com.MY_APP_PACKAGE.ads.AdMob.initAdmob (AdMob.kt:128)

有人有这个问题吗？

我还有其他使用 22.6.0 版本 Admob 的应用程序，我没有注意到它们发生此类崩溃，而对于这个应用程序，它只发生在 6 个用户（约 23 万用户）中，但仍然......为什么会发生这种情况......

更新：

发现其他人也出现同样的问题：https ://groups.google.com/g/google-admob-ads-sdk/c/88UHAaWElsc

更新2：

现在我遇到了更多崩溃，现在它影响了其他应用程序

ps 另外，Admob Dashboard API 今天也关闭了，所以 mb 这是相关的

Reddit 主题

谷歌问题追踪器

临时解决方案：如果您为应用程序设置了 Firebase Remote Config 以禁用广告，MobileAds.initialize()如果您添加了特定参数，这也会阻止调用。不幸的是，就我而言，我只有参数来启用/禁用应用程序屏幕上的广告类型（横幅、插页式广告），但没有参数来阻止加载同意信息（UMP 库）和MobileAds.initialize()，但我现在会添加它以供将来使用案例...

我有以下内容

library(tidyverse)
test <- tibble(A = c("1994:2020, 2021"), B = 1995)

我想检查 B 中的年份是否在 A 列中给出的年份中。A 列中的年份是一个字符串（数据是从 Excel 文件中读取的）。以下显然不起作用（它给出“否”，但我想要“是”）：

test %>%
  mutate(InA = ifelse(B %in% A, "Yes", "No"))

> test
# A tibble: 1 x 2
  A                   B
  <chr>           <dbl>
1 1994:2020, 2021  1995

我假设我必须分隔 A 中的字符串。但是，A 可以包含多个范围和/或超过一年（例如（“1994:2012, 2014, 2016:2020, 2021”）并使用“separate”对于不同的结构会变得复杂，也许有更简单的方法。

以下代码生成的程序集在使用-O3. 为了完整起见，代码始终在 GCC 13.2 中执行 SIMD，而从不在 clang 17.0.1 中执行 SIMD。

#include <array>

__attribute__((noinline)) void fn(std::array<int, 4>& lhs, const std::array<int, 4>& rhs)
{
    for (std::size_t idx = 0; idx != 4; ++idx) {
        lhs[idx] = lhs[idx] + rhs[idx];
    }
}

这是Godbolt 中的链接。

这是 GCC 12.3 的实际汇编（使用 -O3）：

fn(std::array<int, 4ul>&, std::array<int, 4ul> const&):
        lea     rdx, [rsi+4]
        mov     rax, rdi
        sub     rax, rdx
        cmp     rax, 8
        jbe     .L2
        movdqu  xmm0, XMMWORD PTR [rsi]
        movdqu  xmm1, XMMWORD PTR [rdi]
        paddd   xmm0, xmm1
        movups  XMMWORD PTR [rdi], xmm0
        ret
.L2:
        mov     eax, DWORD PTR [rsi]
        add     DWORD PTR [rdi], eax
        mov     eax, DWORD PTR [rsi+4]
        add     DWORD PTR [rdi+4], eax
        mov     eax, DWORD PTR [rsi+8]
        add     DWORD PTR [rdi+8], eax
        mov     eax, DWORD PTR [rsi+12]
        add     DWORD PTR [rdi+12], eax
        ret

我非常想知道 a) 前 5 条汇编指令的目的，以及 b) 是否可以采取任何措施使 GCC 12.3 发出 GCC 13.2 的代码（理想情况下，无需手动编写 SSE）。

从文档中可以看出：

pub fn new(x: T) -> Box 在堆上分配内存，然后将 x 放入其中。

但“地点”是一个棘手的词。如果我们写

let arr_boxed = Box::new([0;1000]);

会[0;1000]在堆上就地初始化吗？

如果我们写

let arr = [0;1000];
let arr_boxed = Box::new(arr);

[0;1000]编译器是否足够聪明，可以首先在堆上初始化？

在微控制器上，为了避免加载之前固件版本的设置，我还存储编译时间，在加载时检查该时间。

该微控制器项目是使用MikroElektronika 的“ mikroC PRO for ARM”构建的。

为了方便调试，我在PC上用minGW编写了代码，左右检查后，将其放入microC中。

使用该检查的代码无法正常工作。经过一晚令人沮丧的调试后，我发现sizeof("...")在两个平台上产生了不同的值，并因此导致缓冲区溢出。

但现在我不知道是谁的错。

要重新创建问题，请使用以下代码：

#define SAVEFILECHECK_COMPILE_DATE __DATE__ " " __TIME__

char strA[sizeof(SAVEFILECHECK_COMPILE_DATE)];
char strB[] = SAVEFILECHECK_COMPILE_DATE;

printf("sizeof(#def): %d\n", (int)sizeof(SAVEFILECHECK_COMPILE_DATE));
printf("sizeof(strA): %d\n", (int)sizeof(strA));
printf("sizeof(strB): %d\n", (int)sizeof(strB));

在 MinGW 上它返回（如预期）：

sizeof(#def): 21
sizeof(strA): 21
sizeof(strB): 21

但是，在“mikroC PRO for ARM”上，它返回：

sizeof(#def): 20
sizeof(strA): 20
sizeof(strB): 21

这种差异导致了缓冲区溢出（覆盖指针的字节零——哎呀）。

21 是我期望的答案：20 个字符和 '\0' 终止符。

这是 C 中“视情况而定”的事情之一，还是违反了sizeof运算符行为？

如果存在std::map<std::pair<std::string, std::string>, some_type>找到其值的最佳方法是什么？

我想最明显的一个是做这样的事情： 但这将导致在对构造期间对和字符串map.find(std::make_pair(str1, str2)); 进行复制构造。str1str2

我希望也许map.find(std::make_pair(std::ref(str1), std::ref(str2)));能有所帮助，但不幸的是没有，这仍然会产生字符串副本。

map.find(std::make_pair(std::move(str1), std::move(str2))应该可以工作，但我们假设这些字符串 ( str1, str2) 是 const 或者不应该移动。

所以我问是否有其他方法可以进行地图搜索而不进行多余的字符串副本？

（请注意，使用std::string_viewforstd::map key不是一个选项，因为地图应该拥有其字符串。）

我正在 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)
)

问题

我想知道每一行的col1、 col2和col3是否与col4、col5和col6相同，但应忽略 col1 - col3 和 col4 - col6 的顺序。

因此，对于第 1 行，如果 col1 - col3 分别包含 a、a、b，并且 col4 - col6 分别包含 b、a、a，则将被视为匹配。

期望的结果

在“评估”栏中添加注释以帮助理解

我需要定义一个接受多个 3D 坐标作为参数的 C++ 模板。当这些坐标的所有维度都定义为单独的整数变量时，参数列表将变得非常长 - 3 个坐标需要 9 个参数，这使得模板难以使用。

因此，非常希望以使用编译时数组的方式声明模板。它们的默认参数也应该直接在模板声明的位置声明为值，而不是变量名。

经过一些实验，令我惊讶的是，我发现 GCC 13 将接受以下 C++ 程序std=c++20：

#include <cstdio>
#include <array>

template <
    std::array<int, 3> offset = {0, 0, 0}
>
struct Array
{
    void operator() (int i, int j, int k) 
    {
        printf("(%d, %d, %d)\n", i + offset[0], j + offset[1], k + offset[2]);
    }
};

int main(void)
{
    Array arr_default;
    arr_default(0, 0, 0);

    Array<{1, 1, 1}> arr;
    arr(0, 0, 0);

    return 0;
}

然而，clang 18 拒绝使用braced-init-list，因为它无效：

test2.cpp:5:30: error: expected expression
    5 |         std::array<int, 3> offset = {0, 0, 0}
      |                                     ^
test2.cpp:17:8: error: no viable constructor or deduction guide for deduction of template arguments of 'Array'
   17 |         Array arr_default;
      |               ^
test2.cpp:7:8: note: candidate template ignored: couldn't infer template argument 'offset'
    7 | struct Array
      |        ^
test2.cpp:7:8: note: candidate function template not viable: requires 1 argument, but 0 were provided
    7 | struct Array
      |        ^~~~~
test2.cpp:20:8: error: expected expression
   20 |         Array<{1, 1, 1}> arr;
      |               ^
3 errors generated.

问题

1. 它真的是合法的C++程序吗？如果是，我应该使用什么语法来说服 clang 接受它？如果不是，我是否应该报告 GCC 错误以毫无疑问地接受它？

2. 是否有替代且更兼容的方式来实现我的目标？std::array不必使用，任何其他具有同等效果的方法也可以。

这是 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，该对象执行实际迭代并返回结果列表，并立即调用它。我无法理解需要创建一个单独的函数来执行这项工作。这是一种优化技巧吗？

我读过这个

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

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

背景：

我正在尝试移植一个库以在 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？