如何告诉编译器不要创建临时对象？
在编程中，有时候我们希望避免创建临时对象，以提高程序的性能。以下是一些方法可以帮助你告诉编译器不要创建临时对象：
- 使用引用传递：在函数或方法中，使用引用传递参数，而不是值传递。这样，编译器就不需要创建临时对象来传递参数。
void foo(const std::string& str) {
// ...
}- 使用右值引用：在C++11中，可以使用右值引用来避免创建临时对象。右值引用允许你直接访问临时对象的内存地址，而不需要创建副本。
void foo(std::string&& str) {
// ...
}- 使用
std::move()：如果你需要将一个对象的所有权转移给另一个对象，可以使用std::move()函数。这样，编译器就不需要创建临时对象来进行转换。
std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2 = std::move(vec1);- 使用
const关键字：如果一个函数不会修改其参数，可以使用const关键字来避免创建临时对象。
void foo(const std::vector<int>& vec) {
// ...
}- 使用编译器优化选项：一些编译器提供了优化选项，可以帮助你避免创建临时对象。例如，在GCC和Clang中，可以使用
-O2或-O3选项来启用优化。
g++ -O2 main.cpp -o main总之，避免创建临时对象可以提高程序的性能。你可以使用引用传递、右值引用、std::move()、const关键字和编译器优化选项等方法来实现这一目标。
相关·内容
2回答
我必须导入并使用C++项目。但是，如果没有Microsoft Visual Studio，我无法运行它。该项目的作者告诉我，我必须使用Microsoft编译器，因为只有这个编译器可以处理他使用的特定符号(例如，在将对象传递给方法时动态创建对象)。请参见示例。
lights.push_back(Light(Vector(dirx,diry,dirz).normalize(), Color(colr, colg, colb)));
我之前必须创建一个矢量对象，并将其传递给该方法。
有人能告诉我我可以使用哪种编译器吗？我没有足够的位流下载3 gb的Visual Studio。一个我可以在Mac上使用
浏览 0提问于2012-01-04得票数 2
回答已采纳
2回答
我已经阅读了很多关于const参考的文章，但没有找到我想要的东西。你能纠正我关于将临时变量绑定到常量引用以延长生命周期的机制的假设吗？
int Foo(){return 3;}
int main(){
const int& ref = Foo();
return 0;
}
Foo返回一个临时的未命名的值，该值位于寄存器中，通常之后会被清除。将它绑定到const引用告诉编译器不要忽略它，而是使用ref的作用域和名为ref的别名将值保存在内存中。
它是这样工作的吗？
浏览 1提问于2017-02-26得票数 1
4回答
考虑C++中的以下代码：
struct A {A(int);};
A foo() {return static_cast<A>(0);}
A x = foo();
在这里，static_cast<A>(0)通过标准的5.2.9-4创建一个临时对象，这是一个prvalue。标准12.2-1说
类类型的临时变量是在各种上下文中创建的:绑定对prvalue的引用(8.5.3)，返回prvalue (6.6.3)，创建prvalue的转换(4.1，5.2.9，5.2.11，5.4)，抛出异常(15.1)，输入处理程序(15.3)，以及初始化(8.5)。
那么，返回语句是
浏览 0提问于2015-10-30得票数 10
回答已采纳
2回答
如果这个问题已经被回答的话，我很抱歉--我已经搜索过了，但是这是一个很难找到的搜索词，因为通过引用传递更多的一般性问题。
我遇到的问题是，当我编译这类东西时，会收到第4级的警告：
class MyClass
{
public:
MyClass() {};
};
void DoSomethingToMyClass(MyClass& my_class_reference);
void MyRoutine()
{
DoSomethingToMyClass(MyClass());
};
警告(C4239)基本上表示从实例到引用存在一个不可靠的强制转换。我从仔细的检查中学到
浏览 1提问于2013-01-17得票数 2
回答已采纳
foo和bar有什么区别吗：
class A
{
Object __o;
void foo(Object& o)
{
__o = o;
}
void bar(Object o)
{
__o = o;
}
}
据我所知，foo在对象o被调用时不执行任何复制操作，而对赋值执行一次复制操作。被调用时，Bar在对象o上执行一次复制操作，另一次执行赋值操作。所以我或多或少可以说foo使用的内存比bar少2倍(如果o足够大的话)。对吗？
有没有可能编译器将bar函数优化为只在o上执行一次复制操作？即使__o指向参数o的本地副本，而不是创建新副
浏览 0提问于2010-03-22得票数 2
回答已采纳
2回答
例如，我有一个类，它在返回本地对象的构造函数中调用一个函数。我正在尝试使用右值引用来访问这个对象，以避免在内存中进行昂贵的移动。
class MyClass
{
BigObject&& C;
MyClass() : C(f())
{
};
};
BigObject f()
{
return BigObject();
}
但是compiller告诉我，引用成员被初始化为临时值，该临时值在构造退出后不会持续存在。
我还是不明白。我知道在函数作用域中创建的局部对象只存
浏览 1提问于2016-05-30得票数 3
1回答
我还在学习C++。我试图了解评估是如何一步一步地进行的。因此，使用这个简单的例子，一个表达式语句：
int x=8*5- 5；
这就是我认为会发生的事。请告诉我我离目标有多远：
操作数x、8、5和5被“评估”。可能会创建一个临时对象来保存每个值(我对此不太确定)。
8*5计算为40，这是储存在一个临时的。
40 (临时)-5评估为35 (另一个临时)。
35被复制到x中。
所有临时对象都以相反的顺序销毁，它们是以相反的顺序创建的(值被丢弃)。
我至少快猜对了吗？
浏览 2提问于2016-09-11得票数 5
1回答
这段代码
#include <tuple>
struct Foo
{
Foo(const int& value):value_(value){}
//Foo(const Foo&)=delete; // delete copy constructor
int value_;
};
int main()
{
std::tuple<Foo> tup(std::move(Foo(1)));
return 0;
}
工作正常，但是如果删除Foo复制构造函数，它会失败，出现以下编译错误:使用已删除的函数Foo::Fo
浏览 1提问于2015-09-28得票数 1
回答已采纳
2回答
我有时读到，当我调用构造函数时，它会创建临时对象，然后将其复制到真正的变量中。所以我不应该把一些东西放到构造器中，比如创建对象的计数器等，并且创建对象的一些语法应该比其他语法更快？
A a(10);
A a = 10; // temporary object?
A a = A(10); // temporary object?
那么我应该使用哪种类型的构造函数呢？
浏览 3提问于2013-04-03得票数 0
回答已采纳
9回答
我在教自己C++，在这个过程中，我编写了一些简单的小程序来学习基本思想。关于“按引用传递”，我不明白为什么下面的代码可以工作(其中一些代码只是为了练习重载构造函数)：
#include <iostream>
#include <string>
using namespace std;
class Dude
{
public:
string x;
Dude(); // Constructor 1
Dude(const string &a); // Constructor 2
};
Dude::Dude(
浏览 10提问于2011-11-02得票数 3
回答已采纳
我试图使用引用指针将值发送到函数中，但它给了我一个完全不明显的错误。
#include "stdafx.h"
#include <iostream>
using namespace std;
void test(float *&x){
*x = 1000;
}
int main(){
float nKByte = 100.0;
test(&nKByte);
cout << nKByte << " megabytes" << endl;
cin.
浏览 1提问于2013-07-21得票数 62
回答已采纳
下面的代码在C++中可以接受吗？如果是，会发生什么？它是否创建了一个临时字符串变量并传递其地址？
void f(const string& s) {
}
const char kJunk[] = "junk";
f(kJunk);
浏览 3提问于2013-11-28得票数 2
回答已采纳
它可以工作，不会崩溃。可以吗？
编辑:我这么问的原因是std::string s = "a" + "b" + "c";会产生一个编译器错误，而(std::string)"a"只是告诉编译器，“假设"a”指向的是一个std::string“。我实际上并不知道std::string是如何实现的。
感谢大家的反馈。
浏览 8提问于2011-02-01得票数 4
回答已采纳
1回答
在iOS 7(和更早的版本)中，可以有效地创建“临时”NSManagedObject，并在以后将其添加到上下文中并持久化，如下所示：
NSEntityDescription* entityDescription = [NSEntityDescription entityForName:@"User" inManagedObjectContext:managedObjectContext];
User* user = [[User alloc] initWithEntity:entityDescription insertIntoManagedObjectContext:nil]
浏览 2提问于2014-08-20得票数 5
回答已采纳
1回答
在C++中，当按值抛出对象时，例如:抛出异常()，这将创建临时对象，如何通过引用捕获它？我知道它可以工作，但是如果它是一个函数返回值或函数调用，如果不将const添加到类型中，它就会失败，有什么区别呢？
浏览 3提问于2015-03-08得票数 7
回答已采纳
请考虑下面的代码
struct A { int m; };
int main()
{
A a; // I beleive this should put space on the stack with sizeof(A) bytes
a = A{5};
}
将a放入堆栈后，创建另一个A对象后的代码行是将其设置为a，还是仅设置a中的值
浏览 2提问于2018-07-09得票数 0
3回答
我有以下问题。我有一个带有getInstance成员函数的单例函数，该函数返回一个实例。我在代码中的某个地方调用了它，出于某种原因，VC试图调用复制构造函数。为什么会这样呢？我该如何解决这个问题？
标题：
class FileSystemEntryCollection {
public:
static FileSystemEntryCollection &getInstance();
private:
FileSystemEntryCollection();
FileSystemEntryCollection(FileSystemEntryCollection
浏览 0提问于2012-08-19得票数 5
回答已采纳
下面的C++代码是格式良好的：
void consumer(char const* p)
{
std::printf("%s", p);
}
std::string random_string_generator()
{
// returns a random std::string object
}
consumer(random_string_generator().c_str());
我遇到的问题是，在创建临时std::string对象并获取c_str()指针之后，没有任何东西可以阻止std::string对象被销毁(也许我错了？)。你能告诉我标准吗，如果代码
浏览 3提问于2012-04-04得票数 65
回答已采纳
3回答
我是valgrind的新手，所以我可能会做一些错误的事情，但是如果valgrind报告的空闲数比分配数多，我该怎么办？
这里有一个SSCCE：
#include <cstring>
class something
{
protected:
char* ptr;
public:
something() {ptr = NULL;}
something(const char* value) {
ptr = new char[strlen(value)+1]; strcpy(ptr, value);
}
~something() {
浏览 0提问于2012-04-28得票数 3
回答已采纳
1回答
我发现，接受单个参数的构造函数称为转换构造函数(c++03).But，这是否意味着特定的构造函数将隐式创建一个临时对象，并将其分配给所需的对象？(对我们来说是不可见的？)那么，编写EgClass m=EgClass(1)和EgClass m=1 to (1) typecast int到EgClass有什么不同？(如果是这样的话，这种情况是如何发生的？)另外，当我们编写EgClass m(1)时会发生什么？
浏览 2提问于2015-12-27得票数 0
回答已采纳
例如，如果你有下面这段代码，会发生什么？
int mean(const vector<int> & data) {
int res = 0;
for(size_t i = 0; i< data.size(); i++) {
res += data[i];
}
return res/data.size();
}
vector<int> makeRandomData() {
vector<int> stuff;
int numInts = rand()%100;
for(int i = 0; i< num
浏览 2提问于2010-09-02得票数 4
回答已采纳
4回答
myClassVar = MyClass(3);
我希望在前面创建的左侧myClassVar上调用析构函数。
但是它实际上是在MyClass(3)创建的新对象上调用的。
我的完整测试代码和输出如下..
编辑
我该怎么解决这个问题？
执行赋值操作符？
MyClass实际上有指针，MYSQL_STMT*，我想知道如何处理MYSQL_STMT*变量。
我只需要MyClassVar(3)对象，而不是在创建ClientClass对象时第一次创建的MyClassVar()。
我经常遇到这种情况，我想知道是否有一个好的方法。
#include <stdio.h>
class MyClass
浏览 8提问于2011-10-28得票数 5
回答已采纳
1回答
我的程序运行时崩溃了。如果我注释掉行if((str1->compare(*str2))==0 ){...}，它可以正常工作。我不知道如何比较字符串*的两个元素，这是我在比较后创建和删除的。
main.cpp: In function `int operator==(const Integer&, const Integer&)':
main.cpp:18: warning: taking address of temporary
main.cpp:19: warning: taking address of temporary
Integer.h
class In
浏览 2提问于2012-05-22得票数 0
回答已采纳
3回答
我对关于复制选择的新规则有点困惑，实际上，我甚至不确定它是否适用于这种情况。我有这个：
template <typename T> struct foo {
T t;
foo(const T& t) : t(t) {}
~foo() { std::cout << "destructor \n"; }
}
template <typename T> foo<T> make_foo(const T& t) { return {t}; }
其中，make_foo只允许推断参数(在实际代码中，t是
浏览 0提问于2018-03-20得票数 2
回答已采纳
3回答
C++临时变量寿命
、、、、
这个代码有效吗？
int foo()
{
std::vector<std::string>& v = std::vector<std::string>(5, "X");
// Do something silly...
return 42;
}
出于某种原因，我认为临时std::vector对象(从赋值符号开始)应该在其构造后立即销毁(从而使引用无效)。
但是，调试证明我错了，而且，我意识到我不太明白为什么当函数返回时临时变量会被破坏。
我想我对一些基本的东西有强烈的误解，所以请告诉我:)
浏览 6提问于2012-05-10得票数 5
回答已采纳
3回答
c++继承问题
、、、
我对此有一个问题：
class A
{
int a;
int* pa;
public:
A(int i):a(i) , pa(new int(a))
{
cout<<"A ctor"<<a<<endl;
}
~A()
{
delete pa;
cout<<"dtor\n";
}
int * &get()
{
return pa;
}
};
class B : public A
{
浏览 18提问于2011-02-05得票数 0
回答已采纳
一种方法；
Sterling operator+(const Sterling& o) const {
return Sterling(*this) += o;
}
"Sterling(* this ) += o“这一行是否在堆栈内存中创建了一个新对象？如果为真，它如何将堆栈中的对象返回到方法外部？
我可以这样做吗：
Sterling operator+(const Sterling& o) const {
return *this += o;
}
因为我认
浏览 0提问于2011-05-18得票数 3
回答已采纳
1回答
以下是我的C++书的引文：
当我们使用直接初始化时，我们要求编译器使用普通函数匹配来选择与我们提供的参数最匹配的构造函数。当我们使用复制初始化时，我们要求编译器将右边的操作数复制到正在创建的对象中，如果有必要，可以使用转换该操作数.。
对我来说，这个粗体的部分产生了一点模糊。它使它听起来像右手操作数被转换成类类型，然后使用复制构造函数，例如；
string s = "hello";
会变成..。
string s = string("hello");
它使用复制构造函数。如果这是真的，那么我的测试程序；
#include <iostream>
浏览 1提问于2015-08-25得票数 2
回答已采纳
3回答
下面的代码介绍了一个类C。该类有构造函数、复制构造函数、operator=和一个成员。如何在main()函数中获取C(2)创建的对象的地址？
#include <iostream>
class C
{
public:
int a;
C(const C &other)
{
std::cout << "Copy Constructor:" << a << std::endl;
}
C(int a)
{
this->a
浏览 0提问于2011-11-18得票数 2
回答已采纳
1回答
我有以下代码：
constexpr const_reference_t at(size_t p_pos) const
{
using namespace std;
return (p_pos > m_size)
? throw out_of_range{ string{ "string_view_t::at: pos > size() with pos = " } + to_string(p_pos) }
: m_begin_ptr[p_pos];
}
在编译时，g++告诉我：
/home/martin/Projek
浏览 1提问于2017-10-06得票数 1
当我们用C语言编程时，会创建多少个文件，比如一个".exe“和一个".obj”。是否创建了其他文件？谢谢!
浏览 6提问于2013-09-21得票数 0
回答已采纳
我有一个问题，在初始化对象时有和没有构造函数成员初始化列表的区别。
在下面的代码片段中，有两个类Test1和Test2，每个类都有两个构造函数，这两个类的对象是在另一个类Example的默认构造函数中创建的。Test1的对象是在成员初始化程序列表中用一个参数创建的，而Test2的对象则是在Example的构造函数体中使用一个参数创建的。
class Test1 {
public:
Test1() { cout << "Test1 is created with no argument"; }
Test1(int a) { cout <
浏览 0提问于2018-12-25得票数 1
回答已采纳
1回答
std::string &func(int vlu)
{
std::string str;
str = std::to_string(vlu) + "something";
return str;
}
上述功能显然是不安全的。
以下是另一个版本。
std::string &func(int vlu)
{
return std::to_string(vlu) + "something";
}
我有一些问题：
在第二个版本中，编译器(Gcc)没有给我任何警告。安全吗？我只是觉得那个编译器(或者别的什么？)将创建一
浏览 1提问于2018-10-29得票数 9
回答已采纳
我对编程很陌生。我想创建一个请求您的信息并将其保存到文本文件中的应用程序(但稍后会出现)。
我被困在这里，我应该让程序读到用户输入的内容：
char nimi[20];
int aika;
int ika;
char juoma[3];
cout << "Hello!\nWhat's your name?\n";
cin >> nimi;
cout << "\n\nHi ";
cout << nimi;
cout << "!\n";
cout << "\nE
浏览 4提问于2014-02-07得票数 1
回答已采纳
4回答
按值返回内联函数
、、、
我正在实现一些数学类型，并希望优化运算符，以最小化创建、销毁和复制的内存量。为了演示，我将展示我的四元数实现的一部分。
class Quaternion
{
public:
double w,x,y,z;
...
Quaternion operator+(const Quaternion &other) const;
}
我想知道下面这两个实现有什么不同。我确实有一个+=实现，它在没有创建内存的地方就地操作，但是一些使用四元数的高级操作使用+而不是+=是有用的。
__forceinline Quaternion Quaternion::operator+(
浏览 1提问于2009-08-21得票数 7
回答已采纳
这个问题的题目是个口头禅。基本上，我正在创建一个哈希表结构，它在向量中使用双链接列表。当我使用重载的构造函数创建对象时，一切都很好，但是使用默认构造函数会使对象的状态在返回main后变得异常。
我的建设者：
HashTable::HashTable()
{
HashTable(53);
}
HashTable::HashTable(int tableSize)
{
currentSize = tableSize;
table.resize(tableSize);
}
创建对
浏览 2提问于2014-04-12得票数 0
回答已采纳
1回答
下面是具有默认构造函数和复制构造函数的MyStruct类实现。
struct MyStruct {
MyStruct(const string& name) {
cout << "Basic constructor called" << endl;
name_ = name;
}
MyStruct(const MyStruct& S) {
cout << "Copy constructor called" << endl;
浏览 3提问于2020-07-29得票数 0
4回答
我正在读Eckel中的常量一章，并被解释时间的部分搞混了。我能得到的是，当我们将引用传递给一个函数时，编译器会创建一个临时的常量对象，因此即使我们将引用作为
f(int &a){}
现在，我试着在网上查看一些其他的临时参考资料，但我被困住了。
和
这让我意识到，临时库不仅仅是传递引用和创建常量对象，在functions.Now中我可以从这两个链接中获得一些东西，但不能说我已经理解了临时库的工作原理、功能和使用。如果有人能解释一下时间的概念，那将是非常有帮助的。提前谢谢。
bruce eckel的原始示例是：
// Result cannot be used as an lvalue
浏览 1提问于2013-02-28得票数 12
回答已采纳
3回答
我正在从java迁移到c++，并且我正在尝试理解构造/析构对象。当我这样做的时候
Myclass c=createANewObject();
c=createANewObject();
旧的c是垃圾回收的，另一个c是用相同的名称创建的。
如果我试图在c++中做同样的事情，我会得到奇怪的行为。
class my_class
{
string content;
time_t t;
public:
my_class(string c);
~my_class();
};
my_class::my_class (string c)
{
content=c;
cout<<"In
浏览 1提问于2016-02-23得票数 7
假设我有以下(非常粗略的)代码
class foo
{
public:
int a;
foo() //Regular constructor
{
......
std::cout << "Regular \n";
}
foo(foo& f) //Copy constructor with with non-const parameter
{
....
std::cout << "Copy Constructor \n
浏览 4提问于2015-02-21得票数 2
回答已采纳
1回答
我有一个关于C++标准遵从性或缺乏的问题。
在我的项目中，我使用了一些简单的Guard类，这个类使用了const引用技巧。我使用的是Visual Studio2005，有两种配置--一种用于普通发布版本，另一种用于单元测试。
在这两种情况下，最后在const引用上都有一些临时挂起，但在此期间发生的是问题。对于发布配置，const引用直接指向在创建Guard实例的helper函数模板的返回中创建的temp (没有调用任何复制构造函数，甚至没有为此进行实例化)。
但是对于单元测试conf，首先复制函数模板temp，然后调用其析构函数，仅在const引用超出范围后才执行应该执行的操作。
我已经通过禁
浏览 8提问于2010-11-03得票数 3
回答已采纳
在阅读了Scott的“更有效的C++”一书的第20和第22项之后，我决定问这个问题。
假设您编写了一个类来表示有理数：
class Rational
{
public:
Rational(int numerator = 0, int denominator = 1);
int numerator() const;
int denominator() const;
Rational& operator+=(const Rational& rhs); // Does not create any temporary objects
...
浏览 4提问于2018-01-24得票数 6
回答已采纳
3回答
可能重复：
我已经看到了关于int a() const的不同帖子。我的问题是，为什么我们要把const关键字放在那里？我知道它阻止了我们对函数所在的类的成员进行更改，但那又怎样呢？
我们可以在函数上面写一个注释，告诉编码器不要在函数中对类本身做任何更改，但是为什么我们在const声明之后才真正关心void呢？在哪种情况下可能有更好的方法来使用，例如int a() const，而不仅仅是int a()，编译后的代码会发生根本的变化吗？
浏览 3提问于2013-01-14得票数 1
回答已采纳
关于关键字new和&在特定上下文中的区别，我有一些问题。
假设这是我的代码：
struct Base {};
struct Foo : Base {};
struct Storage
{
void save(Base * object) {}
Base * content;
};
int main()
{
Storage s1, s2;
s1.save(new Foo());
s2.save(&Foo());
}
执行main后，s1将保存指向Foo类型对象的指针。然而，s2将保存指向Base类型对象的指针。在保存方法完成执行之前，s2
浏览 3提问于2018-12-30得票数 18
回答已采纳
4回答
多重继承中的多义性
、、、
假设我有一段简单的代码
#include <iostream>
using namespace std;
class A {
public:
void show() {
cout << "A" << endl;
}
};
class B {
public:
void show() {
cout << "B" << endl;
}
};
class C:public A, public B {
};
int main()
{
浏览 0提问于2016-07-19得票数 2
1回答
创建一个临时char缓冲区作为默认函数参数，并将r值引用绑定到它，允许我们在一行上组合语句，同时避免了在堆上创建存储的需要。
const char* foo(int id, tmp_buf&& buf = tmp_buf()) // buf exists at call-site
将引用/指针绑定到临时缓冲区并随后访问它，会产生未定义的行为，因为临时缓冲区不再存在。
从示例应用程序中可以看到，tmp_buf的析构函数在第一个输出之后和第二个输出之前调用。
我的编译器(gcc-4.8.2)不会警告我将变量绑定到临时变量。这意味着，使用这种微优化来使用自动字符缓冲区而不是具有关联堆
浏览 3提问于2014-11-20得票数 2
1回答
我有这个密码
class MyString {
public:
MyString();
MyString(const char*);
MyString(const String&);
MyString(String&&) noexcept;
...
};
String::String()
{
std::cout << "default construct!" <<std::endl;
}
String::String(const c
浏览 8提问于2021-10-27得票数 0
回答已采纳
我有一个由a调用的两个存储过程a和b，B，在创建的一个临时表中，并且在试图访问sp的临时表的sp B中，在编译时得到丢失对象的错误。
浏览 0提问于2009-10-07得票数 0
函数structFromVector()从结构向量返回一个结构。如果您编译下面的代码，那么foo1Ptr->a是一个空向量，但是foo2Ptr->a是一个向量，其唯一的元素是1。为什么在第一种情况下未初始化结构？
如果a是一个int，而不是一个向量，而不是a.push_back(1);，那么foo1Ptr->a和foo2Ptr->a都等于1。为什么在这种情况下，它不工作呢？
struct Foo {
std::vector<int> a;
Foo() {
a.push_back(1);
}
};
std::vect
浏览 1提问于2015-05-22得票数 0
回答已采纳
我认为下面的代码应该会产生一个错误：
#include <iostream>
#include <string>
static void pr(const std::string &aStr)
{
std::cout << aStr << "\n";
}
int main(void)
{
const char *a = "Hellu";
pr(a);
return 0;
}
但gcc 4.1.2成功地编译了它。
是不是std::string的构造函数妨碍了创建std:
浏览 0提问于2012-07-02得票数 7
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
