未捕获lambda和函数指针作为重载函数歧义中的参数
是指在函数重载中，当函数的参数为lambda表达式或函数指针时，可能会出现函数调用的歧义问题。
Lambda表达式是一种匿名函数，可以在函数调用时直接定义和传递，常用于函数式编程和异步编程。函数指针是指向函数的指针变量，可以用于动态调用函数。
在函数重载中，当存在多个函数具有相同的函数名，但参数类型不同的情况下，编译器会根据传入的参数类型选择合适的函数进行调用。然而，当函数的参数包含lambda表达式或函数指针时，由于lambda表达式和函数指针的类型是不确定的，编译器无法确定应该调用哪个函数，从而产生了歧义。
为了解决这个问题，可以采取以下几种方法：
- 显式类型转换：通过将lambda表达式或函数指针转换为特定的函数类型，可以消除歧义。例如，可以使用static_cast将lambda表达式转换为特定的函数类型。
- 函数重命名：给具有相同函数名但参数类型不同的函数进行重命名，以避免歧义。通过修改函数名，可以明确指定要调用的函数。
- 函数模板：使用函数模板可以实现对不同参数类型的函数进行泛化处理，从而避免歧义。通过定义适当的函数模板，编译器可以根据传入的参数类型自动推导出要调用的函数。
总结起来，未捕获lambda和函数指针作为重载函数歧义中的参数时，可以通过显式类型转换、函数重命名或函数模板等方式来解决歧义问题。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数（云函数）：https://cloud.tencent.com/product/scf
- 腾讯云API网关：https://cloud.tencent.com/product/apigateway
- 腾讯云容器服务：https://cloud.tencent.com/product/ccs
- 腾讯云数据库（云数据库MySQL、云数据库MongoDB等）：https://cloud.tencent.com/product/cdb
- 腾讯云服务器（云服务器CVM）：https://cloud.tencent.com/product/cvm
- 腾讯云CDN加速：https://cloud.tencent.com/product/cdn
- 腾讯云安全产品（云防火墙、DDoS防护等）：https://cloud.tencent.com/product/ddos
相关·内容
下面的代码使用MSVC编译器在Visual 2017中进行编译，但无法在GCC或Clang中编译。
#include <iostream>
#include <functional>
void functionTest(std::function<void()>) {
std::cout << "F\n";
}
void functionTest(bool) {
std::cout << "B\n";
}
int main() {
functionTest([](){ st
浏览 6提问于2017-08-09得票数 4
回答已采纳
我在玩，研究它如何使用默认参数处理函数。令我惊讶的是，对于免费函数和operator()，结果是不同的。
template <typename F>
auto func(F f) -> decltype(f(42))
{
int a = 51;
return f(51);
}
template <typename F>
auto func(F f) -> decltype(f(42, 42))
{
int a = 0;
int b = 10;
return f(a, b);
}
int defaultFree(in
浏览 1提问于2018-09-17得票数 20
回答已采纳
3回答
我理解c++ 11中的lambda函数和它的用途，但我不明白“获取值”和“传递参数”之间的区别。例如..
#include <iostream>
#include <functional>
using namespace std;
int add(int a,int b){
return a+b;
}
int main(int argc, char** argv){
function <int(int,int)> cppstyle;
cppstyle = add;
auto l = [] (function <i
浏览 1提问于2015-06-25得票数 27
回答已采纳
考虑以下情况：
// utils.h
#include <string>
#include <list>
namespace Utils {
void do_something(int a, std::list<int> *b);
void do_something(int a, std::list<std::string> *b);
};
// utils.cpp
#include "utils.h"
void Utils::do_something(int a, std::list<int> *
浏览 4提问于2017-05-18得票数 2
回答已采纳
#include <functional>
void foo(std::function<void()> f) { f(); }
void foo(void (*f)()) { f(); }
int main ()
{
foo( [](){} );
}
VS编译，谁是对的？lambda应该是一个类类型，所以在它和函数指针之间不应该有任何转换。因此，VS似乎是正确的，克服了所有的困难。但也许我漏掉了什么。
除了将lambda转换为任一类型之外，有没有一种简单的方法来消除调用的歧义？
浏览 2提问于2013-07-21得票数 1
回答已采纳
2回答
我正在尝试创建一个'compose‘函数，返回作为参数给出的可调用对象的组合。
在数学中，它将如下所示：
F = h(g(f(x)))
下面是C++中的一个实现：
template <typename F>
auto compose(F&& f)
{
return[f = std::forward<F>(f)](auto&&... args){
return f(std::forward<decltype(args)>(args)...);
};
}
template <type
浏览 0提问于2020-09-13得票数 4
下面是官方网站c++的教程
在那里，提到lambda捕获不受支持，因为那里的编译器不支持std::function。但是，在2017年8月23日发布的4.1.0版本的中，有人提到他们增加了对lambda捕获的支持。
当我写这样的函数时
void CreateUserInFirebase(const std::string& Email, const std::string& Password)
{
auth->CreateUserWithEmailAndPassword(Email.c_str(), Password.c_str());
firebase
浏览 0提问于2019-01-28得票数 0
回答已采纳
在下面的代码中，对foo的第一个调用是不明确的，因此无法编译。
第二个，在lambda之前添加了+，解析为函数指针重载。
#include <functional>
void foo(std::function<void()> f) { f(); }
void foo(void (*f)()) { f(); }
int main ()
{
foo( [](){} ); // ambiguous
foo( +[](){} ); // not ambiguous (calls the function pointer overload)
}
+符号在这
浏览 32提问于2013-07-24得票数 104
回答已采纳
3回答
Lambda作为模板函数
、、、
我有一个非常奇怪的问题。
template<typename Func>
void foo(Func a, Func b)
{
std::cout << "good";
}
int myPutcharFunc(int)
{
return 0;
}
int main()
{
auto myPutcharLambda = [](int) -> int
{
return 0;
};
foo(putchar, myPutcharFunc); // okay
foo(putchar
浏览 0提问于2016-05-15得票数 4
因此，对于一个类，我有一个方法和它的重载，如下所示：
bool my_for_each(someIterator begin, someIterator end, bool (*_lambda)(someIterator));
void my_for_each(someIterator begin, someIterator end, void (*_lambda)(someIterator));
正如您所看到的，唯一的区别是传递函数的签名，即它的返回类型。尽管上面的代码在我调用它时运行得非常好：
my_for_each(iteratorBegin, iteratorEnd, [](some
浏览 1提问于2017-04-25得票数 1
回答已采纳
4回答
我最近看到了一段代码，看起来像这样：
static typename handle_set::iterator find(T* p)
{
return std::find_if(handles().begin(), handles().end(), [p](const std::unique_ptr<T,D>& l) { return l.get() == p; });
}
哪里
typedef typename std::set<std::unique_ptr<T,D>> handle_set;
浏览 2提问于2012-08-21得票数 2
回答已采纳
看看下面列出的代码示例，我用(使用gcc和clang)测试了它，并输出了(预期的) 200输出。
我想弄清楚的是:为什么这是有效的C++。或者不是？
这里，我使用using关键字来定义函数类型ft的别名(而不是typedef)，它描述了以int作为参数并返回int的函数(ft是函数类型，而不是函数指针类型！)。等效的typedef语法是typedef int ft(int);。由于C++标准规定，每个typedef都有一个使用using语法的等效表单，因此很明显，using ft = int(int)是一种定义良好的方法来指定此函数类型。
接下来是有趣的部分:我使用ft类型来指定另一个函数(p
浏览 14提问于2022-07-28得票数 3
回答已采纳
3回答
C++20是否允许非捕获λ作为非类型模板参数直接传递到函数指针？如果是的话，正确的语法是什么？
我使用-std=c++2a在clang和gcc的不同版本中尝试了以下代码。
#include <iostream>
template<auto f>
struct S {
static void invoke(int x) { f(x); }
};
using X = S<+[](int x) -> void { std::cout << x << " hello\n"; }>;
int main()
{
浏览 5提问于2020-01-16得票数 10
回答已采纳
2回答
我正在尝试构建一个泛型函数，它将异常转换为可选的：
template<typename Func, typename... Args>
auto get_opt(Func f, Args&&... args)
{
auto ret = std::experimental::optional<decltype(f(std::forward<Args>(args)...))>();
try
{
ret = f(std::forward<Args>(args)...);
}
cat
浏览 2提问于2014-12-29得票数 2
回答已采纳
3回答
C++λ捕获约束
、、
可以限制作为参数给定的lambda的捕获类型吗？
例如，是否可以只采用不会通过引用捕获任何内容的lambdas？
template <typename F>
void f(const F& lambda) // F must be a lambda that do not capture by ref
{
:::
}
浏览 0提问于2012-03-12得票数 6
回答已采纳
2回答
C++11中的函数签名差异
、、、、
考虑C++11的lambdas和下面的代码，
template <typename M>
void call(void (*f)(M), M m)
{
f(m);
}
int main()
{
call<int>([](int n) { }, 42); // OK
int r;
call<int>([&](int n) { r = n; }, 42); // KO
}
这两个lambda之间是否存在签名差异，使得第二个lambda与call的参数不兼容
我使用g++ 4.6.1。
次要问题:如果我写call([
浏览 0提问于2011-04-08得票数 6
回答已采纳
我不熟悉指向函数的指针，目前我正在做一些测试。但是在下面的程序中，我不明白为什么第一个版本可以工作，为什么第二个版本不能编译。正确的语法是什么？
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>
template<typename Type>
void display(const std::vector<Type>
浏览 0提问于2012-11-05得票数 1
回答已采纳
1回答
下面的代码无法编译( GCC和clang都说lambda不是一个正确的函数？)
#include <iostream>
using namespace std;
void apply(void f(int)) {
f(10);
f(20);
f(30);
}
int main()
{
int col = 42;
apply([col](int data) -> void {
cout << data << ' ' << col <<
浏览 0提问于2020-04-26得票数 0
有可能获得lambda调用操作符的地址吗？更重要的是:将这样的指针赋给一个公共指针，该指针可以指向具有相同捕获和相同调用参数的不同lambda？严格地说，将一个结果类分配给另一个结果类应该不是直接可行的，但您可能会使用一些肮脏的技巧并强制转换指针，这是可能的，因为(class1::*)( ... )类在理论上是可互换的。
那么，这方面的“正确”语法是什么呢？即使是一个肮脏的把戏。
不幸的是，下面代码的最后一行不起作用：
int main()
{
int i;
auto l100 = [&]()
{
i += 100;
};
usi
浏览 1提问于2021-04-03得票数 1
我尝试使用std::isgraph from <cctype>作为find_if中的谓词。但是编译器错误地说：
错误:对‘find_if( __gnu_cxx::__normal_iterator< const char*、std::basic_string< char> >、__gnu_cxx：：__normal_iterator< const char*、std::basic_string< char> >、<未解析重载函数type>)的调用没有匹配函数。
我使用过using namespace std;，据我
浏览 2提问于2015-11-25得票数 3
回答已采纳
1回答
这可能是个很棒的问题，但我自己想不出来。
因此，我试图将lambda传递到以下函数：
wiringPiISR(int pin, int mode, void (*function)())
..。其结果是：
wiringPiISR(Pin::BELL, INT_EDGE_RISING, [] {});
..。显然，我可以使用lambda而不是指向函数。
但是我实际上想要做的是这样做，通过捕获this来访问外部上下文中的函数onInterrupt(Pin pin)：
wiringPiISR(Pin::BELL_1, INT_EDGE_RISING, [this] {
onInterrup
浏览 9提问于2016-06-18得票数 0
回答已采纳
2回答
这段代码
int(&foo)(int, int) = [](int a, int b) { return a + b; };
不编译，因为很明显，非const引用不能用临时参数初始化。我把const放在哪里？
浏览 0提问于2019-07-01得票数 20
回答已采纳
为什么下面的代码不编译？为什么我必须告诉编译器，传递的函数指针返回一个双值？(如果显式调用call<double>()!)
template<typename T>
void call(T (*const _pF)(void))
{
}
int main(int, char**)
{ call(
[](void) -> double
{ return 1.0;
}
);
}
浏览 6提问于2022-02-18得票数 2
回答已采纳
请考虑以下例子：
#include <iostream>
#include <future>
std::size_t calc_something(std::size_t lim_)
{
std::size_t result = lim_ * 10;
return result;
}
void calc_something(std::size_t lim_, std::promise<std::size_t> &promise_)
{
std::size_t result = lim_ * 10;
pr
浏览 4提问于2020-02-03得票数 2
回答已采纳
1回答
C++ lambda回调
、、、
我正在尝试创建一个HTTP类，并且我想通过lambda使用C++11 (还不是C++14 )回调。我有2个模型可用，第一个工作…但看起来很丑陋。我的第二个目标，不是编译(最后的错误)。
我不能使用std::function，因为这是一个嵌入式项目，该模板会生成大量代码。
#include <cstring>
class HTTP
{
public:
void get1(const char* url, void* context, void (*callback)(void*, const char*) )
{
callback(context,
浏览 13提问于2020-03-11得票数 2
回答已采纳
1回答
为什么编译器拒绝将变量lamda转换为函数指针？没有可变的args，转换工作得很好。
auto lambda = [] (void *, const char *) {};
auto variadicLambda = [] (void *, const char *, auto ...) {};
auto ptrLambda = +[] (void *, const char *) {};
auto ptrVariadicLambda = +[] (void *, const char *, auto ...) {};
用gcc 12.2和clang 15.0
浏览 14提问于2022-11-23得票数 0
1回答
我在我的项目中使用了SNMP++库，一切工作正常。但是，有一个方法需要在我的.mm文件中获取回调。现在，当我创建一个块并将其作为参数传递给该函数时，它抛出了一个错误：“没有匹配的成员函数用于调用'get_bulk'”。下面是这段代码：
void(^callbackFunc)(int,Snmp*,Pdu&,SnmpTarget&,void*);
callbackFunc = ^(int i,Snmp* s,Pdu& p,SnmpTarget& t,void* v) {
};
snmp.get_bulk(pdu, *target, l_re
浏览 6提问于2018-09-11得票数 0
g++为此代码生成错误。我得把std::sin换成(double (*)(double))std::sin。为什么？
#include <iostream>
#include <list>
#include <algorithm>
#include <cmath>
int main(int argc, char *argv[])
{
std::list<double> radians = {0.0, 3.14/2, 3.14};
std::list<double> sines(radians.size()
浏览 1提问于2020-02-12得票数 1
回答已采纳
2回答
virtual Answer<const Taaal& const> askWho(bool(const Taaal& const)) = 0;
virtual Answer<const Taaal& const> askWho(const Taaal& const t) {
return askWho([&](auto q) {
return q == t;
});
}
被拒绝时使用“没有重载函数的实例与参数列表匹配”(另外，我被告知auto是不允许的，但是用显式类型替换它将留下第一个问题)
Ta
浏览 6提问于2014-08-26得票数 1
回答已采纳
让我们考虑两个同名的函数： int func(int&)
{
return 7;
}
int func(const int&)
{
return 5;
} 让int mutableValue = 5在某个地方定义。有没有可能call(mutableValue, func)中的模板函数call只接受int func(int&)？我不想用static_cast<int(&)(int&)> --因为它太吵了。 朴素的实现： template<typename Arg, typename Ret>
void call(A
浏览 11提问于2020-01-24得票数 7
2回答
我已经开始学习C++11和C++14了，我有一个问题。为什么lambda不返回23？
template<class T>
auto func(T t)
{
return t;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
auto abc = []()->auto { return func(23); };
qDebug() << abc; // output: true
return a.exec();
}
浏览 4提问于2017-12-13得票数 6
回答已采纳
3回答
std：：绑定重载解析
、、、
下面的代码运行良好
#include <functional>
using namespace std;
using namespace std::placeholders;
class A
{
int operator()( int i, int j ) { return i - j; }
};
A a;
auto aBind = bind( &A::operator(), ref(a), _2, _1 );
这不是
#include <functional>
using namespace std;
using namespace std::pl
浏览 2提问于2010-11-12得票数 26
回答已采纳
4回答
operator[]模糊度解算
、、、、
努布在这里。下面是一个类定义的片段，我在一个图书示例中谈到了这一点：
double& operator[](int i);
double operator[](int i) const;
我的问题是：，为什么这不是模棱两可？在编译项目的文件时，编译器不会给出任何错误。另外，在下面(假设AnyClass包含一个valarray<double>对象，我想直接访问它)：
AnyClass test;
cout << test[2]
编译器使用哪个版本？
浏览 9提问于2012-09-04得票数 1
回答已采纳
我想通过lambda::bind调用一个成员。不幸的是，我有两个同名但返回类型不同的成员。有没有办法帮助lambda::bind为成员函数调用推导出正确的返回类型？(bind在显式返回类型推导中工作得很好)
#include <vector>
#include <iostream>
#include <algorithm>
#include <boost/bind.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
using
浏览 8提问于2010-04-30得票数 1
回答已采纳
我不明白为什么Map.compute()和Map.computeIfPresent()使用BiFunction参数以及Map.computeIfAbsent() a Function
我希望有一个普通的，将旧值映射到一个新值，resp。新值的。调用者已经有了密钥(第一个参数)，所以函数或供应商已经可以使用它了。我找到的所有例子都不用钥匙。我想到的原因是：
关键必须是(有效的) final --这很容易管理
有一些花哨的、易于使用的方法引用。
但我不认为这些是这个设计的可行理由。你有什么想法吗？
浏览 1提问于2015-12-09得票数 10
回答已采纳
我正在尝试使用ANSI C++ for_each语句来迭代和打印标准向量的元素。如果我让for_each调用一个非重载的函数，它就能工作，但如果我让它调用一个重载的函数，它就会产生一个编译器错误。
下面是一个最小的测试程序，用于显示编译器错误发生的位置：
#include <algorithm>
#include <iostream>
#include <vector>
struct S {
char c;
int i;
};
std::vector<S> v;
void print_struct(int idx);
void
浏览 1提问于2012-09-28得票数 9
回答已采纳
让我们考虑一下：
void goo () {
std::cout << "void goo ()\n";
}
int goo (int) {
std::cout << "int goo (int)\n";
return 42;
}
现在我想使用如下定义的包装器函数来调用其中一个函数：
template <typename F, typename... A>
void c (F&& f, A&&... a) {
f (std::forward<A>
浏览 1提问于2017-09-03得票数 4
我有一些需要C函数的代码，但我想实例化一堆类实例，并将该类的成员函数作为C函数传递。我需要同时捕获N个实例。我希望我能以lambda的身份来做。 下面是生成的函数应该是什么样子(大致)： // This is the code I want to interface with:
typedef void func(ParamClass param); // ParamClass is NOT my class
extern void notMyCode1(func funcArg); // Code I want to call, saves funcArg
extern void no
浏览 64提问于2019-05-10得票数 0
2回答
如果我像这样实现C回调：
register_callback([](/*some args*/){/*some stuff*/});
当SIGSEGV触发时，我得到一个SIGSEGV，但是如果我像这样注册它：
auto const f([](/*some args*/){/*some stuff*/});
register_callback(f);
那它就能正常工作。(对我来说)特别感兴趣的是地址消毒液产生的堆栈跟踪：
ASAN:SIGSEGV
=================================================================
==22904=
浏览 6提问于2015-01-19得票数 6
回答已采纳
在我的项目中有一个向量
std::vector<std::shared_ptr<MovingEntity>>gameObjects;
如果元素符合标准的话，我想删除这些元素。
方法删除元素：
void GameWorld::catchBees()
{
auto q = std::remove_if(bees.begin(), bees.end(), beeToClose);
bees.erase(q);
}
方法beeToClose：
bool GameWorld::beeToClose( const MovingEntity & bee)
{
浏览 0提问于2016-12-20得票数 1
回答已采纳
刚刚发现了一件很有趣的事情：
var
Queue : TQueue <TProc>;
MyProc : TProc;
...
MyProc := Queue.Dequeue;
我想你知道这是什么意思了。但是，编译器认为我想在MyProc中存储Queue.Dequeue方法(类型为"procedure of object")并报告错误
E2010 Incompatible Types: 'TProc' und 'Procedure of object'
我想出的解决方法是这样的：
MyProc := TProc (Pointe
浏览 0提问于2010-02-17得票数 7
回答已采纳
我最近修复了一个窃听器。
在下面的代码中，一个重载函数是const，另一个不是。这一问题将通过使这两种职能相结合而得到解决。
我的问题是，为什么编译器只在参数为0时才抱怨。
#include <iostream>
#include <string>
class CppSyntaxA
{
public:
void f(int i = 0) const { i++; }
void f(const std::string&){}
};
int main()
{
CppSyntaxA a;
a.f(1); // OK
//a
浏览 1提问于2019-07-18得票数 44
回答已采纳
1回答
比较函数向量的默认参数
、、、、
感兴趣的函数
我正在尝试编写一个模板化的sortDifferentWays函数，它将按照比较器函数的指令对向量进行排序(和打印)。我不确定表示比较器的标准方法是什么，但我选择了
template<typename T>
void sortDifferentWays(std::vector<T>& v, std::vector<bool (*)(T,T)> comparators)
{
for (auto& comparator : comparators)
{
std::sort(v.begin(), v.en
浏览 60提问于2018-06-04得票数 1
1回答
收费站怎么了？
、、
我读到的答案是：
这部分的内容是什么:这一行代码中的(int (*)(int))tolower：
transform(s.begin(),s.end(),s.begin(),(int (*)(int))tolower );
如果我让这个函数和代码工作：
int myToLower(int c){
return tolower(c);
}
transform(s.begin(),s.end(),s.begin(), myToLower);
这部分的通俗之处是：(int (*)(int))。
浏览 0提问于2018-05-17得票数 1
回答已采纳
有什么不符合将lambda传递给apply的std::valarray方法的条件呢？考虑以下代码：
int main()
{
std::valarray<int> arr = {1, 2, 3, 4, 5, 6};
auto arr1 = arr.apply([](int val) { return val * 2; }); // compiles
int n = 3;
auto arr2 = arr.apply([n](int val) { return val * n; }); //does not compile
return 0;
}
浏览 3提问于2017-09-03得票数 6
回答已采纳
我有下面的代码片段：
int x = 3;
auto fauto = [=](){ cout<<'x'; };
function<void()> func{fauto};
func();
void (*rawPf)() = fauto; // fail to compile
rawPf();
我知道只有非捕获的lambda可以分配给函数指针的语法。但是：
(1)为什么std：：功能可以容纳捕获-λ？
(2)由于std：：函数指针和函数指针都是callable，使得std：：函数能够保持捕获-lambda而函
浏览 8提问于2022-08-15得票数 0
回答已采纳
我知道在C++中，在基于指针的应用程序中，0x或NULL已经被nullptr所取代。我只是好奇他们为什么要做这个替代品？
在什么情况下，在处理指针时，使用nullptr而不是NULL是有益的？
浏览 33提问于2013-12-11得票数 265
回答已采纳
2回答
C++内嵌λ参数
、、
考虑下面的代码
#include <iostream>
#include <functional>
using namespace std;
inline void readandrun(function<void(int)> callback) {
int i;
i = 1;
callback(i);
}
int main(int argc, char *argv[])
{
#ifdef LAMBDA
readandrun([](int i){ printf("the read number is: %d\n&
浏览 5提问于2020-08-21得票数 4
回答已采纳
2回答
我有一个vector
std::vector<island> sea;
现在，我想在另一个vector中保存指向这个vector的所有元素的指针。但只是为了个人练习，我想用一种花哨的C++风格来做这件事，所以我输入的不是std::vector<const island*> p_sea：
std::vector<std::reference_wrapper<const island>> r_sea;
现在，我想用引用填充这个新的vector：
std::transform(sea.begin(), sea.end(),
浏览 2提问于2017-12-11得票数 2
回答已采纳
我有这样一种情况，我有一个lambda作为成员变量，它是由某个函数调用创建的。问题是它将此作为其操作的一部分来捕获。稍后，我希望能够复制整个对象...
但是，在复制时，我不知道lambda是如何创建的(它可以通过不同的代码路径在多个点上定义)。因此，我有点困惑于在复制构造函数中放入什么内容。理想情况下，我希望将lambda的捕获“重新绑定”到创建的新"this“。
这有可能吗？
下面是一些示例代码：
#include <iostream>
#include <string>
#include <functional>
class Foo
{
p
浏览 1提问于2012-08-02得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
