小编Ran*_*tep的帖子

C++20 引入了std::span，它是一个类似视图的对象，可以接受连续序列，例如 C 风格的数组、std::array、 和std::vector。C 风格数组的一个常见问题是在传递给函数时它会衰减为指针。这样的问题可以通过使用来解决std::span：

size_t size(std::span<int> s)
{
    return s.size();
}

int main()
{
    std::array arr = {1,2,3,4,5};
    std::vector vec = {1,2,3,4,5};
    auto il = {1,2,3,4,5};
    int c_arr[] = {1,2,3,4,5};
    std::cout << size(arr) << size(vec) << size(il) << size(c_arr);
}

正如预期的那样，这将打印出来5555。然而，size可能不应该只接受int. 相反，它应该容纳任何类型的容器。但是，将 更改size为接受 a 的模板化函数后std::span<T>，它无法再成功替换 C 样式数组，而其他函数则可以：

template<typename T>
size_t size(std::span<T> s)
{
    return s.size();
}

int main()
{
    std::array …

我想知道通过使用转换string为使其与 switch 一起工作是否不会影响程序的行为。我使用字符串是因为我正在通过为此方法使用 asci 表来验证用户输入，但未包含在此代码中以使其简短。intstoi>= 48 && <= 57

编码：

    do
       {
          cout << "Choice: ";
          string userChoice;
          cin >> userChoice;
          isValid = validNum(userChoice);
          if(isValid)
          {
             int intUserchoice = stoi (userChoice);
             switch(intUserchoice)
             {
             case 1:
                ServerStart();
             }
          }
       }while (!isValid);

正如标题所建议的，我应该如何在 macOS 上禁用 SwiftUI 2 的全屏按钮？

我能找到的唯一信息似乎使用了NSWindow. SwiftUI 2 中有没有一种原生方法可以做到这一点？

我正在编写一个额外的菜单栏，它会向您显示已安装的应用程序的列表，并允许您单击列表中的每个按钮来打开该应用程序。显然，要做到这一点，我需要用户拥有的每个应用程序的列表。我选择执行此操作的具体方法是创建一个函数，该函数将循环遍历系统的应用程序文件夹中的文件，删除应用程序内容中的任何内容或不以 .app 结尾的内容，并返回包含文件列表的数组作为名称，然后对其进行迭代以创建用户可以单击以启动应用程序的“应用程序按钮”列表。

我的函数的代码是

func enumerateAppsFolder() -> Array<String> {
    var fileNames:Array<String> = []
    
    let fileManager = FileManager.default
    let enumerator:FileManager.DirectoryEnumerator = fileManager.enumerator(atPath:"/Applications/")!
    
    while let element = enumerator.nextObject() as? String {
        if element.hasSuffix("app") && !element.contains("Contents") { // checks the extension
            fileNames.append(element)
        }
    }
    return fileNames
}

我创建我的列表

ForEach(enumerateAppsFolder(), id:\.self){
    AppBarMenuItem(itemAppName: $0)
}

但当我这样做时，结果是我所期望的，但表现却很糟糕。这可以在屏幕截图中看到，并且某些人的系统上较大的应用程序文件夹会使情况变得更糟 （当应用程序启动时，大约需要 5 分钟，CPU 和磁盘使用率也非常高）是否有更好更快的方法来检索系统上的每个应用程序，类似于 macOS 启动板或“Open With”。 。“ 列表？

最近，我对在浮点数上使用位移位进行一些快速计算很感兴趣。

为了让它们以更通用的方式工作，我想让我的函数使用不同的浮点类型，可能是通过模板，不仅限于floatand double，还有“半宽”或“四倍宽”浮点数等等.

然后我注意到：

 - Half   ---  5 exponent bits  ---  10 signicant bits
 - Float  ---  8 exponent bits  ---  23 signicant bits
 - Double --- 11 exponent bits  ---  52 signicant bits

到目前为止，我认为exponent bits = logbase2(total byte) * 3 + 2，
这意味着 128 位浮点数应该有 14 个指数位，而 256 位浮点数应该有 17 个指数位。

然而，后来我了解到：

 - Quad   --- 15 exponent bits  ---  112 signicant bits
 - Octuple--- 19 exponent bits  ---  237 signicant bits

那么，有没有一个公式可以找到它？或者，有没有办法通过一些内置函数来调用它？
C 或 …

假设我有一个模板化类Wrapper，有没有办法创建一个类型别名模板，自动Wrapper <T>从 的容器推导出 的容器T，以便：

• alias(Wrapper, vector<int>)会成为vector<Wrapper<int>>
• alias(Wrapper, map<int, string>)会成为map<Wrapper<int>, Wrapper<string>>
• alias(Wrapper, array<int, 10>)会成为array<Wrapper<int>, 10>

到目前为止，我最好的尝试是：

template<template<typename> typename U, template<typename...> typename Container, typename ...T>
using alias = std::remove_cvref_t<decltype(std::declval<Container<U<T>...>>())>;

但有两个问题：

1. 必须使用如下语法来调用它：这个版本需要被称为（这并不理想）：alias(vector, Type)和alias(map, Key, Value)。alias(vector<Type>)如果可能的话，我很乐意使用alias(map<Key, Value>)。

2. 它不兼容，std::array因为 的第二个模板参数array不是size_t类型。我想我可以创建第二个类型别名并根据容器类型调用相应的别名，但我宁愿不必这样做。

在 C++20 之前执行此操作的一种简单方法是执行嵌套循环：

template<typename Container>
constexpr bool has_duplicate(Container&& container)
{
    for (auto it1 = container.cbegin(); it1 != container.cend(); ++it1)
        for(auto it2 = container.cbegin(); it2 != it1; ++it2)
            if (*it1 == *it2)
                return 1;
    return 0;
}

通过在基于范围的 for 循环中添加 init 语句，并引入ranges::subrange，我相信这个函数可以用基于范围的 for 循环重写：

template<std::ranges::input_range Container>
constexpr bool has_duplicate(Container&& container)
{
    for(auto it = container.cbegin(); const auto& obj1 : container)
        for(const auto& obj2 : std::ranges::subrange(container.cbegin(), it++))
            if(obj1 == obj2) 
                return 1;
    return 0;
}

虽然它在 gcc 上运行良好，但无法使用 clang 进行编译，除非我使用 …

每当纯右值作为需要该操作数的泛左值的运算符的操作数出现时，就会应用临时具体化转换来将表达式转换为 xvalue。

_{来源：https://eel.is/c++draft/basic.lval#7}

为什么5 = 6格式不正确？它不应该执行临时物化转换并创建可分配的临时对象吗？

class Component {
    // Code here
};

class TransformComponent : public Component {
    // Code here
};

class Entity:
    public:
        Component components[25];
        
        TransformComponent *getTransform() {
            for(int i = 0; i < 25; i++) {
                if(typeid(components[i]) == typeid(TransformComponent())) {return *(components + i);}
            }
        }
};

我有一个组件数组，里面可以是“Component”的任何子类，例如“TransformComponent”。问题是，在编译时，计算机认为组件数组仅填充有“Component”对象。该函数应该返回一个“TransformComponent”，编译器将其视为错误，即使我返回的数组中的元素是 TransformComponent。有没有办法解决这个问题（最好是简单的）？

我对 C++ 编程非常陌生。我想将枚举类型的元素插入到vector<uint8_t>? std::vector <ValType> call即追加到 的所有元素std::vector<uint8_t> bravo 。有什么办法可以做到这一点吗？

#include <stdio.h>
#include <vector>
#include <cstdint>

enum class ValType : uint8_t
{

    Working = 1,
    Failed = 0,
    Freezed = 0

};

int main()
{
    std::vector<uint8_t> bravo = {23, 23, 23, 22, 5};
    std::vector<ValType> call;
    bravo.insert(bravo.end(), call.begin(), call.end());

    return 0;
}

住在这里

我在编译时遇到错误：

   In file included from c:\program files (x86)\mingw-w64\i686-8.1.0-posix-dwarf-rt_v6-rev0\mingw32\include\c++\11.2.0\vector:66,
                 from custom.cpp:2:
c:\program files (x86)\mingw-w64\i686-8.1.0-posix-dwarf-rt_v6-rev0\mingw32\include\c++\11.2.0\bits\stl_uninitialized.h: In instantiation of '_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = __gnu_cxx::__normal_iterator<ValType*, …

我正在尝试默认初始化一个配置结构，该结构由一些字段组成，其中包括另一个从属配置结构 - 使用宏：

现场演示

#include <cstdio>

#define MYCLASS_DEFAULT_CONFIG mylib::options { \
    .a_ = 2, \
    .b_ = 3, \
    .subopts_ = MYCLASS_DEFAULT_SUBOPT_CONFIG() \
}

#define MYCLASS_DEFAULT_SUBOPT_CONFIG mylib::sub_options { \
    .c_ = 'A'; \
    .d_ = 'H'; \
}


namespace mylib
{
    struct sub_options
    {
        char c_;
        char d_;
    };

    struct options
    {
        int a_;
        int b_;
        sub_options subopts_;
    };


    class myclass
    {
        myclass(options opts)
            : opts_ { opts }
        {
            
        }

        options opts_;
    };
}

int main()
{
    mylib::myclass some_class(MYCLASS_DEFAULT_CONFIG()); …

我有这个练习，其中我们使用模板类尝试右值和左值引用的各种组合，我收到两个断言错误；如果有人可以指导的话。

#include <assert.h>

typedef int& IntLRef;
typedef IntLRef& IntLLRef;
typedef IntLRef&& IntLRRef;

typedef int&& IntRRef;
typedef IntRRef& IntRLRef;
typedef IntRRef&& IntRRRef;

template<typename T, typename U>
struct IsSameType
{
  static const bool value = false;
};

template<typename T>
struct IsSameType <T, T>
{
    static const bool value = true;
};
static_assert(IsSameType<IntLRef, IntLLRef>::value, "LRef DIF LLRef"); static_assert(IsSameType<IntLRef, IntLRRef>::value, "LRef DIF LRRef"); static_assert(IsSameType<IntLLRef, IntLRRef>::value, "LLRef DIF LRRef");

static_assert(IsSameType<IntRRef, IntRLRef>::value, "RRef DIF RLRef"); static_assert(IsSameType<IntRRef, IntRRRef>::value, "RRef DIF RRRef"); static_assert(IsSameType<IntRLRef, IntRRRef>::value, "RLRef DIF RRRef");

int …