避免std::function的开销
是指在编程中尽量减少使用std::function类型的对象，以避免带来的性能损耗和额外的开销。
std::function是C++标准库中的一个通用函数封装器，可以用于存储、复制和调用任意可调用对象（函数、函数指针、成员函数指针、lambda表达式等）。然而，由于std::function的灵活性和通用性，它在运行时会引入一些额外的开销，包括内存分配、虚函数调用等，从而导致性能下降。
为了避免std::function的开销，可以考虑以下几种方法：
- 使用模板函数：通过使用模板函数，可以在编译时确定函数的具体类型，避免了std::function的运行时开销。例如，可以使用函数模板来实现通用的回调函数，而不是使用std::function。
- 使用函数指针：如果可行的话，可以直接使用函数指针来代替std::function，因为函数指针的调用效率更高，没有额外的开销。
- 使用lambda表达式：lambda表达式可以在一定程度上替代std::function的功能，并且在性能上通常更高效。可以使用auto关键字来推导lambda表达式的类型，避免显式指定std::function的类型。
- 使用静态多态：如果需要在运行时动态地调用不同类型的函数，可以考虑使用静态多态技术，如模板特化或模板元编程，以在编译时生成不同类型的函数调用代码，避免std::function的运行时开销。
总之，避免std::function的开销可以通过使用模板函数、函数指针、lambda表达式和静态多态等技术来实现。根据具体的场景和需求，选择合适的方法可以提高程序的性能和效率。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数计算（云原生无服务器计算服务）：https://cloud.tencent.com/product/scf
- 腾讯云云数据库 MySQL 版（关系型数据库服务）：https://cloud.tencent.com/product/cdb_mysql
- 腾讯云云服务器（弹性计算服务）：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/mad
- 腾讯云对象存储（云存储服务）：https://cloud.tencent.com/product/cos
- 腾讯云区块链（区块链服务）：https://cloud.tencent.com/product/baas
- 腾讯云虚拟专用网络（VPC）：https://cloud.tencent.com/product/vpc
- 腾讯云安全产品（包括DDoS防护、Web应用防火墙等）：https://cloud.tencent.com/product/ddos
相关·内容
1回答
我有两个类A和B，我想从A类调用B类的成员函数，同时将A的成员函数传递给B的所述函数。设置： class B {
public:
int dopristep(std::function<int(int,int)> f, double t, double h);
};
class A {
public:
void run();
int g(int,int);
B* mB;
};
void A::run() {
ires = mB->dopristep(&g, T, h)
浏览 13提问于2020-07-22得票数 0
回答已采纳
1回答
我正在尝试内联以下C++代码：
__attribute__((always_inline)) static void inline compose(const char* s, std::function<void(const char *)> f) {
std::cout << s << std::endl;
f(s);
}
// --------------- Main ---------------
int main() {
// Nest three things
c
浏览 17提问于2018-06-08得票数 -2
回答已采纳
我正在尝试比较GSL的ODE-solver和boost中的odeint用于多维系统，因此写了一个简短的测试程序：
#include <iostream>
#include <cmath>
#include <vector>
#include <chrono>
#include <boost/numeric/odeint.hpp>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_odeiv2.h>
浏览 32提问于2020-02-11得票数 0
回答已采纳
请考虑以下示例：
using function_pair = std::pair<int, void(*)(void*)>; // This line cannot change
template <class Arg, class F>
function_pair make_function_pair(int i, F&& f)
{
return function_pair(i,
[&](void* x){std::forward<F>(f)(static_cast<Arg*>(x));}); // N
浏览 1提问于2015-12-01得票数 1
回答已采纳
1回答
是否可以调用用std::bind创建的函数对象(使用std：：异步)。以下代码无法编译：
#include <iostream>
#include <future>
#include <functional>
using namespace std;
class Adder {
public:
int add(int x, int y) {
return x + y;
}
};
int main(int argc, const char * argv[])
{
Adder a;
function<i
浏览 2提问于2013-09-29得票数 7
回答已采纳
1回答
我的印象是，未格式化的write()将逐字复制字节到调用它的ostream。另一位用户也告诉我：“写函数不会跳过任何东西。如果你在使用stringstream时遇到问题，就问一个问题。”
但是，在最近使用stringstream的一些代码中，我发现情况并非如此。
#include <iostream>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <iterator>
int main()
{
{
const std::
浏览 4提问于2017-05-17得票数 2
回答已采纳
2回答
我正在寻找一种在两个谓词函数之间创建二进制操作的方法。这是我的谓词函数声明：
template <typename T>
using Predicate = std::function<bool(T const&)>;
我正在寻找一种将两个谓词函数“连接”为一个的方法：
template <typename T>
static Predicate<T> andPredicate(Predicate<T> a, Predicate<T> b) {
// ???
}
预期行为：
Predicate<int&
浏览 1提问于2018-05-23得票数 0
回答已采纳
考虑一个正常的递归函数：
#include <iostream>
#include <functional>
void f(unsigned long long int x) {
std::cout << x << "\n";
if(x < 1e9)
f(x+1);
}
int main() {
f(1);
return 0;
}
这将终止于43033。
现在考虑递归lambda：
#include <iostream>
#include <functio
浏览 4提问于2016-09-26得票数 8
回答已采纳
1回答
不带移动构造函数的移动类
、、、
假设我有一个类型为A的对象a。
如果我想把它移到一个函数foo(A)。
一种选择是执行foo(std::move(a))，这将调用move构造函数。
但是，假设我使用的是一个我无法控制的类。如果我还想移动文字，这还不够吗？
std::unique_ptr<A> a_ptr(new A());
foo(std::move(a_ptr));
并将foo更改为接受unique_ptr。
这两者不是很相似吗(在第二种情况下使用智能指针的开销很小)？
浏览 0提问于2017-04-22得票数 1
2回答
我想使用std：：可选作为一个可能的类型，我担心我是否可以用它来表示一些计算中的潜在故障，所以观察到它是一个空选项。
例如，考虑：
// This function doesn't have state
std::optional<int> multiply_by_2(std::optional<int> ox) noexcept
{
if (ox)
return {ox.value() * 2};
// empty input case
return {};
}
int main()
{
auto input
浏览 2提问于2019-09-24得票数 0
回答已采纳
我有一些遗留代码，我想用C++11风格重写。有一些boost::function被定义为
// void One::first(int)
boost::function<void()> a1 = boost::bind(&One::first, this, this->a);
// void Two::second()
boost::function<void()> a2 = boost::bind(&Two::second, this);
// void Three::third(int, const std::string &)
浏览 3提问于2015-04-13得票数 2
回答已采纳
1回答
我已经实现了Luhn算法校验和部分的两个python版本。除了计算第二次求和的方法外，代码片段几乎是相同的。它不同于通常的实现，因为它计算总和，然后用校正因子更新和(如所示)。
def manual_loop(xs):
differences = (0, 1, 2, 3, 4, -4, -3, -2, -1, 0)
total = sum(xs) % 10
for x in xs[len(xs)%2::2]:
total += differences[x]
return total % 10
def builtin_loop(xs):
浏览 0提问于2018-08-20得票数 2
回答已采纳
2回答
在final或function上使用说明符是否会增加内存或cpu开销，还是只在编译时使用？
std::is_final是如何认识到什么是最终的？
浏览 3提问于2015-08-12得票数 9
回答已采纳
1回答
我将为我的C++游戏引擎实现类似于C++组件模型的东西。请查看我的Component基类草案：
class Component
{
public:
template<class T>
static T* create(void)
{
if (Type<T>::id == 0)
Type<T>::id = ++_idCounter;
T* component = new T();
component->_id = Type<T>::id;
浏览 0提问于2013-06-20得票数 4
2回答
我正在尝试使用地图作为实现对象工厂的一种方式。在Python中，可以将类类型存储在映射中，然后使用类类型创建对象：
class Foo:
# ...
class Bar:
# ...
factory_map = { 'foo' : Foo, 'bar' : Bar }
foo_object = factory_map['foo']()
我不知道C++中有类似的特性(即在地图中存储类型)，所以我想出了一个基于lambda函数的解决方案，其中映射存储负责创建对象的函数：
class Base {
public:
typed
浏览 0提问于2012-08-15得票数 2
2回答
请考虑以下示例
void foo(const std::function<int()>& f) {
std::cout << f() << std::endl;
}
void foo(const std::function<int(int x)>& f) {
std::cout << f(5) << std::endl;
}
int main() {
foo([](){return 3;});
foo([](int x){return x;});
}
这不编译，因为对foo的调
浏览 0提问于2015-01-03得票数 12
回答已采纳
1回答
我在使用模板时遇到了一个匿名函数错误。我想要创建一个函数，并有一个参数传递给它。这应该很简单，但我错了。如果我不使用模板，只需要替换实际的类型，代码就不起作用了。我做错什么了？
没有调用“打印”的匹配函数
template <typename mytype>
void print(mytype arg1, std::function<void(mytype)> arg2)
{
arg2(arg1);
}
.
.
auto myLamba = [](int x){std::cout << "x = " << x <<
浏览 1提问于2020-01-19得票数 0
回答已采纳
4回答
让我们假设我希望通过引用函数传递由std::bind创建的函数对象：
void myCallback(int i, int j)
{
std::cout << "toCall , i=" << i << " j=" << j;
}
void worker(std::function<void(int)> & callback)
{
callback(111);
}
int main(int argc, char** argv)
{
auto foo = std::bi
浏览 1提问于2020-01-28得票数 5
3回答
与常规递归函数相比，递归lambda函数是否会产生任何开销(因为我们必须将它们捕获到std：：函数中)？
此函数与仅使用常规函数的类似函数有何不同？
int main(int argc, const char *argv[])
{
std::function<void (int)> helloworld = [&helloworld](int count) {
std::cout << "Hello world" << std::endl;
if (count > 1) helloworl
浏览 2提问于2013-06-12得票数 8
回答已采纳
3回答
除了诉诸std::function之外，还有其他方法来存储一个齐次的可调用集合吗？即，替换以下代码中的T类型
using T = std::function<void(int)>;
std::vector<T> v{some_lambda, some_fn_ptr, some_pmf, some_functor};
用别的东西吗？
当将单个调用作为参数传递给高阶函数时，我尽可能地使用模板来避免std::function的开销。但对于收藏品，我不知道是否有什么我能做的。
浏览 3提问于2016-12-18得票数 6
回答已采纳
据我所知，将指针或引用引用到std::vector元素被认为是错误的做法。但是std::vector::data()呢？重新分配后，data()获取的指针是否仍然有效？
浏览 1提问于2020-12-26得票数 2
回答已采纳
2回答
小型C++线程池
、、
我制作了一个小线程池，用于与Redis服务器进行通信：
#include "redox.hpp"
redox::Redox rdx;
void my_cool_function()
{
// do stuff with rdx
}
int main()
{
rdx.connect("localhost");
int max_threads = std::thread::hardware_concurrency();
std::vector<std::thread> pool;
for (int i =
浏览 0提问于2016-05-12得票数 1
回答已采纳
有没有人可以建议如何从模板唯一的指针池返回自定义删除程序的唯一指针。
在下面的代码片段中，我使用ObjectPool.h作为我的模板类来获取一个唯一指针堆栈。我使用ObjectPool在DBConnection.h中创建了一个共享池对象，稍后在DBConnection.cpp中，我只是将该对象返回给DBExec。
我在DBConnection.cpp中得到了一些编译错误，这些错误与将带deleter的指针转换为普通的唯一指针有关。
> Class that will manage connection objects.
**DBConnectionPool.h**
#ifndef DB
浏览 1提问于2017-05-01得票数 0
下面是我的异常类：
class Win32Failure : public std::exception
{
public:
Win32Failure( char const* win32_function_name, LONG error_code );
char const* win32_function_name() const { return win32_function_name_; }
LONG error_code() const { return error_code_; }
virtual char const* what() const
浏览 0提问于2012-02-23得票数 8
回答已采纳
在下面的代码中，类拥有一个动态分配的数组.它通过执行隐式转换到const的公共方法公开对此数组的只读访问。
#include <array>
template <class T, std::size_t N>
class A {
const unsigned int size;
std::array<T, N> *s;
public:
A(const unsigned int _size, const std::array<T, N>& def) :
size(_size),
s(new std::arr
浏览 0提问于2019-08-14得票数 1
回答已采纳
我已经尽可能地简化了这一点，并希望这是明确的。我有一个名为Foo的类，它包含一个std::function成员，它绑定到我想要调用的函数。
当调用Foo::DoCallback时，执行绑定或赋值的函数。为了支持不同类型的参数，我创建了2个构造函数和一个不接受参数的默认构造函数。
一个构造函数，它使用带有int类型参数的std::function。
Foo(std::function<void(int)> callback, int a)
接受std：：函数的构造函数，它接受bool参数。
Foo(std::function<void(bool)> callback, b
浏览 1提问于2018-09-22得票数 2
回答已采纳
1回答
我写了如下的程序
多线程环境中的遍历目录首先确定所有顶层目录并存储到向量中，结果如下：
/家庭/迪尔1
/家庭/迪尔2
..。一千多
创建数据库数量
创建线程数
将每个线程分配给一个目录
遍历和确定目录的大小
当然有一些问题，但我觉得代码也需要重新考虑任何更好的建议。
#include<boost/tokenizer.hpp>
#include<boost/asio.hpp>
#include <boost/bind/bind.hpp>
#include "scan_dir.h" //local file
using namespace s
浏览 0提问于2021-03-18得票数 2
在我的应用程序中，将的使用迁移到有什么真正的好处吗？
我不明白，我试图更改代码，现在它无法编译：
7>------ Build started: Project: Meeting Schedule Assistant, Configuration: Release x64 ------
7>CalendarSettingsOutlookPage.cpp
7>C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.30.30705\include\xhash(112,53): error
浏览 6提问于2021-11-10得票数 0
回答已采纳
我一直在想，C++中的设计决策是否有理由不为任何std库容器提供一个纯粹的抽象类？
我理解hash_map是后来从stdext命名空间来的，但是共享一个非常相似的接口。如果我后来决定要为某个特定的软件实现自己的地图，我更愿意使用某种接口。
示例
std::base_map *foo = new std::map<std::string, std::string>;
delete foo;
foo = new stdext::hash_map<std::string, std::string>;
显然，就我所知，上面的示例是不可能的，但是对于list和其他std容器来说也
浏览 1提问于2013-02-23得票数 3
回答已采纳
1回答
在过去，当我想要一个回调作为函数参数时，我通常决定使用std::function。在很少的情况下，我绝对不使用捕获，而是使用typedef作为函数声明。
因此，通常情况下，带有回调参数的声明如下所示：
struct Socket
{
void on_receive(std::function<void(uint8_t*, unsigned long)> cb);
}
然而，据我所知，std::function实际上在运行时做了一些工作，因为必须将lambda的捕获解析为std::function模板，并移动/复制它的捕获(?)。
阅读新的C++ 20特性时，我想我可能能够利用概
浏览 2提问于2020-08-21得票数 7
回答已采纳
同意using namespace XXX不是一个好的实践。然而，在每个调用中添加namespaces::前缀不仅单调乏味，而且有时也令人恼火。例如，查看下面使用标准命名空间std的代码
#include <iostream>
int main()
{
std::cout << "Hello World" << std::endl;
return 0;
}
但是，我只需通过using关键字导入函数本身，就可以摆脱重复的using
#include <iostream>
using std::cout;
using
浏览 2提问于2017-01-25得票数 3
回答已采纳
我找到了关于如何使用的std::getline()，下面是代码片段：
std::istringstream input("abc|def|gh");
std::vector<std::array<char, 4>> v;
for (std::array<char, 4> a; input.getline(&a[0], 4, '|'); )
v.push_back(a);
我们可以发现，a是在for-循环中构造的，并作为参数传递到push_back中。是否有更好的方法来确保没有像a这样的临时对象来避免开销？
我
浏览 2提问于2018-02-04得票数 3
回答已采纳
来自C++11的std::function<void(int&)>和它的sizeof = 32有什么神奇之处？如果我将函数引用存储为指针，则只需8 bytes (在64位机器上)。
浏览 1提问于2012-11-22得票数 24
回答已采纳
在发布模式下，在Visual 2022中运行以下命令：
#include <chrono>
#include <mutex>
#include <shared_mutex>
#include <iostream>
std::mutex mx;
std::shared_mutex smx;
constexpr int N = 100'000'000;
int main()
{
auto t1 = std::chrono::steady_clock::now();
for (int i = 0; i != N;
浏览 2提问于2021-11-16得票数 12
回答已采纳
3回答
做软件2d像素缓冲，闪存等等。有人告诉我，使用std：：向量来表示对象没有任何开销，我想知道std：：向量是否确实是像素缓冲区的一个好容器，或者我是否应该像我一直使用的那样使用原始数组。
谢谢
浏览 0提问于2012-05-01得票数 3
回答已采纳
auto很好，但是我需要在类中声明一个成员，而不是堆栈中的一个变量。
decltype可以工作，但是看起来有点奇怪
class Automation {
void _init_state(int);
decltype(std::mem_fn(&Automation::_init_state)) next_state;
};
std::function似乎也有效，但与纯成员函数略有不同。
class Automation {
void _init_state(int) {}
public:
decltype(std::mem_fn(&Automa
浏览 4提问于2015-07-24得票数 5
回答已采纳
假设我在内存中有一个存储c_string的字符缓冲区，并且我希望以一种高效的方式将包含该c_string内容的std::string对象添加到标准容器(如std::list<std::string> )中。
示例：
#include <list>
#include <string>
int main()
{
std::list<std::string> list;
char c_string_buffer[] {"For example"};
list.push_back(c_string_buffe
浏览 3提问于2022-03-02得票数 1
回答已采纳
在我的理解中，在Rcpp和C++之间转换向量会创建新的向量，如下所示。我的理解正确吗？
在将Rcpp向量转换为C++向量时，我们使用Rcpp::as<T>() (例如，Rcpp::as<std::string>表示Rcpp::CharacterVector)。将创建std::vector<std::string>，并将原始Rcpp元素作为std::string复制到C++矢量中。这意味着修改新创建的C++向量元素不会影响原始的Rcpp向量元素。
在将C++向量转换为Rcpp向量时，我们使用Rcpp::wrap()。创建具有相应类型的Rcpp向量，并将C++元
浏览 20提问于2019-10-27得票数 3
回答已采纳
我正在尝试使用std::function作为回调处理程序。
就像这样，
void some_job( int arg1, std::function<void(int)> & callback )
{
callback( process(arg1) );
}
在本例中，我使用了按引用传递。
但是问题是，我不能保证std::function对象callback仍然存在，因为在我的程序中在异步上下文中执行的函数。
因此，我必须管理函数对象的生命周期，并且我为它想了两种方法。
使用按值传递(副本)
使用std::shared_ptr
我知道st
浏览 1提问于2013-02-20得票数 2
回答已采纳
1回答
在一些在线法官平台上，代码以这样的方式编译和运行：
g++ -O3 -std=c++17 a.cpp
./a.out
我想使用OpenMp并行化我的代码，那么在没有-fopenmp标志的情况下启用OpenMP是可能的吗？
#include <iostream>
using namespace std;
int main() {
#pragma omp parallel for
for (int i = 0; i < 100; i++) {
std::cout << i << std::endl;
}
}
我尝试过将它
浏览 1提问于2020-10-15得票数 0
我想知道编写一个高阶函数的主要区别、利弊，它以std::function或转发引用(例如template<typename F> void hof(F&& fun); )作为输入参数。显然，前者比后者更严格，因为它指定输入可调用对象必须遵守的函数类型。
浏览 4提问于2016-12-05得票数 4
回答已采纳
2回答
为了优化一些重用匹配组的代码，我想知道访问Match.group()是否很昂贵。我试图挖掘的源代码，但代码有点神秘。
一些测试似乎表明，最好将Match.group()的输出存储在变量中，但我想了解调用Match.group()时到底会发生什么，以及是否有其他内部方法可以直接访问组的内容。
一些示例代码说明了它的潜在用途：
import re
m = re.search('X+', f'__{"X"*10000}__')
# do something
# m.group()
# do something else
# m.group()
时
浏览 11提问于2022-01-27得票数 1
回答已采纳
上下文
我正在编写一个具有三个参数的类模板，以便它是可构造的复制/移动、可分配的复制/移动。该类有两个模板参数：(1)名为tree_t的类型；(2)枚举值
enum class bounding_t { bound, unbound };
如果(2)是bounding_t::bound，那么类需要有一个成员const tree_t&；当(2)是bounding_t::unbound时，类不应该有它。为此，我使用了
template <typename tree_t, bounding_t bound>
using base_impl =
std::condition
浏览 10提问于2022-04-18得票数 0
回答已采纳
2回答
我想知道为什么没有像“绑定成员-函数指针”这样的概念，即绑定到特定对象的成员函数指针，因此可以将其视为正常的函数指针。
#include <functional>
struct Foo {
void foo() {}
};
void foo() {}
void call(void(*)()) {}
template<typename T>
void call_mem(void(T::*fn)(), T* x) { (x->*fn)(); }
int main() {
Foo x{};
call(&foo); // wor
浏览 2提问于2020-09-23得票数 0
回答已采纳
我想将lambda传递给一个函数，但是我遇到了将它成功地传递到函数上的问题。该函数选择追加TrueVal或FalseVal，并根据给定的condition创建布尔向量。
我正在使用2019年Visual的ISO C++14标准来编译代码。
#include <iostream>
#include <vector>
using namespace std;
template<typename T, typename T1, typename T2>
vector<bool> ConstructNestedVectorByElements(T c
浏览 1提问于2021-07-06得票数 2
回答已采纳
我是新来的:asio。我需要将shared_ptr作为参数传递给处理程序函数。
例如。
boost::asio::post(std::bind(&::function_x，std：：move(Some_shared_ptr))；
使用std::move(some_shared_ptr)对吗？或者我应该用在下面，
( boost::asio::post(std::bind(&::function_x，some_shared_ptr));
如果两者都是正确的，哪一个是可取的？
提前感谢
问候尚卡尔
浏览 1提问于2021-04-21得票数 0
为什么这种快速排序算法看起来比std::sort更快？我已经检查过以确保它确实对数组进行了排序。我还用相同迭代次数的空心for循环替换了两个排序调用，以测试计时基准，并检查了所有内容。 我还想知道我可以对快速排序进行哪些调整，以允许它递归更多次。也许是某种可变内存管理？ #include <iostream>
#include <vector>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
浏览 46提问于2021-02-02得票数 1
我有一个函数模板，它接受某种可调用类型的参数，并使用std::bind为原始可调用对象创建一个具有预定义参数值的新可调用对象。我用一个转发引用参数和std::forward编写了它，如下所示：
template <typename F>
auto make_example_caller(F &&f) {
return std::bind(std::forward<F>(f), 123, 456, 789);
}
表示绑定对象“持有由std::forward<F>(f)构造的类型为std::decay<F>::type的成员对象
浏览 1提问于2019-07-08得票数 9
回答已采纳
1回答
如何对并行代码进行测试？
、、、
我有一些使用Rayon并行处理的代码，希望能提高它的性能，但是Bencher测量的结果是.最平淡无奇的。我怀疑这可能是我执行基准测试的方式造成的(也许它们是并行运行的？)，所以我测试了一个更简单的例子。
考虑以下基于的并行化代码
#![feature(test)]
extern crate rayon;
extern crate test;
use test::Bencher;
use std::cmp::Ordering;
pub fn sort<T>(arr: &mut [T])
where T: Send + std::cmp::PartialEq +
浏览 2提问于2017-11-18得票数 3
我想知道是否有什么方法可以让std::string发布它正在使用的char*。
我想，在std::string的某个地方，它有一个类型为char*的字段，我想要一些类似于这样的方法：
const char* std::string::release() {
const char* result = __str;
__size = 0;
__capacity = INITIAL_CAPACITY_WHATEVER;
__str = new char[INITIAL_CAPACITY_WHATEVER];
return result;
}
并不是说复制内容是
浏览 7提问于2013-02-07得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
