小编And*_*joe的帖子

有没有办法实现自定义类型限定符(类似于const)？我想只允许函数调用具有相同资格的函数中具有相同资格的函数.

假设我会:

void allowedFunction();
void disallowedFunction();

//Only allowed to call allowed functions.
void foo()
{
    allowedFunction();
    disallowedFunction(); //Cause compile time error
}

//Is allowed to call any function it wants.
void bar()
{
    allowedFunction();
    disallowedFunction(); //No error
}

我想这样做的原因是因为我想确保在特定线程上调用的函数只调用实时安全函数.由于许多应用程序需要硬实时安全线程,因此在编译时使用某种方法检测锁定将保证我们不会发生许多难以检测的运行时错误.

对于可选的内部内容，可选是否需要放置新的内容才能重建内部就地存储或联合？是否有一些新功能（例如 C++ 20 中的placement new）允许 std::Optional 的 constexpr 赋值？

template< class U = T >
optional& operator=( U&& value );
(since C++17)
(until C++20)
template< class U = T >
constexpr optional& operator=( U&& value );
(since C++20)

由于将概念定义为编译时谓词，是否还可以将这些谓词实际重用于编译时算法？例如，可以检查元组中的所有类型是否都符合概念？据我所知，不可能以任何方式将概念传递给函数，这使我重新回到在这些情况下使用模板。

#include <type_traits>

template<typename T>
concept FloatLike = std::is_same_v<T, float>;

struct IsFloat
{
    template<typename U>
    constexpr static bool test()
    {
       return FloatLike<U>;
    }
};


template<typename Predicate, typename... T>
constexpr bool all_types()
{
    return (Predicate::template test<T>() && ...);
}


int main()
{
   static_assert(all_types<IsFloat, float, float>());
   static_assert(!all_types<IsFloat, float, int>());
}

我想做的就是这样，所以我不必一直包装这个概念就可以使用它：

template<concept Predicate, typename... T>
constexpr bool all_types()
{
    return (Predicate<T> && ...);
}


int main()
{
   static_assert(all_types<FloatLike, float, float>());
   static_assert(!all_types<FloatLike, float, int>());
}

有什么办法可以做到这一点？

Why does the following code compile?

#include <memory>
#include <vector>

int main()
{
    std::vector<std::unique_ptr<int>> uncopyableStuff;
    for(int i = 0; i < 5; ++i)
        uncopyableStuff.emplace_back(std::make_unique<int>(i));
    auto lambda = [uncopyableStuff = std::move(uncopyableStuff)](){};
    static_assert(std::is_copy_constructible<decltype(lambda)>::value);
}

It seems to me that lambda is uncopyable, because when I try to copy it like:

auto copy = lambda;

这给了我一个编译错误（正如我所期望的）。lambda和副本可构造性特征是否有例外？

请参阅链接以获取Godbolt示例：https ://godbolt.org/z/GByclH

编辑：

查找尝试复制时lambda是否将编译的正确方法是什么？我对我对给定可调用对象的理论副本可构造性不感兴趣，但对成功复制构造的发现不感兴趣。对我来说，向量复制构造函数是用这种方式定义的，这仍然让我感到很奇怪。

所有std :: span的构造函数都声明为constexpr，但是我似乎无法在constexpr上下文中使用它们中的任何一个。取消注释以下任何constexpr都将导致编译错误。

#include <array>
#include <span>

int main()
{
    constexpr int carray[3] = { 0, 1, 2 };
    constexpr std::array<int, 3> array{ 0, 1, 2 };
    using S = std::span<const int, 3>;

    /*constexpr*/ S span1{ array.data(), 3 };
    /*constexpr*/ S span2{array.begin(), array.end()};
    /*constexpr*/ S span3{carray};
    /*constexpr*/ S span4{array};
}

实际上是否可以创建constexpr span类型，因为似乎构造函数在必须初始化指针或引用时永远无法在编译时求值吗？

有没有办法只为基本类型制作模板专业化？我试图做以下事情:

template<typename T, typename = typename std::enable_if<!std::is_fundamental<T>::value>::type>
class foo
{
}

template<typename T, typename = typename std::enable_if<std::is_fundamental<T>::value>::type>
class foo
{
}

但我收到一个错误,模板已经定义.

How does one filter duplicate types from a tuple?

For example:

using Tuple = std::tuple<int, double, int, double, std::string, std::string>
using FilteredTuple = without_duplicates<Tuple>;

In which without_duplicates is implemented in such a way that it generates the following FilteredTuple type:

std::tuple<int, double, std::string>

假设我有一堂课

enum CallbackType
{
    SYNC,
    ASYNC
}


template<CallbackType CB = SYNC, typename... Args>
class Callback
{
}

我希望能够选择特定的回调类型,同时仍然能够拥有可变参数模板参数.现在我明白编译器不能区分它们,但也许有一些方法可以处理第一个模板参数是CallbackType的特定情况？

Callback<int int> //Should be Callback<SYNC, int, int>
Callback<ASYNC, int, int> //Should be Callback<ASYNC, int, int>

我知道这va_list通常是您应该避免的事情，因为它不是很安全，但是是否可以从如下函数传递参数：

void foo(...);

到一个函数

template<typename... Args>
void bar(Args... arguments);

?

编辑：最初我想尝试使用它来调用具有可变数量的参数/类型的虚函数，但这并不是使这个问题变得无关紧要的方法。最终我最终做了这样的事情：

struct ArgsPackBase
{
    virtual ~ArgsPackBase() {}
};

template<typename... Args>
struct ArgsPack : public ArgsPackBase
{
public:
    ArgsPack(Args... args_)
        : argsTuple(args_...)
    {}

    void call(std::function<void(Args...)> function)
    {
        callExpansion(function, std::index_sequence_for<Args...>{});
    }

private:
    template<std::size_t... I>
    void callExpansion(std::function<void(Args...)> function, std::index_sequence<I...>)
    {
        function(std::get<I>(argsTuple)...);
    }

    std::tuple<Args...> argsTuple;
};

有没有办法检查两个可变参数包的串联是否与第三个可变参数包相同.

template<typename... Args>
struct ClassOne
{
}

template<typename... Args>
struct ClassTwo
{
}

template<typename... Args>
struct ClassThree
{
}

template<typename... PackA, typename... PackB, typename... PackC>
void foo(ClassOne<PackA...>, ClassTwo<PackB...>, ClassThree<PackC...>)
{
}

如果PackA ... = PackB ...,PackC,我想foo​​才能启用...

由于array没有构造函数或析构函数，也没有公共的非静态成员变量，因此array如何允许花括号初始化？不允许尝试初始化以下类型：

template<typename T, std::size_t num>
class Array
{
    T data[num];
};

我如何以这种方式初始化该类型，而无需任何构造函数或析构函数就可以初始化该类型，以保持该类型易于构造和破坏，并且不暴露私有数组成员？

如何创建一个接受size_t但不接受int或任何其他隐式可转换类型的函数？

呼叫会_mm_load_ps传回__m128。在英特尔内部函数指南中，它说：

从内存将128位（由4个压缩的单精度（32位）浮点元素组成）加载到dst中。mem_addr必须在16字节边界上对齐，否则可能会生成常规保护异常。

（编者注：_mm_loadu_ps用于可能未对齐的负载）

这是否意味着只要__m128仍处于活动状态，这4个float包就驻留在xmm寄存器中？然后这是否意味着堆栈上的__m128数量多于可用的xmm寄存器会导致溢出？