问题[c++](coding)

我有一个采用模板 size_t 参数的基类和 2 个派生类，将模板参数提供给基类​​。

template<size_t N>
class BaseClass
{
  size_t value = N;
};

class Derived1 : public BaseClass<1>
{};

class Derived2 : public BaseClass<2>
{};

现在我想在从 Baseclass 派生的任何类上创建一个模板函数。所以我想在通用类 T 上创建一个模板，并使用 std::is_base_of_v(...) 的要求来确保 T 是一个 BaseClass。

给出父类时的问题我还需要精确存储在 T 中的 size_t 模板参数。

我最终得到以下结果：

template<class T>
  requires std::is_base_of_v<BaseClass<T.value>, T>
void
function(T arg) {};

显然这不能编译，因为 T 是一个通用类并且不包含属性值，我发现解决这个问题的唯一方法是向函数添加另一个 size_t 模板参数并在 BaseCLass 中使用它：

template<class T, size_t N>
  requires std::is_base_of_v<BaseClass<N>, T>
void
function(T arg) {};

这（应该）可行，但我对这个解决方案不太满意，因为最终我得到了一个冗余的 N，我必须手动将它赋给函数模板以及已经保存了该值的派生类。有什么办法可以解决这个问题吗？

我制作了一些模板，旨在

• （1）测试数字是否可以相加而不溢出，
• （2）添加数字，如果溢出则失败。

test_sum里面的(1)static_assert编译通过了，所以我猜是的constexpr。
为了避免重复计算，我尝试将断言直接放在计算和的 (2) 函数中。然而，在下面的所有版本中，无论条件如何，断言总是失败。有什么办法可以解决这个问题吗？

#include <limits>
#include <stdexcept>
#include <type_traits>

template<typename T>
constexpr bool add(T& a, T b)
{
    static_assert(std::is_integral<T>::value, "Only integral types are supported");

    if ((b > 0) && (a > std::numeric_limits<T>::max() - b))
        return false;
    if ((b < 0) && (a < std::numeric_limits<T>::min() - b))
        return false;

    a += b;
    return true;
}

//

template<typename T>
constexpr bool sum_impl(T& result)
{
    return true;
}

template<typename T, typename... Rest>
constexpr bool sum_impl(T& result, T value, Rest... rest)
{
    if (!add(result, value))
        return false;

    return sum_impl(result, rest...);
}

//

template<typename T, typename... Rest>
constexpr bool test_sum(T value, Rest... rest) // (1)
{
    return sum_impl(value, rest...);
}

template<typename T, typename... Rest>
T sum(T value, Rest... rest) // (2) regular
{
    if (!sum_impl(value, rest...))
        throw std::overflow_error("Overflow in checked::sum");

    return value;
}

template<typename T, typename... Rest>
constexpr T sum_cexpr(T value, Rest... rest) // (2) constexpr
{
//  if (!sum_impl(value, rest...))
//      static_assert(false, "Overflow"); // fail

//  static_assert(sum_impl(value, rest...), "Overflow"); // fail

//  if (!sum_impl(value, rest...))
//      delegated_assert<false>(); //  fail

    return value;
}

template<bool B>
constexpr void delegated_assert()
{
    if constexpr (!B)
        static_assert(B);
}

//////

int main()
{
    static_assert(test_sum(1, 2)); // (1) works

    constexpr int a = sum_cexpr(10, 20, 30); // fails to compile
    
    return 0;
}

我正在 VS Code 中尝试 Pico SDK 和扩展程序，但当我用 C++ 而不是 C 语言编写文件程序时，似乎很多硬件选项都无法使用了。具体来说，我更倾向于使用 ADC。

#include "hardware/adc.h"

这在 C 程序中运行良好，但在 C++ 中不再可用。

 fatal error: hardware/adc.h: No such file or directory

为什么会这样？我该怎么办？我更喜欢用 C++ 来编写程序，因为我想使用 C++ 附带的一些标准库，而且对我来说，C++ 更直观。

标准是否要求operator->()为非连续的末端迭代器定义？

背景：

• operator*()无论迭代器属于哪种类别，当迭代器指向末尾之后的值时，都允许表现出未定义的行为。这一点在https://en.cppreference.com/w/cpp/iterator的“可解引用性和有效性”一节中明确指出：“对于迭代器 i ，如果表达式 *i 已定义，则该值被称为可解引用的。标准库从不假设末尾之后的值是可解引用的。”
• 编辑：此点的结论是错误的：请参阅下面的答案。对于连续operator->()迭代器，我认为当迭代器指向末尾之后时，不允许出现未定义的行为。这可以从 cppreference 中的两个部分推断出来：(1) 在https://en.cppreference.com/w/cpp/iterator/contiguous_iterator上，“语义要求”部分定义了不可解引用的迭代器c，并说明了std::to_address(c)暗示std::to_address(c)不会出现未定义行为的要求。(2) 在https://en.cppreference.com/w/cpp/memory/to_address上，它提供了一个“可能的实现”，其中std::to_address依赖于operator->()。编辑：如果迭代器已定义，则“可能的实现”不使用；如果是这种情况，则似乎允许不为末尾迭代器定义 。operator->()pointer_traitsoperator->()

目前尚不清楚是否允许非连续operator->()迭代器实现，因此对于尾后迭代器，其行为是未定义的。以下是我找到的与此相关的各种“证据”/“提示”：

• 非连续的 C++20 迭代器概念似乎根本不需要定义它。据我所知， https://en.cppreference.com/w/cpp/iterator/random_access_iteratoroperator->()中定义的所有要求，或者它们所依赖的要求，根本没有提到这一点。
• 连续的 C++20 迭代器概念std::contiguous_iterator需要operator->()：如上所述，由于std::to_address必须定义 ，因此可以推断出 ，并且 的“可能实现”std::to_address使用operator->()。并且页面https://en.cppreference.com/w/cpp/memory/to_address明确提到std::contiguous_iterator。由于它没有提及其他迭代器类型，因此对于非连续迭代器 IIUC 来说，这并不意味着任何含义。
• 旧式迭代器类别要求operator->()为 和 更强的 定义（参见https://en.cppreference.com/w/cpp/named_req/InputIteratorLegacyInputIterator上的表格），并且满足“前提条件：i 可解引用”的条件。换句话说，存在一个明确的例外，允许尾后迭代器表现出未定义的行为。我没有看到任何更强的旧式迭代器类别删除了这个前提条件（仅供参考，甚至https://en.cppreference.com/w/cpp/named_req/ContiguousIterator也没有，所以这看起来像是和之间的区别）。LegacyContiguousIteratorstd::contiguous_iterator
• 另一方面，在https://en.cppreference.com/w/cpp/iterator的“可解引用性和有效性”部分中，它提到operator*()对于尾后迭代器不需要定义，但没有提到operator->()。因此，这可能表明允许对尾后迭代器进行某些操作未定义的例外不一定适用于operator->()。

所以，很容易让人感到困惑，我看到了不少与非连续迭代器、operator->()以及末尾过长相关的“证据”/“提示”。但据我所知，没有明确的要求规定非连续迭代器在operator->()指向末尾过长时是否允许表现出未定义的行为。有人能给出更明确的答案吗？

编辑：感谢几条有用的评论。提供一些背景信息，可能是为了回答一些回复：实际操作方面，稍微简化一下，我定义了迭代器包装器，即自定义迭代器类，其实现依赖于现有的（“包装的”）迭代器。包装的迭代器的类型作为模板参数给出，包装的迭代器作为构造函数参数给出。我粗心地认为我可以operator->()在包装器类中定义为&*wrapped_iterator。这在 clang、gcc、MSVC 发布版本，甚至在 MSVC 调试版本中对于非连续迭代器都有效。然而，它导致 MSVC 调试版本中对于连续迭代器的断言失败，在诸如std::vector::assign(first,last)first 和 last 是连续迭代器的包装器，以及 first 和 last 都是尾后迭代器的函数中。原因是 MSVCvector::assign调用了std::address_of(first) even if first==last，这是我没有预料到的。反过来，它为我的连续迭代器包装器address_of调用了。first.operator->()由于我已将其定义operator->()为&*wrapped_iterator，因此它会operator*在包装的迭代器中调用，而该迭代器在给定条件下的行为是未定义的。在这个特定情况下，它导致了断言失败，因为 MSVC 的调试模式有特殊的代码来检查类似这样的内容 ( _ITERATOR_DEBUG_LEVEL)。

所以我需要修改迭代器包装器的实现operator->()。我最初的想法是让它在包装的迭代器上调用。然而，这并不保证一定能实现（参见已接受的答案）。我需要做的是在包装的迭代器上operator->()调用。std::to_address

让我先从一段C++代码开始，它简化了我在实际代码库中遇到的问题。我用--std=c++20和编译了它--std=c++17。下面的第一个 for 循环没有问题；而第二个 for 循环（它返回结果）std::optional<Container>在我尝试过的所有多个容器中都不行。我想了解原因：

#include <iostream>
#include <optional>
#include <string>
#include <unordered_set>

std::unordered_set<std::string> GenerateSet() {                                                                                                                                                                                                      
  std::unordered_set<std::string> names = {"a", "b"};                                                                                                                                                                                                
  return names;                                                                                                                                                                                                                                      
}

std::optional<std::unordered_set<std::string>> GenerateOptionalSet() {                                                                                                                                                                               
  std::unordered_set<std::string> names = {"a", "b"};                                                                                                                                                                                                
  return names;                                                                                                                                                                                                                                      
}

int main() {                                                                                                                                                                                                                                         
  std::cout << "When a set is returned: {";                                                                                                                                                                                                          
  for (const auto& e : GenerateSet()) {                                                                                                                                                                                                              
    std::cout << e << " ";                                                                                                                                                                                                                           
  }                                                                                                                                                                                                                                                  
  std::cout << "}" << std::endl;                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  std::cout << "When a optional of a set is returned: {";                                                                                                                                                                                            
  for (const auto& e : GenerateOptionalSet().value()) {                                                                                                                                                                                              
    std::cout << e << " ";                                                                                                                                                                                                                           
  }                                                                                                                                                                                                                                                  
  std::cout << "}" << std::endl;                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  return 0;                                                                                                                                                                                                                                          
}

结果是运行时出现分段错误（相当新clang），或者在第二个 for 循环中根本没有迭代（gcc在古老的 Linux 机器上相当旧）。

std::optional<T>::value()这是我提到的有关: std::optional::value()的 URL，来自 cppreference.com

似乎有 4 个不同的版本。我不太确定这 4 个重写函数中哪个版本会被调用，以及为什么它没有按我预期的方式工作（即只是循环遍历返回的临时值std::optional<T>）。

从上一个问题中我知道，在~base()调用派生类时，它首先构造一个临时基对象，然后operator~()在临时对象上调用临时基，最后销毁临时对象。

但是当基类没有时operator~，在派生类中调用base::~base()仍然可以调用基类的析构函数。

为什么当基类有时会发生错误operator~？

#include <iostream>
using namespace std;
class base
{
public:
    base(){cout << "constructor base \n";}
    ~base(){cout << "destructor base \n";}
    void operator~(){cout << "operator ~ \n";}
};

class derived : public base
{
public:
    derived(){cout << "constructor derived \n";}
    ~derived(){base::~base();cout << "destructor derived \n";}
};

编译器版本信息：

g++.exe (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 8.1.0
Copyright (C) 2018 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.

错误：

cmd /c chcp 65001>nul && C:\mingw64\bin\g++.exe -fdiagnostics-color=always -g "D:\Valkyrie-text\simple text\text.cpp" -o "D:\Valkyrie-text\simple text\text.exe"
D:\Valkyrie-text\simple text\text.cpp: In destructor 'derived::~derived()':
D:\Valkyrie-text\simple text\text.cpp:15:28: error: no matching function for call to 'derived::~derived()'
     ~derived(){base::~base();cout << "destructor derived \n";}
                            ^
D:\Valkyrie-text\simple text\text.cpp:7:5: note: candidate: 'base::~base()'
     ~base(){cout << "destructor base \n";}
     ^
D:\Valkyrie-text\simple text\text.cpp:7:5: note:   candidate expects 1 argument, 0 provided

在 C++ 中，为什么派生类不能不使用范围解析运算符而直接显式地调用其基类的析构函数？

我听说在C++中，所有的析构函数都会被编译器处理成“destructor”，也就是说基类和派生类的析构函数同名，从而导致重定义（隐藏）。

这是正确的吗？

#include <iostream>
 
struct base {
    base() { std::cout << "base default \n"; }
    ~base() { std::cout << "~base \n"; }
};
 
struct derived : base {
    derived() { std::cout << "derived default \n"; }
    ~derived()
    {
        //~base();No
        base::~base();
        std::cout << "~derived \n";
    }
};

我知道在实践中几乎没有必要这样做，我只是想了解原理......

我很难理解这两种说法之间是否真的有区别：

Image->Picture->Bitmap = bitmap;  // bitmap is a TBitmap object
Image->Picture->Assign(bitmap);

VCL 帮助清楚地说明了通过以下方式进行分配=：

注意：在分配 Bitmap 属性时，TPicture 会分配另一个 TBitmap 对象的属性。它不会获取指定值的所有权。

这意味着第一个语句不会将位图复制到 中，而只是接管Image->Picture->Bitmap的地址。bitmapImage->Picture->Bitmap

为什么我删除了位图Image->Picture->Bitmap对象后，图片仍然正确显示在屏幕上？

在阅读了不少关于联合体用途和类型双关（基本上是不允许的，你应该依赖编译器优化 memcpy 调用）的文章后，我想知道以下联合体用法是否完全不安全，或者它是否完全是未定义行为，或者它实际上是否完全符合联合体规范且安全。其理念是，底层数据都属于相同的基本类型（int、double 等），但我只是想看看它是如何以不同的方式布局或命名的。我或许应该称之为“容器双关”，而不是“类型双关”。

// main.cpp
// compile with `c++ main.cpp -std=c+23`

#include <iostream>
#include <array>
#include <format>


struct Mat2 {
  union {
    std::array<float, 4> data;
    std::array<std::array<float, 2>, 2> rows;
    struct { float x, y, z, w; };
  };
};


int main() {

  // sometimes you want to think about it in rows
  Mat2 m{ .rows = {{ {0, 1},
                     {2, 3} }}};

  for (auto &row : m.rows) {
    for (auto &col : row) {
      std::cout << col << " ";
    }
    std::cout << "\n";
  }

  // sometimes you want to think about it as a block of data
  std::cout << "\n";
  for (auto &d : m.data) {
    std::cout << d << " ";
  }
  std::cout << "\n\n";

  // sometimes you want to access elements based on sematic names
  std::cout << std::format("{}, {}, {}, {}", m.x, m.y, m.z, m.w);
  std::cout << std::endl;

}

我想要查看输入流中的字符：

    auto input = std::stringstream{"abcd"};
    using Iter = std::istreambuf_iterator<char>;
    auto s = std::ranges::subrange{Iter{input}, Iter{}};

到目前为止一切顺利。现在，我转换该视图（为了简单起见，使用身份转换）：

    auto t = s | std::views::transform(std::identity{});

尽管这个转换后的观点是有效的value_type（即这个断言通过了）：

    using T = decltype(t);
    static_assert(std::is_same_v<char, std::ranges::range_value_t<T>>);

它的迭代器类型没有：

    static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<T>>::value_type>);

这失败了

view.cc: In function 'int main()':
view.cc:27:90: error: 'value_type' is not a member of 'std::iterator_traits<std::ranges::transform_view<std::ranges::subrange<std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ranges::subrange_kind::unsized>, std::identity>::_Iterator<false> >'
   27 |     static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<T>>::value_type>);
      |                                                                                          ^~~~~~~~~~
view.cc:27:100: error: template argument 2 is invalid
   27 |     static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<T>>::value_type>);
      |                   

它对我很重要的原因是我想在下游视图适配器中使用迭代器特征。

调查表明，Transform 视图的迭代器缺少其iterator_category成员。当我传递一个功能更强大的范围（例如，传递给 Transform 的范围）时，代码会成功，std::string但传递这个非前向范围时会失败。

完整代码（也在Compiler Explorer 上）：

#include <functional>
#include <iterator>
#include <ranges>
#include <sstream>
#include <string>
#include <type_traits>

int main()
{
#ifdef PASS
    auto input = std::string{"abcd"};
    std::ranges::forward_range auto s = std::ranges::subrange(input.begin(), input.end());
#else
    auto input = std::stringstream{"abcd"};
    using Iter = std::istreambuf_iterator<char>;
    std::ranges::input_range auto s = std::ranges::subrange{Iter{input}, Iter{}};
#endif

    using S = decltype(s);
    static_assert(std::is_same_v<char, std::ranges::range_value_t<S>>);
    static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<S>>::value_type>);

    auto t = s | std::views::transform(std::identity{});
    using T = decltype(t);
    static_assert(std::is_same_v<char, std::ranges::range_value_t<T>>);
    static_assert(std::is_same_v<char, std::ranges::iterator_t<T>::value_type>);
    static_assert(std::is_base_of_v<std::input_iterator_tag, std::ranges::iterator_t<T>::iterator_category>);
    static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<T>>::value_type>);
}