lambda中的自动参数类型导致“使用'template‘关键字来处理...”错误
Lambda中的自动参数类型导致“使用'template'关键字来处理...”错误是由于Lambda表达式中的自动类型推导机制导致的。当Lambda表达式中使用了'template'关键字时，编译器无法正确推导出参数类型，从而导致错误。
解决这个错误的方法是显式指定Lambda表达式的参数类型，而不依赖于自动类型推导。可以通过在Lambda表达式的参数列表中使用参数类型来解决这个问题。
以下是一个示例代码：
#include <iostream>
template<typename T>
void process(T value)
{
std::cout << value << std::endl;
}
int main()
{
auto lambda = [](auto value) {
process(value);
};
lambda("Hello, World!"); // 调用Lambda表达式
return 0;
}在上述示例中，我们定义了一个模板函数process，它接受一个参数并打印出来。然后，我们定义了一个Lambda表达式lambda，它接受一个参数并调用process函数。在Lambda表达式中，我们使用了auto关键字来表示参数的类型。由于Lambda表达式中使用了'template'关键字，编译器无法正确推导出参数类型，因此会报错。
为了解决这个问题，我们可以显式指定Lambda表达式的参数类型，如下所示：
auto lambda = [](const char* value) {
process(value);
};在上述代码中，我们将Lambda表达式的参数类型指定为const char*，从而解决了错误。
腾讯云相关产品和产品介绍链接地址：
- 云函数（Serverless）：https://cloud.tencent.com/product/scf
- 云开发（CloudBase）：https://cloud.tencent.com/product/tcb
- 云原生应用引擎（TKE）：https://cloud.tencent.com/product/tke
- 云数据库（TencentDB）：https://cloud.tencent.com/product/cdb
- 云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 人工智能（AI）：https://cloud.tencent.com/product/ai
- 物联网（IoT）：https://cloud.tencent.com/product/iotexplorer
- 移动开发（移动推送、移动分析）：https://cloud.tencent.com/product/mps
- 云存储（COS）：https://cloud.tencent.com/product/cos
- 区块链（BCS）：https://cloud.tencent.com/product/bcs
- 元宇宙（Metaverse）：https://cloud.tencent.com/product/metaverse
请注意，以上链接仅供参考，具体产品选择应根据实际需求进行评估。
相关·内容
2回答
重载前模板实例化中的错误
、、、、
给定以下代码
#include <type_traits>
#include <utility>
template <typename T>
class Something {
public:
template <typename F>
auto foo(F&&)
-> decltype(std::declval<F>()(std::declval<T&>())) {}
template <typename F>
auto foo(
浏览 3提问于2017-10-11得票数 3
回答已采纳
2回答
假设我想要能够写：
template<class T> concept WithNestedTemplate = ...;
struct F { template<class> using nested = int; };
static_assert(WithNestedTemplate<F>);
static_assert(!WithNestedTemplate<int>);
也就是说，WithNestedTemplate应该检查是否存在带有签名template<class> class的成员类模板或别名模板。
我可以写一个助手概念
浏览 0提问于2021-05-20得票数 3
1回答
我想用c++17编译下面的代码，这样我就可以传递具有特定签名int(int)的任何函数(lambda)，同时也允许默认参数：
template <class F = int(int)> // for deduction
struct A{
A(F f = [] (int x){return x;}) : f_{f} {}
F f_;
};
int main() {
A work([](int x){return x + 1;});
A not_work; // compile error.
}
但是，clang发出
浏览 2提问于2021-12-01得票数 2
回答已采纳
2回答
匹配类型的Gmock匹配器
、、、、
在gmock中有没有匹配类型而不是值的方法？这个类类似于：
struct Blob {
template<class T> bool is(); // if blob holds data of type T
template<class T> T get(); // get data as type T
}
我的匹配器看起来像这样：
MATCHER_P(BlobIs, T, "") {
return arg->is<T>();
}
但是构建失败了，出现以下错误：
error: expected primary-
浏览 9提问于2019-08-02得票数 3
2回答
当返回参数为void或T时，我尝试实现模板函数。我使用sfinae尝试了上面代码的不同变体，但仍然不确定在lamdba是函数参数的情况下，这是否通常是可能的。以下代码无法编译：
#include <functional>
template <typename T>
T Apply(const std::function<T()>& func)
{
return func();
}
template <>
void Apply(const std::function<void()>& func)
{
浏览 13提问于2018-01-24得票数 4
回答已采纳
3回答
auto关键字在C++11中可以替换函数模板和专门化吗？如果是，使用模板函数和专门化比将函数参数简单地输入为auto有什么好处？
template <typename T>
void myFunction(T &arg)
{
// ~
}
与
void myFunction(auto &arg)
{
// ~
}
浏览 3提问于2013-08-08得票数 33
回答已采纳
我发现gcc和clang允许在非类型模板参数类型子句中使用decltype(auto)。例如：
template <decltype(auto)>
struct X {};
int foo ;
int main() {
X<(foo)> x;
static_cast<void>(x);
}
它是符合标准的特性，还是一些？
浏览 4提问于2017-09-03得票数 45
回答已采纳
2回答
这是最小的可复制代码，
#include <iostream>
#include <string>
void bar(std::string s, int x){
std::cout <<std::endl<< __FUNCTION__<<":"<<s<<" "<<x;
}
using f_ptr = void(*)(std::string);
void foo(f_ptr ptr){
ptr("Hell
浏览 0提问于2021-03-02得票数 1
回答已采纳
1回答
我有这样一门课：
#include <iostream>
template <class T>
class LL
{
using size_t = unsigned int;
class Node
{
T m_data;
Node* m_next;
Node(const T& data) :m_data{ data }, m_next{ nullptr }{}
friend std::ostream& operator<<(std::ostream
浏览 0提问于2020-05-18得票数 1
回答已采纳
模板模板类型名称？
当使用模板语法时，就像在template <template <typename> class T>中一样，需要使用关键字class，因为使用typename会出现以下错误：
错误:模板模板参数在参数列表后要求“class”
在声明模板参数的基本情况下，在其他地方，关键字typename和class是可互换的。
您可能会认为，使用模板模板时的要求是一个提示，即您需要传递一个类类型的，但情况并不总是如此(特别是在C++11引入了模板类型别名之后)。
template <template <typename> class T&g
浏览 2提问于2014-06-06得票数 32
回答已采纳
2回答
将函数作为类中的参数传递
、、、
因此，我试图在一个项目中使用，并且由于所述项目的大小，我正在将我的代码重构成一组不同的库。这是客户端服务器处理部分的一部分。
我已经确定了如何有效地传递*请求来分离函数，以便清理我的代码。也就是说，在我的图书馆.cpp文件中
server->on("/heap", HTTP_GET, [this](AsyncWebServerRequest *request) { handleHeap(request); });
火灾：
void CServer::handleHeap(AsyncWebServerRequest *request) { request->send(
浏览 2提问于2020-01-03得票数 2
回答已采纳
bool isEven(int val) {
return val % 2 == 0;
}
bool isOdd(int val) {
return val % 2 != 0;
}
template<class Iterator>
int count_function(Iterator start, Iterator end, auto criteria) {
int count = 0;
for (; start != end; ++start) {
if (criteria(*start)) {
cou
浏览 33提问于2019-07-07得票数 1
1回答
template < class A, class B, class R = A >
void addMultiplyOperation( std::function< R ( const A&, const B& ) > func )
{
...
}
addMultiplyOperation< float, int >( []( float a, int b ) { return a * b; } );
这会导致编译器错误：
In function 'int main(int, char**)':
error: n
浏览 2提问于2014-03-01得票数 4
回答已采纳
3回答
我对此有很多理解上的困难。我知道我的编译器(Visual Studio)知道lambda是什么“类型”，因为有时它显示它是一个lambda，但是我的模板不能推断它，auto关键字也不能。
template <typename T> void templatedFunc(T (*funcPtr)(void)) { }
int main()
{
templatedFunc([] () { return 6;} ); // Error, no template matches argument list
int (*funcPtr)(void) = [] ()
浏览 0提问于2017-01-14得票数 1
2回答
假设我有两个函数作为参数接收不同的lambda类型：
template<typename F>
void func1(F&& lambda) {
// lambda must be [](unsigned int) -> short
}
template<typename F>
void func2(F&& lambda) {
// lambda must be [](const vector<string>&) -> void
}
如何在C++17中限制这些lambda签名，使其与我在每
浏览 2提问于2020-09-23得票数 3
回答已采纳
这是我的名单课
template <typename Object>
class List {
public:
class iterator {
...
};
....
};
这是我的职责
template <typename Object>
void swapAdjacent(List<Object>::iterator & itrA, List<Object>::iterator & itrB) {
}
编译后，会发现以下错误
错误:变量或字段“swa
浏览 2提问于2015-11-11得票数 1
回答已采纳
当获取winapi HWND并返回wstring时，我有一个函数。 std::wstring utility::winapi::window_class(HWND hwnd) {
int title_length = 20;
std::wstring class_name;
class_name.resize(title_length, '\0');
GetClassName(hwnd, const_cast<LPWSTR>(class_name.c_str()), title_length);
class_name.era
浏览 38提问于2020-08-29得票数 1
回答已采纳
为什么下面的代码不编译？为什么我必须告诉编译器，传递的函数指针返回一个双值？(如果显式调用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
回答已采纳
5回答
我一直在审查标准的草案版本。特别是关于的部分，我对不引入多态lambdas的理由感到困惑。
例如，在使用多态lambda的100001种方式中，我希望我们可以使用如下代码：
template<typename Container>
void foo(Container c)
{
for_each(c.begin(), c.end(), [](T& t) { ++t; });
}
原因是什么：
是因为委员会没时间了吗？
多态兰巴斯太难实现了吗？
或者他们被认为是不需要的
注意:请记住，上面的例子并不是唯一的例子，它仅作为代码类型的指南提供。仅专注于
浏览 7提问于2011-01-10得票数 35
所以我一直在学习模板和lambdas，所以我尝试将两者结合起来。我正在尝试创建一个模板化的ty对联，它指定了lambda应该返回和接受的内容。它适用于非捕获λ，但它不能处理捕获的任何lambdas。这是我现在的代码：
template<typename T>
using L = T(*)(T);
template<typename T>
T applyLambda(T var, L<T> lambda){
return lambda(var);
}
int main() {
const int a = 45;
int b = app
浏览 3提问于2020-08-10得票数 4
回答已采纳
为什么下面的类A不能在下面的代码中推导出它的模板参数：
#include <functional>
template <class... Ts>
class A
{
public:
using Func = std::function<void(std::decay_t<Ts>...)>;
A(Func func) : m_func(func)
{
}
private:
Func m_func;
};
int main()
{
//compiles
A<int, bool&
浏览 6提问于2021-01-18得票数 1
回答已采纳
我正在尝试用迭代器实现一个简单的列表以供实践，但是我遇到了一个编译错误，我不完全理解我没有能够修复它。当我试图在Iterator类中创建指向Node的指针时，会得到如下编译错误：
类模板的使用需要模板参数列表
下面是生成编译错误的headre文件：
#ifndef _MY_LIST_H
#define _MY_LIST_H
#include <memory>
template<class T>
class MyListItr;
template<typename T>
class MyList {
private:
int _size;
浏览 4提问于2020-04-06得票数 0
回答已采纳
在C++03或更早版本中，有实现auto关键字的方法吗？不是对象类，而是可以像这个C++11那样使用它
auto x = 5;
std::cout << x;
我很快就‘启动’了一个实现，但是它是相当垃圾的，因为您可以将它转换成任何类型--太像一个object类了，而且非常基本，我知道，但无论如何，它是这样的：
class auto_t
{
public:
template < typename _Ty > auto_t(const _Ty &_Value)
: __data(_Value)
{
}
templa
浏览 1提问于2014-02-24得票数 5
回答已采纳
假设代码：
template <class T>
class X { };
int main(void) {
X<class {
int a;
}> x;
return 0;
}
g++ 5.1提供了以下错误消息：
prog.cpp: In function 'int main()':
prog.cpp:5:10: error: types may not be defined in template arguments
X<class {
^
prog.cpp:7:2: erro
浏览 8提问于2016-01-09得票数 3
下面的代码产生一个错误error: ‘struct Foo’ is not a valid type for a template constant parameter
template <struct Foo>
struct Bar {
};
为什么会这样呢？
template <class Foo>
struct Bar {
};
运行得非常好，甚至可以接受一个结构作为参数。
浏览 0提问于2010-03-26得票数 4
回答已采纳
2回答
我需要接受lambda函数作为参数并计算它的返回类型。到目前为止，我还没有想出任何可行的办法。下面是一个例子：
template <typename T1, typename T2>
T1 foo(T2 arg, std::function<T1(T2)> f)
{
return f(arg);
}
...
int n = foo(3, [](int a){ return a + 2; }); <-- ERROR!
怎么做呢？Boost解决方案也可以。
浏览 4提问于2014-08-18得票数 2
回答已采纳
3回答
我用gcc编译了以下代码：
template<typename... Pack>
auto func(Pack... x) {
return (x + ...) ;
}
template<typename... Pack>
auto lamd = [](Pack... x) {
return (x + ...) ;
};
我可以用func(1,2,3)调用函数模板，但是在使用lamd(1,2,3)或lamd<int>(1,2,3)调用lambda时会出现错误。
浏览 4提问于2019-06-24得票数 4
回答已采纳
3回答
我正在尝试使用g++编译一些Microsoft Visual C++代码。现在我遇到了一个编译器错误，我真的不能理解。(简化的)代码如下所示：
template<int X> struct A {
template<class Ret> static Ret call() {
return 0;
}
};
template<int X> struct B : A<X> {
int f() {
return A<X>::call<int>();
}
};
当我
浏览 0提问于2012-01-25得票数 3
回答已采纳
我正在编写一个C++类，其中包含一个成员vector。我想重写vector方法，以便MyVector可以像std::vector一样使用。但是，assign方法始终引发编译错误：
#include <vector>
template<class T>
struct MyVector {
typedef std::vector<T> vector_type;
vector_type my_vector;
template<class It>
void assign(It first, It last)
浏览 0提问于2019-08-23得票数 2
回答已采纳
下面的代码在Visual C++ 2010下编译得很好，但在Android NDK r8b的GCC 4.6下就不行了。
template<typename A>
struct foo
{
template<typename B>
B method()
{
return B();
}
};
template<typename A>
struct bar
{
bar()
{
f_.method<int>(); // error here
}
private:
浏览 3提问于2012-09-28得票数 2
回答已采纳
一件简单的事情。但我花了一个小时搞不明白。
当我编译以下代码时：
#include <iostream>
#include <sort.h>
#define array_len(arr) ( sizeof(arr) / sizeof (*arr) )
using namespace std;
template<typename ITER>
void printIt_works(ITER b, ITER e) {
for_each(b, e, [](int it) { cout << it; } ); // putting int ex
浏览 4提问于2012-03-15得票数 3
回答已采纳
1回答
我几乎没有找到相关的答案，但不是我想要的。
下面是我现在的代码：
code_str = """
print "this is my global x = " + x
print "And another line is done"
"""
x = 'mystery'
func_template = lambda p: None
func_template.__code__ = compile(code_str, '<string>', 'exec')
浏览 3提问于2013-05-14得票数 4
回答已采纳
我这样定义了一个方法：
template <class ArgT>
void foo(ArgT arg, ::boost::function< void(ArgT) > func)
{
func(arg);
}
并像这样使用它--例如--
foo(2, [](int i) -> void { cout << i << endl; });
为什么编译器不能推导出类型，因为它肯定是一个int
我得到了'void foo(ArgT,boost::function<void(ArgT)>)' : could no
浏览 1提问于2011-05-03得票数 9
回答已采纳
我把以下功能作为我们班的一员：
template <typename... _Types>
void NotifyAllDelayed(_Types&&... _Args)
{
delay_runner->Add([=, this] { this->NotifyAll<_Types...>(std::forward<_Types>(_Args)...); });
}
我创建了这个，因为我不想重复：
delay_runner->Add([=, ¬ifications] { notifications-&g
浏览 8提问于2022-09-27得票数 0
回答已采纳
我不确定为什么下面的代码块编译和工作，即使模板语法所暗示的语义是不同的。类A接受模板类型Data，并包含模板类型为Data的成员data。它还具有一个构造函数，该构造函数通过值接受Data的实例，并使用假定的复制构造函数实例化成员data。另一个类C有一个任意的构造函数，它接受指向某个任意类B的指针，并将其存储为成员foo。当A中的Data被模板化为类型C和使用C的构造函数接受的参数(即指向B的指针)实例化的A<C>时，可能会出现编译器错误，因为A没有被告知如何处理任意参数并将它们传递给Data构造函数。它只被告知对现有实例使用Data的复制构造函数。但是，此代码使用clang和c
浏览 11提问于2019-07-16得票数 1
我正在玩一些C++11特性，我遇到了以下情况：
#include <iostream>
#include <vector>
template <class T>
void map(std::vector<T>& values, T(*func)(T)) {
for (int &value : values) {
value = func(value);
}
}
int mul2(int x) {
return 2*x;
}
auto mul3 = [](int value) {
浏览 2提问于2020-05-30得票数 0
回答已采纳
3回答
这段代码按预期工作(什么也不做，甚至不会产生警告/错误)：
l = lambda {|i|}
l.call(1)
此代码生成警告(警告:一个块参数有多个值(0代表1))：
l = lambda {|i|}
l.call
此代码失败并返回错误(ArgumentError:参数数量错误(2为0))：
l = lambda {|i, y|}
l.call
我认为lambda需要传递所有的参数。
从第二个例子中我发现它不是这样的，为什么它在只给出一个参数的情况下工作，而在有多个参数的情况下按预期工作(由于错误而失败)？
PS: ruby 1.8.6 (2008-08-11补丁级别287)通用-darw
浏览 0提问于2010-02-10得票数 25
回答已采纳
我有一个类似容器的类，它的方法类似于std::apply。我想用const限定符重载这个方法，但是当我试图用泛型lambda调用这个方法时，我会从std::invoke_result_t的实例化中得到一个严重的错误。我使用std::invoke_result_t推断方法的返回值，并对参数执行SFINAE检查。
#include <type_traits>
#include <utility>
template <typename T>
class Container
{
public:
template <typename F>
浏览 0提问于2018-11-16得票数 4
回答已采纳
我想做一件简单的事情：
void DoUntil(auto predicate = [] { return false; });
显然，这是行不通的-我必须使用模板参数：
template <typename P>
void DoUntil(P predicate = [] { return false; });
但是这个声明也不起作用-- Clang给出了一个错误：
错误:没有调用…的匹配函数
注:候选模板被忽略:无法推断模板参数'P‘
如果我确实调用了不带参数的函数，编译器就无法从默认参数中推断类型：
int main() { DoUntil(); }
我不想以
浏览 0提问于2017-02-13得票数 11
问题背景：
在讨论使用运行时值恢复编译时上下文的方法时，
(是的，听起来是个坏主意)，我发现GCC对std::integral_constant<bool, value_arg>::value的评价很奇怪：
在这里，请参阅关于godbolt的完整示例：
免责声明：这段代码在许多方面都是错误的，只是为了说明而已。
正如您可能看到的，这里的std::integral_constant<bool, value_arg>::value看起来是在这两种情况下实例化错误的符号。
static_assert(argument_type::value == false); // fai
浏览 3提问于2021-03-22得票数 0
回答已采纳
我得到了以下代码：
template<typename T>
concept con1 = requires(T t, std::string s){
{ t[s] } -> std::same_as<std::string>;
};
using function_signature = std::function<void ( con1 auto functor)>; // ERROR!
虽然编译器没有问题，但我直接定义lambda：
auto lambda_1 = [](con1 auto functor){....}
我希望前者工
浏览 4提问于2022-06-15得票数 1
回答已采纳
考虑具有不同成员类型别名的两个struct：
struct foo { using x = int; };
struct bar { using y = float; };
给定template上下文中的T，我希望根据T是什么来获得T::x或T::y：
template <typename T>
auto s()
{
auto l = [](auto p)
{
if constexpr(p) { return typename T::x{}; }
else { return typename T::y{};
浏览 36提问于2017-06-30得票数 19
回答已采纳
2回答
我正在尝试匹配C++模板中的可调用对象，并根据作为参数接收的可调用对象的类型提供不同的实现。
我有以下模板函数：
template<class Ret, class... Args>
void fun(std::function<Ret(Args...)> f) {}
template<class Ret, class... Args>
void fun(Ret(*f)(Args...)) {}
它们接受std::function对象和普通函数指针，并正确地推导出它们的返回Ret和参数Args类型。然而，我在传递匿名lambda表达式时遇到了困难，因为它们
浏览 9提问于2016-09-27得票数 4
问题如下:以下测试抛出了大量的编译器错误。
#include <vector>
using namespace std;
template<class T>
class test{
vector<T> vec;
public:
vector<T>::iterator begin();
};
template<class T>
vector<T>::iterator test<T>::begin(){
return vec.begin();
}
int main(){
test<
浏览 0提问于2012-10-02得票数 1
回答已采纳
1回答
案例1
考虑以下lambda noexcept说明符中的包扩展：
template <bool... B>
auto g() {
([]() noexcept(B) {}, ...);
}
Clang和MSVC接受此代码，但GCC 与：
error: expansion pattern '<lambda>' contains no parameter packs
这是一个有效的密码吗？我应该信任哪个编译器？
案例2
考虑以下lambda requires-clause中的包扩展
template <bool... B>
aut
浏览 9提问于2021-03-14得票数 28
2回答
模板专门化中的默认参数
、、、
template<typename T> void printf_t(const T&, char='\n');
template<> void printf_t(const int&, char);
void (*pi)(const int&, char) = printf_t<int>;
int main()
{
int a;
scanf("%d", &a);
pi(a);
return 0;
}
我怎样才能使这个代码工作呢？我希
浏览 4提问于2020-07-04得票数 2
回答已采纳
对于上下文，我正在尝试编写一个解决非线性方程系统的类(一个寻根器)。为此，我的接口如下:构造器接受一个函数，该函数接受一个特征向量并返回一个特征向量(系统要求解)，并将其存储在func中，newt成员函数接受一个特征向量(初始猜测)，使用该初始猜测运行算法，并返回特征向量r，使得func(r) = {0, 0, ..., 0}。
现在，我已经按照指令编写了类的函数:编写接受MatrixBase实例化的模板函数。我的问题是，如果我还想将一个函数传递给类，我该如何做类似的事情？我尝试过的最明显的方法是存储一个私有std::function对象，并以类似于我处理函数的方式将其模板化。它没有起作用，我
浏览 0提问于2016-11-12得票数 0
通过整个中介模式的概念及其在wpf中的使用，并感谢那些到目前为止提供帮助的人，我偶然发现了Sacha Barber关于Code Project的一篇文章，他在文章中采用了mediator，但对其进行了稍微的修改，使其更具通用性。
我已经能够理解他的论点的逻辑，并且(改变一下，相当不错)几乎所有他的c#示例都可以很好地转换。当然，所有的都是例外！这是他的例子，你实际上是如何注册中介人的。对于那些还没有看过这篇文章的人，你可以参考它
引起问题的C#片段位于他的示例的构造函数中，如下所示
using System;
using System.Collections.Generic;
using
浏览 2提问于2014-10-29得票数 0
在使用一些模板并使用迭代器编写基本容器类时，我发现自己需要将成员函数的主体从模板类移动到单独的文件中，以符合样式指导原则。但是，我遇到了一个有趣的编译错误：
runtimearray.cpp:17:错误：“&”令牌runtimearray.cpp:24之前的预期构造函数、析构函数或类型转换:错误：“&”令牌runtimearray.cpp:32之前的预期构造函数、析构函数或类型转换:错误：“&”令牌runtimearray.cpp:39之前的预期构造函数、析构函数或类型转换:错误:预期构造函数、析构函数或“&”令牌runtimearray.cpp:85之前的类
浏览 3提问于2009-11-12得票数 3
回答已采纳
我正在尝试编写一个总是返回-1的泛型函数。我希望模板参数列表缺省为int。我尝试使用std::enable_if或std::enable_if_t通过使用std::is_arithmetic或std::is_arithmetic_v来测试类型T是否为有效的算术类型。我遇到了语法问题，无法正确编译此代码。下面是我的lambda的样子： template<typename T = int,
std::enable_if_t<std::is_arithmetic_v<T>> >
static constexpr T negative_one = [](){
浏览 23提问于2021-02-03得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
