Halturin Evgeniy's questions

免责声明：我认为给出的示例与名称解析有关，但这种假设可能是错误的。

有这样的代码：https://godbolt.org/z/bEEjP3x16

#include <functional>

int foo() { return 0; };

using Fn = decltype(foo);

template <typename T>
concept Function = std::is_function_v<T>;

template <typename T>
class TValue {};

template <Function F>
class TValue<F*> {
public:
    F* data;
    constexpr operator F* () const { return data; }
};

// ---------------------------------------
#define MYTEST

#ifdef MYTEST
    template <Function F>
    ::std::function(TValue<F*>) -> ::std::function<F>;
#else
    namespace std {
        template <Function F>
        function(TValue<F*>) -> function<F>;
    }
#endif // MYTEST
// ---------------------------------------

int main() {
    TValue<Fn*> v{&foo};

    std::function f = std::function(v);
}

GCC 可以很好地编译它。但是 Clang 和 MSVC 给出编译错误。 （此外，MS 帮助表明错误 C2643 已过时https://learn.microsoft.com/en-us/cpp/error-messages/compiler-errors-2/compiler-errors-c2600-through-c2699?view=msvc-170）

如果你隐藏定义MYTEST

//#define MYTEST

编译将沿着分支进行

namespace std {
    template <Function F>
    function(TValue<F*>) -> function<F>;
}

那么所有 3 个编译器都会顺利完成工作。

这才是真正的问题。谁是对的？或者这根本与名称解析规则无关，还有其他事情发生吗？

template <typename T>
struct MyT {};

template <typename T>
constexpr bool std::is_void_v<MyT<T>> = true;

static_assert(std::is_void_v<MyT<int>>);

在clang和gcc 中static_assert正常工作。但msvc认为，is_void_v仍然是false。

https://godbolt.org/z/9r6YeaM91

我已经遇到过这样一个事实：在msvc中，有些事情的行为与纯 C++ 中的行为并不完全相同，但据我所知，可以使用编译器指令来调节这一点。也许这里也有一些指令？或者这纯粹是一个错误（功能））））？那么，或者如何将它们重新加载到msvc中？

两个祖先都有一个继承人。两个祖先都有一个具有特定名称的方法。在后继方法中，我需要分配（重载）一个具有相同名称的方法，这将重复这些祖先方法之一。这样，当调用后代的方法时，就会执行祖先之一的同名方法。我堆了这个设计

class Base1 {
private:
    int data;
public:
    int const & Data() const { return data; }
};

class Base2 {
private:
    std::vector<int> data;
public:
    Base2() : data{ 1,2,3,4,5,6,7,8,9,0 } {}

    std::vector<int> const & Data() const & { return           data ; }
    std::vector<int>      && Data()      && { return std::move(data); }
};

class Derived: public Base1, public Base2 {
public:
    std::vector<int> const & Data() const & { return Base2::Data(); }
    std::vector<int>      && Data()      && { return std::forward<Base2>(*this).Data(); }
};

constexpr auto WWW() {
    return Derived().Data().size(); // тут вызывается Base2::Data() &&
}

int main()
{
    Derived obj{};
    auto v1 = obj.Data(); // тут вызывается Base2::Data() const
    auto v2 = Derived().Data(); // тут вызывается Base2::Data() &&
    auto s = WWW();
    auto v3 = Base2().Data();
}

再次修复

看起来工作正常（抱歉，我欺骗了自己，然后忘了在哪里。我纠正了）。但第二种方法（Data() &&）不是多余的吗？

&&也许因为我总是只返回对成员字段的常量引用，所以用?编写该方法的第二个版本是没​​有意义的。或者Data() &&会有不必要的复制v2 = Derived().Data();？我无法从汇编器中理解它。

我需要在运行时确定具体类型。种类有固定数量，但也有很多。准确的说是256。我做了一个创客。但看起来令人毛骨悚然。

static TBase* NewObj(unsigned char num)
{
    switch (num)
    {
    case 0: return new TDerived<0>;
    case 1: return new TDerived<1>;
    case 2: return new TDerived<2>;
    case 3: return new TDerived<3>;
    case 4: return new TDerived<4>;
    case 5: return new TDerived<5>;
    case 6: return new TDerived<6>;
    case 7: return new TDerived<7>;
    case 8: return new TDerived<8>;
    case 9: return new TDerived<9>;
    case 10: return new TDerived<10>;
    case 11: return new TDerived<11>;
    case 12: return new TDerived<12>;
    case 13: return new TDerived<13>;
    case 14: return new TDerived<14>;
    case 15: return new TDerived<15>;
    // ...
    // ...
    default: return nullptr;
    }
}

没有256个案例能做到这一点吗？或者这是正常的？还是我又犯傻了？

在什么情况下/以什么方式可以创建编译时常量向量？

例如。C++ 对字符串发誓

constexpr auto vvv0 = std::vector<int>(4, 0);

海湾合作委员会：

“constexpr”变量“vvv0”的类型“const std::vector”不是文字

铛：

constexpr 变量不能具有非文字类型 'const std::vector'

视觉工作室：

表达式必须具有常量值 解释器存储地址的使用无效

尽管这里的向量显然是从文字生成的。标准说

22.3.11.2 构造函数、复制和赋值

constexpr vector(size_type n, const T& value, const Allocator& = Allocator());

6. 前提条件：T 是 Cpp17CopyInsertable into *this。

7. 效果：使用指定的分配器构造一个具有 n 个值副本的向量。引用

8. 复杂度：与 n 呈线性关系。...

有趣的是，在 QT 源代码中没有向量构造函数constexpr)))) 但在 Visual Studio 中却相当

    constexpr vector(const size_type _Count, const _Ty& _Val, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct_n(_Count, _Val);
    }

在什么情况下/以什么方式可以创建编译时常量向量？

（当然，这个问题不仅适用于向量，也不仅适用于作为示例选择的构造函数）

仍在与我的教育多维矩阵作斗争。仍在初始化。首先，在初始化数组时，我初始化存储矩阵结构的字段 - 其维度的一维数组。该数组的长度等于矩阵的维数。数组元素 - 每个维度的矩阵元素数量。因此，数组构造函数之一具有可变数量的参数（参数包） - 只是列出矩阵的维度。

   using dimension_t = unsigned char;

   template <dimension_t Dimension_, std::unsigned_integral SizeType_ = size_t>
   class TMultiDimParam {
   private:

       SizeType_ data[Dimension_];

   public:

       template <std::integral ...size_types>
       TMultiDimParam(const size_types... sizes) :
           data{ static_cast<SizeType_>(sizes)... }
       {}

   };

任务：有必要在编译阶段禁止调用参数数量错误的构造函数。

幸运的是，您不需要执行任何操作来防止超出参数数量。自从尝试时

sib::TMultiDimParam<3> mds0(1, 2, 3, 4);

排队

data{ static_cast<SizeType_>(sizes)... }

会立即出现错误

C2078 初始化程序太多

但如果我打电话的话

sib::TMultiDimParam<3> mds0(1, 2);

然后它将被编译并且数组将被零填充。所以这是我想避免的。

解决方案是将数组元素类型 ( SizeType_) 包装在没有默认构造函数的包装类中。

   using dimension_t = unsigned char;

   template <dimension_t Dimension_, std::unsigned_integral SizeType_ = size_t>
   class TMultiDimParam {
   private:

       template<std::unsigned_integral T>
       struct TDimParam {
           T data;
           TDimParam() = delete;
           TDimParam(T value) : data(value) {};
       };

       TDimParam<SizeType_> data[Dimension_];
       //SizeType_ data[Dimension_];

   public:

       template <std::integral ...size_types>
       TMultiDimParam(const size_types... sizes) :
           data{ static_cast<TDimParam<SizeType_>>(sizes)... }
           //data{ static_cast<SizeType_>(sizes)... }
       {}

   };

而且，你瞧，它奏效了。现在尝试

sib::TMultiDimParam<3> mds0(1, 2);

结果出现错误

C2280 “sib::TMultiDimParam<3,size_t>::TDimParam<SizeType_>::TDimParam(void)”：尝试引用远程函数

这里的基础对我来说开始相当不稳定，因为我希望（我认为这是任何容器在以某种结构的形式直接存储数据之后的第一个含义）这样的技巧不影响性能。而且好像也没有什么效果。我在发布模式下比较了反汇编程序，两个选项是相同的。甚至优化（它不创建临时数组，然后我对其求和，但立即对数字求和）也以相同的方式工作。但这只是“某种程度上”，因为对我来说，正如我已经说过的，这是一个不稳定的基础。知识太肤浅了。如果有人理解，出于体育兴趣或出于对那些不想学习所有东西的懒惰人的怜悯，会说：我是否在正确的方向上前进？或者有更简单/更清晰/更正确的方法吗？

这是我的类，其中构造函数调用方法作为初始值设定项。构造函数和这些方法的签名是相同的（唯一的区别是有些是构造函数，而另一些是返回某些内容的方法）

#include <iostream>
#include <vector>
#include <type_traits>
#include <concepts>

// TMyClass ********************************************************************************
template <size_t Size>
class TMyClass {
public:

    using TData = std::vector<size_t>;

private:

    TData data;

protected:

    template <std::integral size_type>
    TData InitData(const size_type(&arr)[Size]) {
        std::vector<size_t> tmp(Size);
        for (size_t i = 0; i < Size; ++i) {
            tmp[i] = arr[i];
        }
        return tmp;
    }

    template <std::integral size_type>
    TData InitData(const size_type* arr, size_t size = Size) {
            if (size != Size) throw;
        std::vector<size_t> tmp(Size);
        for (size_t i = 0; i < Size; ++i) {
            tmp[i] = arr[i];
        }
        return tmp;
    }

public:

    template <std::integral size_type>
    TMyClass(const size_type(&arr)[Size])
        : data(InitData(arr)) // <------------------ ERROR
    {}

    template <std::integral size_type>
    TMyClass(const size_type* arr, size_t size = Size)
        : data(InitData(arr, size))
    {}

};

// M A I N ********************************************************************************
int main()
{
    int arr[3] = { 3, 4, 5 };
    TMyClass<3> obj1(arr);

    std::vector<int> vec = { 1, 2, 3 };
    TMyClass<3> obj2(vec.data()); // <------------------ ?????


    std::cout << "\n\n  - the end -\n";
    std::cout << "press [Enter]...";
    std::cin.get();
}

结果，我收到错误（代码中的行标记为“<-------------------- ERROR”）：

TMyClass<3>::InitData：对重载函数的不明确调用

看起来一切都是合乎逻辑的，纠正是

template <std::integral size_type>
TData InitData(const size_type* arr, size_t size) {
// ...
}

（删除参数的默认值size）解决了问题。

但！那么为什么线上不会出现这个错误

TMyClass<3> obj2(vec.data()); // <------------------ ?????

毕竟在构造函数中

template <std::integral size_type>
TMyClass(const size_type* arr, size_t size = Size)
    : data(InitData(arr, size))
{}

该参数的默认值size仍然存在。

PS：问题不在于课程的逻辑：什么是正确/不正确？问题是：为什么在相同的（在我看来）情况下会有不同的行为？

PPS：使用标准 type_traits

模板 <类型名称 size_type, std::enable_if_t< std::is_integral_v<size_type>, bool > = true>

给出相同的结果

PPS：在 Visual Studio 和 Qt 上测试

是否有任何编译器指令允许您在执行算术和整数赋值时包含溢出检查和负无符号整数赋值？与 _ITERATOR_DEBUG_LEVEL、CONTAINER_DEBUG_LEVEL (Visual Studio)、_GLIBCXX_ASSERTIONS (Qt) 指令类似，用于在容器及其迭代器中启用有效性和范围检查。我还假设“否定未签名”检查可以解释为溢出，但我不知道，也许对此事已经有一些既定的看法。

事实上，我也在编写自己的容器（一个多维数组，用于教育目的），但除了指定的检查之外，我还想添加调试来检查我没有得到负大小一构造函数中的尺寸，但我不想将这些检查拖到版本中。如果编译器中已经存在类似的指令，那么创建自己的指令并不是很好。

我在这个主题上找到的所有内容都是在运行时实现检查的示例。是的，我需要它们。但问题不在于他们。我希望它们（这些检查）默认被禁用，但可以启用以进行测试。

添加：

我完全忘记提到断言。断言是可能的，但它的范围太宽了。一个 NDEBUG 解决所有问题。简单地说，如果它在这里有一席之地，那么为什么它在标准容器中没有一席之地呢？我不知道……但如果根据规范这确实是断言的地方，那就让它断言吧。但我真的还不知道。

我让我的班级有机会使用 << 运算符写入 ostream。

friend static std::ostream& operator<<(std::ostream& stream, const my_type& arg)

但原则上，将来你可能需要在iostream中记录。是的，对于其他子线程来说，basic_ostream<char, char_traits<char>> 立即定义运算符是否有意义：

friend static std::ostream& operator<<(std::basic_ostream<char, char_traits<char>>& stream, const my_type& arg)

？

或者这是不礼貌的行为，他们出于某种原因不这样做？