限制函子参数类型和常量
Restrict functor parameter type and constness
我正在尝试实现一个资源保护类，它将数据与共享互斥锁(实际上，QReadWriteLock，但它是相似的)结合起来。类必须提供在获取锁时对数据应用用户定义函数的方法。我希望这个应用方法根据函数参数(引用，const引用或值)不同地工作。例如，当用户传递一个像int (const DataType &)这样的函数时，它不应该独占阻塞，因为我们只是在读取数据，相反，当函数具有像void (DataType &)这样的签名时，意味着数据修改，因此需要独占锁。
template <typename T>
class Resource1
{
public:
template <typename Result>
Result apply(std::function<Result(T &)> &&f)
{
QWriteLocker locker(&this->lock); // acquire exclusive lock
return std::forward<std::function<Result(T &)>>(f)(this->data);
}
template <typename Result>
Result apply(std::function<Result(const T &)> &&f) const
{
QReadLocker locker(&this->lock); // acquire shared lock
return std::forward<std::function<Result (const T &)>>(f)(this->data);
}
private:
T data;
mutable QReadWriteLock lock;
};
但是std::函数似乎没有限制参数的稳定性，所以std::function<void (int &)>可以很容易地接受void (const int &)，这不是我想要的。在这种情况下，它也不能推断lambda的结果类型，所以我必须手动指定它:
Resource1<QList<int>> resource1;
resource1.apply<void>([](QList<int> &lst) { lst.append(11); }); // calls non-const version (ok)
resource1.apply<int>([](const QList<int> &lst) -> int { return lst.size(); }); // also calls non-const version (wrong)
我第二次尝试使用std::result_of并返回类型SFINAE:
template <typename T>
class Resource2
{
public:
template <typename F>
typename std::result_of<F (T &)>::type apply(F &&f)
{
QWriteLocker locker(&this->lock); // lock exclusively
return std::forward<F>(f)(this->data);
}
template <typename F>
typename std::result_of<F (const T &)>::type apply(F &&f) const
{
QReadLocker locker(&this->lock); // lock non-exclusively
return std::forward<F>(f)(this->data);
}
private:
T data;
mutable QReadWriteLock lock;
};
Resource2<QList<int>> resource2;
resource2.apply([](QList<int> &lst) {lst.append(12); }); // calls non-const version (ok)
resource2.apply([](const QList<int> &lst) { return lst.size(); }); // also calls non-const version (wrong)
主要发生相同的事情:只要对象是非const，则调用apply的可变版本，并且result_of不限制任何内容。
有办法做到这一点吗?
您可以这样做
template <std::size_t N>
struct overload_priority : overload_priority<N - 1> {};
template <> struct overload_priority<0> {};
using low_priority = overload_priority<0>;
using high_priority = overload_priority<1>;
template <typename T>
class Resource
{
public:
template <typename F>
auto apply(F&& f) const
// -> decltype(apply_impl(std::forward<F>(f), high_priority{}))
{
return apply_impl(std::forward<F>(f), high_priority{});
}
template <typename F>
auto apply(F&& f)
// -> decltype(apply_impl(std::forward<F>(f), high_priority{}))
{
return apply_impl(std::forward<F>(f), high_priority{});
}
private:
template <typename F>
auto apply_impl(F&& f, low_priority) -> decltype(f(std::declval<T&>()))
{
std::cout << "ReadLockn";
return std::forward<F>(f)(this->data);
}
template <typename F>
auto apply_impl(F&& f, high_priority) -> decltype(f(std::declval<const T&>())) const
{
std::cout << "WriteLockn";
return std::forward<F>(f)(this->data);
}
private:
T data;
};
Jarod给出了一个变通方法，但我将解释为什么不能通过这种常规方式实现。问题是:
- 当从非const对象调用时，重载解析更倾向于使用非const成员函数而不是const成员函数
- 这个签名
void foo(A&)可以接受的对象，void foo(const A&)也可以接受。后者的绑定集甚至比前者更广。
因此，要解决它，你必须在到达2点之前至少击败1点。正如贾罗德所做的那样。
从你的签名(见我的注释注释):
template <typename F>
typename std::result_of<F (T &)>::type apply(F &&f) //non-const member function
{
return std::forward<F>(f)(this->data);
}
template <typename F>
typename std::result_of<F (const T &)>::type apply(F &&f) const //const member function
{
return std::forward<F>(f)(this->data);
}
当你这样称呼它时:
resource2.apply([](QList<int> &lst) {lst.append(12); }); //1
resource2.apply([](const QList<int> &lst) { return lst.size(); }); //2
首先，请记住resource2不是const的引用。因此，apply的non-const成员函数将始终是重载解析的首选。
现在，以第一次调用//1为例，不管lambda是用什么对象调用的，那么第二个也可以用那个对象
你要做的事情的简化模型是:
struct A{
template<typename Func>
void foo(Func&& f); //enable if we can call f(B&);
template<typename Func>
void foo(Func&& f) const; //enable if we can call f(const B&);
};
void bar1(B&);
void bar2(const B&);
int main(){
A a;
a.foo(bar1);
a.foo(bar2);
//bar1 and bar2 can be both called with lvalues
B b;
bar1(b);
bar2(b);
}
根据我的理解，您需要区分一个参数是接受const引用的std::function，还是非常量引用。
下面基于sfinae的方法似乎可以工作，使用一个助手专门化类:
#include <functional>
#include <iostream>
template<typename ...Args>
using void_t=void;
template<typename Result,
typename T,
typename lambda,
typename void_t=void> class apply_helper;
template <typename T>
class Resource1
{
public:
template <typename Result, typename lambda>
Result apply(lambda &&l)
{
return apply_helper<Result, T, lambda>::helper(std::forward<lambda>(l));
}
};
template<typename Result, typename T, typename lambda, typename void_t>
class apply_helper {
public:
static Result helper(lambda &&l)
{
std::cout << "T &" << std::endl;
T t;
return l(t);
}
};
template<typename Result, typename T, typename lambda>
class apply_helper<Result, T, lambda,
void_t<decltype( std::declval<lambda>()( std::declval<T>()))>> {
public:
static Result helper(lambda &&l)
{
std::cout << "const T &" << std::endl;
return l( T());
}
};
Resource1<int> test;
int main()
{
auto lambda1=std::function<char (const int &)>([](const int &i)
{
return (char)i;
});
auto lambda2=std::function<char (int &)>([](int &i)
{
return (char)i;
});
auto lambda3=[](const int &i) { return (char)i; };
auto lambda4=[](int &i) { return (char)i; };
test.apply<char>(lambda1);
test.apply<char>(lambda2);
test.apply<char>(lambda3);
test.apply<char>(lambda4);
}
const T &
T &
const T &
T &
专门化类中的helper()静态类现在可以修改为接受this参数，然后使用它蹦蹦跳地返回到原始模板的类的方法中。
只要lambda的捕获列表是空的，您就可以依赖这样一个事实，即这样的lambda衰减为函数指针。
区分这两种类型就足够了。
它遵循一个最小的工作示例:
#include<iostream>
template <typename T>
class Resource {
public:
template <typename Result>
Result apply(Result(*f)(T &)) {
std::cout << "non-const" << std::endl;
return f(this->data);
}
template <typename Result>
Result apply(Result(*f)(const T &)) const {
std::cout << "const" << std::endl;
return f(this->data);
}
private:
T data;
};
int main() {
Resource<int> resource;
resource.apply<void>([](int &lst) { });
resource.apply<int>([](const int &lst) -> int { return 42; });
}
相关文章：
- 我想将一个对T类型的非常量左值引用绑定到一个T类型的临时值
- 不能在初始值设定项列表中将非常量表达式从类型 'int' 缩小到'unsigned long long'
- 私有类型的静态常量成员
- 递归模板化函数不能分配给具有常量限定类型"const tt &"的变量"state"
- 是否有内置方法可以强制转换为不同的基础类型，但保留常量限定符?
- 从 BubbleSort* 类型的右值初始化 'AssortedSorter&' 类型的非常量引用无效"
- 常量函数，当其参数是对文字类型的引用时
- 错误:请求从"常量字符 [5]"转换为非标量类型"字符串"
- 为什么"具有常量成员的结构"类型的指针不能指向"具有非常量成员的结构"？
- 常量成员函数中成员变量的类型
- 无法将类型"T&"的非常量左值引用绑定到类型"T"的右值 t++ std：：atomic<T>
- 从 Typedef 数据类型中删除常量
- 为什么定义复制构造函数会给我错误：无法将类型 'obj&' 的非常量左值引用绑定到类型为"obj"的右值？
- 将整型常量映射到类型
- 我正在将一个 std：：string 传递给一个 boost 函数，该函数对该类型进行常量引用，但该值发生了变化
- 对于非常量指针类型的参数，未调用具有常量指针模板类型参数的功能
- 为什么我总是收到此错误：从类型为"农场动物"的右值初始化类型的非常量引用无效|
- 输入参数类型"常量双 *&"是什么意思？
- 从何处获取设备类型常量描述
- 在标头中使用类型常量作为数组大小C++
