主页 / user-21804960

SpeakX's questions

Martin Hope
SpeakX
Asked: 2024-08-23 22:09:42 +0800 CST
  • 9

我正在查看cppreference，但没有看到有关执行循环顺序的任何信息。

我的问题是：当调用时，std::ranges::any_of我data.begin(), data.end() 是否确定它会按顺序从到进行begin()并且end()停止一次true？

c++
Martin Hope
SpeakX
Asked: 2024-08-16 02:45:00 +0800 CST
  • 6

查看文档，我不明白为什么std::make_format_args()采用引用而不是 const 引用？

我的目标是实现类似以下的事情：

#include <format>

template <class... Args>
inline static std::string format(const std::string_view field, Args&&... args)
{ 
    return std::vformat(field, std::make_format_args(std::forward<Args>(args)...)); 
}

并且能够const std::string&作为输入传递args，但它似乎std::make_format_args()需要一个非常量引用。

我收到一个错误：

A non-const reference may only be bound to an lvalue C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.40.33807\include\format(3713): note: see declaration of 'std::make_format_args'
note: while trying to match the argument list '(_Ty, const std::string, _Ty, _Ty)'

更新

我可以在这里重现该错误：https://godbolt.org/z/nj763o48r（在本地我得到与上述完全相同的错误）

c++
Martin Hope
SpeakX
Asked: 2024-03-02 08:14:13 +0800 CST
  • 8

我使用perform_mappingfrom link作为here link，但出现编译错误。

#include <string>
#include <tuple>
#include <utility>
#include <string>
#include <type_traits>

namespace details
{
    template <typename Tuple, typename Mapping>
    struct return_type;
    
    template <template <typename ...> typename Tuple, typename ... Types, typename Mapping>
    struct return_type<Tuple<Types...>, Mapping>
    {
        //I changed the below line from what is in the link
        using type = Tuple<decltype(std::invoke_result<Mapping, Types>())...>;
    };
    template <template <typename, std::size_t> typename Array, typename T, std::size_t Size, typename Mapping>
    struct return_type<Array<T, Size>, Mapping>
    {
        using type = Array<std::invoke_result_t<Mapping, T>, Size>;
    };
    
    template <typename Tuple, typename Mapping>
    using return_type_t = typename return_type<Tuple, Mapping>::type;
    
    template <typename Tuple, typename Mapping, std::size_t ... Indices>
    return_type_t<std::decay_t<Tuple>, std::decay_t<Mapping>> perform_mapping(Tuple&& tup, Mapping&& mapping, std::index_sequence<Indices...>)
    {
        return {mapping(std::get<Indices>(std::forward<Tuple>(tup)))...};
    }
}

template <typename Tuple, typename Mapping, 
          std::size_t Size = std::tuple_size<std::decay_t<Tuple>>::value>
auto perform_mapping(Tuple&& tup, Mapping&& mapping)
{
    return details::perform_mapping(std::forward<Tuple>(tup), std::forward<Mapping>(mapping), std::make_index_sequence<Size>{});
}

struct A
{
    A(double z) : x(z){}; 
    double x;
    using Type = double;
};

struct B
{
    B(std::string s) : x(std::move(s)) {}
    std::string x;
    using Type = std::string;
};

struct C
{
    C() : m_tuple({A(1.0), B("A")})
    {
    }

    template<class T>
    typename T::Type f(T& z)
    {
        return z.x;
    }

    std::tuple<A::Type, B::Type> get()
    {
        return perform_mapping(m_tuple, [this](auto& z) { return this->f(z); });
    }

    std::tuple<A, B> m_tuple;
};

int main()
{
    C c;
    auto t = c.get();
};

我的问题是：我可以perform_mapping按照上面的代码的方式实现吗？

c++
Martin Hope
SpeakX
Asked: 2024-02-26 06:56:30 +0800 CST
  • 4

有没有办法通过包含基本结构成员变量来使用大括号初始化子结构。我正在尝试以下操作，但无法编译（使用 VS 和 C++ 20）。我不想创建构造函数，而是想使用单行构造。

struct Base
{
    int n;
};

struct Derived : Base
{
    std::string s;
};

static const Derived d1{ .s = "Hi", { .n = 1 } }; //fails to compile
static const Derived d2{ 1, { "Hi" } };           //fails to compile
static const Derived d3{ 1, "Hi" };               //fails to compile
static const Derived d4(1, "Hi");                 //fails to compile

编辑：d4, d3实际上编译得很好。

c++
Martin Hope
SpeakX
Asked: 2024-01-22 20:23:25 +0800 CST
  • 4

客户端持有一个指向值 say 的共享指针double，服务器通过持有 a 在另一个分离线程上更新该值weak_pointer，服务器检查该值是否weak_pointer过期，如果未过期，则从安全向量中删除它。我怀疑这不起作用，因为在我的读取（我认为它是线程安全的，因为我想象它指的是 的原子计数器）和我的值更新之间shared_ptr可能会从客户端被破坏。有没有办法让检查和函数在破坏之前更新值？我是说：expired()shared_ptrexpired()lambda

struct server
{
public:
    static void subscribe(const std::shared_ptr<double>& d)
    {
        m_values.safe_push_back(d); //safely pushes back in the vector
    }

    void update()
    {
        auto updater = [](std::weak_ptr<double>& wd)
        {
            if(wd.expired()) wd = nullptr;
            else *wd += 2.0; //This is not thread safe I guess?
        };
        m_values.safe_remove_all(nullptr);
        m_values.safe_visit(updater);
    };

private:
    static safe_vector<std::weak_ptr<double>> m_values;
}

struct client
{
    void subcribe_sleep_print(const double random_seconds)
    {
        std::shared_ptr<double> d = std::make_shared<double>(0.0); //for the sake of the example assume we create subscribe before sleep
        server::subscribe(d);
        sleep_for_seconds(random_seconds); //sleeps for some random time in seconds.
        std::cout << *d << std::endl;
    }
}

想象一下server::update和client::subcribe_sleep_print正在不同的线程上运行。这不安全，因为shared_ptr服务器写入时可能会被破坏？有没有办法在没有用户（我）定义的原子或互斥体的情况下实现这一点？我不介意它是否在后台使用，只要我自己不添加它们（原子/互斥），因为我知道共享指针已经使用原子计数器。

编辑：我没有在程序中使用 double，我使用的是线程安全对象:) 因此操作 += 可以假定为线程安全。对不起。

c++
Martin Hope
SpeakX
Asked: 2024-01-10 06:02:40 +0800 CST
  • 8

上下文：我有一个队列，支持来自两个不同（/或非）线程的单读/单写，为了强制执行此行为，即一次单读/单写，我需要限制拥有的线程数量队列一次为2（作者已经拥有该队列），我当时正在考虑为队列创建一个shared_ptr，并将编译时已知的最大引用计数设置为2。因此我的问题如下。

问题：有没有一种方法可以实现unique_pointer具有编译时已知的最大引用计数的共享指针（可能使用 's）？我的情况是max_ref_count = 2，超过引用计数限制 = 2 应该是编译时错误。

const auto p    = std::make_shared<2, double>(2159); //works fine
const auto q    = p; // works fine
const auto err1 = p; // does not compile
const auto err2 = q; // does not compile
c++
Martin Hope
SpeakX
Asked: 2024-01-03 01:25:09 +0800 CST
  • 6

我想构造一个类型，它是具有不同模板参数类型的同一类的元组。我是说：

想象一下我们有一堂课

template<class Arg>
class A
{
    //.... details
}

我想定义类似的东西：

template<class... Args>
struct construct_tuple 
{
    //assume I can access Args[...]
    using type = std::tuple<A<Args[0]>, A<Args[1]>, ..., A<Args[n]>>;
}

能否请你帮忙？

我相信可能有一个解决方案，通过迭代可变参数并使用元组类型之间的串联或者使用其他一些 TMP 例如std::enable_if或std::conditional_t。

c++