更改其类型后丢失对std::variant对象的引用
在C++编程语言中，std::variant是一个通用联合类型，它可以存储不同类型的值。然而，当我们改变std::variant对象的类型后，如果之前的类型与新的类型不匹配，就会丢失对std::variant对象的引用。
当我们创建一个std::variant对象时，它可以持有多个不同的类型。我们可以使用std::visit函数来访问std::variant对象中当前持有的值。然而，当我们试图更改std::variant对象的类型时，情况就变得复杂了。
在尝试更改std::variant对象的类型之前，我们需要确保当前的类型与要更改的类型匹配。否则，我们会丢失对std::variant对象的引用。
例如，假设我们有一个std::variant<int, float, std::string>对象：
std::variant<int, float, std::string> var = 10; 如果我们尝试将其类型更改为std::string，那么一切都正常：
var = std::string("Hello"); 在这种情况下，我们没有丢失对std::variant对象的引用，因为std::variant对象仍然持有一个std::string类型的值。
然而，如果我们尝试将其类型更改为double，那么问题就出现了：
var = 3.14; // 错误！类型不匹配 由于当前持有的值是std::string类型，而不是double类型，所以我们无法将其更改为double类型。这将导致对std::variant对象的引用丢失。
解决这个问题的一种方法是使用std::get函数来获取std::variant对象中当前持有的值，并在更改类型之前将其保存到临时变量中。然后，我们可以使用std::variant的emplace函数来更改类型并将之前保存的值重新存储回去。这样可以避免丢失对std::variant对象的引用。
例如，我们可以这样做：
std::string oldValue = std::get<std::string>(var); // 获取当前持有的值 var.emplace<double>(3.14); // 更改类型为double var = oldValue; // 将之前保存的值重新存储回去 通过这种方式，我们可以在更改std::variant对象的类型后仍然保留对其引用。
在腾讯云的产品中，没有直接与std::variant相关的产品或服务。然而，腾讯云提供了丰富的云计算和云服务解决方案，如虚拟机、云存储、人工智能、区块链等，可以满足各种需求。您可以访问腾讯云的官方网站（https://cloud.tencent.com/）了解更多信息。
相关·内容
2回答
我正在尝试尝试使用std：：变体。我将std：：变体存储为类的成员。在下面的代码中，如果变量是按值存储的，那么就可以正常工作，但是如果变量是通过引用存储的，则不能工作(对于向量情况和自定义对象也是如此)。为什么会这样呢？
#include <variant>
#include <vector>
#include <iostream>
template<typename T>
using VectorOrSimple = std::variant<T, std::vector<T>>;
struct Print {
浏览 2提问于2016-12-14得票数 1
回答已采纳
1回答
我对新的std::variant类型有一些疑问。我考虑把它作为工会的另一种选择。我编写了一些应该在在线编译器中编译的测试代码。在std：：变体中，我还没有找到很多关于std::array之类类型的存储信息。原始缓冲区存储(例如uint8_t 4)似乎不可能在std::variant中使用。
#include <iostream>
#include <array>
#include <variant>
#include <array>
#include <stdint.h>
#include <typeinfo>
#incl
浏览 4提问于2020-03-21得票数 0
回答已采纳
1回答
我有一个std::variant，其中所有的类都是从同一个基派生的。我想把变体投给基地。
return std::visit( []( const Base& b ) { return b; }, v );
这会编译但给出警告C4172:返回局部变量或临时地址
是否有一种方法可以访问std::variant，而不制作本地或临时副本？
或者，如果这是不可能的，我如何将值转换为void*，以便我可以使用static_cast？
更新：--我认为这个例子应该是显而易见的，但是它不是，这里是完整的repro：
#include <variant>
struct Base {};
浏览 0提问于2018-12-20得票数 3
回答已采纳
2回答
我试图使用我创建的简洁的JSON解析库将这段JSON转换为C++类型。
[
"a",
[
"b",
[
"c",
[
"d",
["... so on so forth"]
]
]
]
]
目前，这在技术上是C++中的类型，但是这显然是无效的，因为typename不能引用它自己：
typename std::variant<std::string, s
浏览 5提问于2022-04-20得票数 1
回答已采纳
2回答
包装器类常量正确性问题
、、、、
我正在尝试为JsonCpp的Json::Value创建一个包装器。
我有一个名称空间global，其中有处理Json::Value&参数的函数。我想为这些函数创建一个更符合语法的包装类。
这是一个最小的例子。
// Impl is a typedef for Json::Value, from JsonCpp
namespace global
{
Impl& getChild(Impl& mImpl, const std::string& mName) { return mImpl[mName]; }
const Impl& getCh
浏览 0提问于2013-07-04得票数 1
回答已采纳
1回答
结构问题1.cpp
// Struct Problem 1.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
#include "structs.h"
double calculateEarnings(Advertising aDay);
void displayEarnings(int questionInstance, Advertising aDay);
void mainQues
浏览 0提问于2015-03-19得票数 0
假设我有一个Variant类，它可以表示各种POD类型，外加std::string，并且我有一个模板方法T get_value(const Variant&)，可以从中提取底层类型。
假设我有一个这些的向量，即。std::vector<Variant> variants;，我想用一种方便的语法从其中读取几个值，如下所示：
int x;
double y;
std::string z;
// Get elements 0, 1, and 2 as int, double, and string respectively
streamlikeObject >> x
浏览 1提问于2011-06-30得票数 2
回答已采纳
2回答
假设我有下面的class A，它通过不同的函数调用和包装器传递。
class A{
std::vector<int> a;
public:
int getSize const {return a.size();}
int getVal(int i) const {return a[i];}
// other private and public members and functions
}
出于某种原因，我需要同一个类，但需要一个双向量。我不能临时处理这个类，因为有许多函数签名是我无法更改的。建议将A重命名为A0，将其临时化，创建包含A0<int>和A0<do
浏览 4提问于2020-02-26得票数 0
回答已采纳
这样的电话有可能过载吗？
f("st");//variant 1
struct Foo { char buf[3]; Foo() { strcpy(buf, "aa"); } };
const Foo foo;
f(foo.buf);//variant 2
在这两种情况下，typeid给出了相同的类型，是否有任何变体来区分上面f的两个调用，并且有两个f的变体？我试过std::is_rvalue_reference，但没有成功。
浏览 7提问于2015-09-11得票数 3
回答已采纳
我编写了以下代码(部分复制:)：HigherOrderFunctions.h：
#ifndef HigherOrderFunctions_H
#define HigherOrderFunctions_H
#include <algorithm>
class HigherOrderFunctions {
public:
template<class Coll, class Func>
static Coll& filter(Coll& items, Func&& filterFunc);
private:
Higher
浏览 0提问于2018-02-21得票数 0
回答已采纳
1回答
下面是一个简单的例子，我们可以定义这样一个低级别的union：
static union
{
uint64_t a;
uint8_t b[8];
};
但是我们不能这样声明std::variant (请不要关心语法，如果我错了，请纠正我！，抓住这个想法)
std::variant<uint64_t, uint8_t[8]> v
明确表示，
模板参数
类型-可以存储在此变体中的类型。所有类型都必须是(可能是cv限定的)非数组对象类型。
此外，MSVC-v141(C++17)编译器给出了一个编译错误：
Error C2338变量要求所有Ts都是非数组对象类型(
浏览 0提问于2018-03-15得票数 12
回答已采纳
我很好奇delete操作符如何知道在基本指针上调用delete时派生类的大小，下面是一个很小的例子：
class IVariant
{
public:
virtual ~IVariant() = default;
virtual void print_value() = 0;
};
template<typename T>
class Variant: public IVariant {};
template<>
class Variant<int>: public IVariant
{
private:
int m_intege
浏览 4提问于2017-02-16得票数 3
回答已采纳
2回答
我拥有一组非默认的可构造类(甚至可能是不可移动的/不可复制的和不可复制的/移动的)类，这些类具有本质上不同的非默认构造函数原型，如下所示：
#include <boost/variant.hpp>
#include <string>
#include <list>
struct A { A(int) { ; } };
struct B { B(std::string) { ; } };
struct C { C(int, std::string) { ; } };
using V = boost::variant< A const, B const
浏览 1提问于2013-05-16得票数 0
下面是一个我不太明白的代码片段。请参阅这两行的注释。为我能找到解释的一方的每一个解释或参考感到高兴。
我不太明白发生了什么事，以及out =*命令出了什么问题；
#include <variant>
struct Buffer
{
struct StructA
{
int X = 10;
};
struct StructB
{
int X = 20;
};
浏览 8提问于2022-10-28得票数 1
回答已采纳
通过下面的代码，我得到了：
In static member function ‘static std::shared_ptr<std::variant<MyClass<InputClass1>, MyClass<InputClass2> > > MyCreatorClass::create()’:
main.cpp:34:57: error: could not convert ‘std::make_shared(_Args&& ...) [with _Tp = MyClass; _Args = {}]()’ from
浏览 1提问于2022-09-06得票数 -3
回答已采纳
我有一个boost::variant，并且我只想在variant是特殊类型的情况下执行一个函数，所以我构造了这个函数：
template<typename T, typename Variant>
void if_init(Variant& opt_variant, std::function<void(T)> functor){
if(auto* ptr = boost::get<T>(&opt_variant)){
functor(*ptr);
}
}
这工作得很好，但是我想要推导出T类型，这样我就可
浏览 1提问于2013-02-09得票数 4
回答已采纳
这个问题决定了不可复制类型不能与Boost变体一起使用
Tree类
template <class T = int>
class Tree{
private:
class TreeNode{
public:
std::unique_ptr Nodes
Move constructors and move assignment + other public members
private:
TreeNode(const
浏览 5提问于2013-03-28得票数 8
回答已采纳
1回答
我目前正在处理的代码有它自己的RefPtr实现，这是随机失败的。
我怀疑这可能是一场经典的数据竞赛。RefPtr有一个指向从RefCounted类继承的原始对象的指针。这个类包含一个非原子的引用计数器(m_refCount)，一个应用程序在某些线程中崩溃，通过RefPtr访问对象。就像RefPtr下的物体被毁了一样。完全不可能。
RefPtr持有的对象实例也由另外两个不修改它(或其内容)的对象保存，我100%确信它们对它具有共享所有权(因此m_refCount不应低于2)。
我确实尝试用std::shared_ptr替换指针，但是崩溃仍然存在。
代表此问题的精馏代码：
class Shared
浏览 3提问于2017-01-26得票数 0
std::variant有一个构造函数，它接受导致就地构造的std::in_place_t<Type>, Args &&...参数。
{
std::cout << "in_place_type:\n";
const auto var = std::variant<callable>(std::in_place_type<callable>);
std::cout << "finished\n";
}
我想知道是否有可能在给定
浏览 17提问于2022-09-16得票数 1
回答已采纳
对于std::any和std::variant，我们有一些函数可以请求对象当前包含的值，如果请求不能满足，这些函数会返回nullptr (就像dynamic_cast一样)：
template<class ValueType>
const ValueType *any_cast(const any *operand);
template<class ValueType>
ValueType *any_cast(any *operand);
和
template <class T, class... Types>
std::add_pointer_t<
浏览 1提问于2016-07-27得票数 7
6回答
#include <iostream>
#include <string>
class A
{
public:
A(int a) : _a(a) {}
virtual ~A() {}
virtual void f() const {std::cout << _a << std::endl;}
private:
int _a;
};
class B : public A
{
public:
B(int a, int b) : A(a), _b(b) {}
virtual void f() const
浏览 0提问于2010-10-04得票数 4
回答已采纳
1回答
我正在使用std::variant和std::visit使用如下所示的：
#include <iostream>
#include <variant>
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
int main(void) {
std::variant<int, float>
浏览 3提问于2020-07-13得票数 3
回答已采纳
2回答
std::variant可以进入一个名为"“的状态。
据我所知，造成这种情况的共同原因是移动分配抛出异常。变体的旧值不再被保证存在，也不再是预期的新值。
然而，std::optional没有这样的状态。claim大胆地宣称：
如果引发异常，则初始化状态为*this .不变，也就是说，如果对象包含一个值，它仍然包含一个值，而反过来。
std::optional如何才能避免“例外而无价值”，而std::variant却并非如此？
浏览 0提问于2019-08-28得票数 14
回答已采纳
我正在学习一个开源应用程序的代码。我对这段代码做了一个更简单的版本，以隔离一些困扰我的东西(尽管我对这段代码有几个问题，我希望C++专家能够帮助我，我将从主要的代码开始)。
主要问题:为什么分配给std::map的对象的类需要一个“空”构造函数(没有参数)？
主要思想(参见下面的代码)是将变量类的实例分配给std::map (其键为std::string)。以下是代码：
#include <iostream>
#include <map>
#include <string>
#include <memory>
struct Data
{
pub
浏览 8提问于2022-08-16得票数 0
回答已采纳
我看到了与valueless_by_exception方法有关的cppreference的以下注释：
变体在下列情况下可能变得毫无价值：
在移动assignment(optionally)期间，在移动包含的值的移动初始化过程中抛出异常，在复制分配的(有保证的)期间抛出异常。
所以，这样的代码
std::variant<MyClass> var = {...};
var = myClassObj;
不需要使var.valueless_by_exception()等于true (并且可能会使var处于以前的状态)，但是下面的代码
std::variant<MyClass>
浏览 7提问于2022-04-22得票数 3
回答已采纳
目标是拥有一个可以改变其行为的对象。
我的对象是包装器，它应该调用一个：：处理程序()并输出“一个”，而不是从情境：：处理程序()输出“来自虚拟处理程序”。
我没有写变更方法是因为我在这里。
#include <iostream>
class Situation
{
public:
virtual void handler()
{
std::cout<<"from virtual handler()";
}
};
class Wrap
{
private:
Situation _sit;
public:
浏览 6提问于2017-12-30得票数 0
回答已采纳
在查看一些代码时，我遇到了一个带有以下行的构造：
if (const auto& foo = std::get_if<MyType>(&bar)) // note the ampersand!
其中bar是std::variant<MyType, OtherType>。这里的问题是，get_if 和我不明白为什么这个语句有效。
考虑一下类似的MCVE：
#include <iostream>
struct Foo { int a = 42; };
Foo* f() { return nullptr; }
int main() {
浏览 0提问于2019-05-09得票数 7
回答已采纳
在下面的示例中，是否可以创建一个遍历变体案例并获取x变量的函数getX？
#include <variant>
class A {
int x = 0;
};
class B {
int x = 1;
};
class C {
int x = 1;
};
std::variant<A, B, C> variant;
一个显而易见的解决方案是：
int getX(std::variant<A, B, C>& variant) {
if (std::holds_alternative<A>(varian
浏览 10提问于2021-05-27得票数 0
回答已采纳
2回答
这是一个C++代码，它很简单，但我得到的错误，我不明白。
我不知道如何使用重载的operator ()，但我这样做了。
程序应该执行以下操作。
输入你的单词:编程
编号:5
P
按下
专业人士
编程
孕产
我得到的错误：
“std：：cout << Word：：operator()(Int)(N)”中的“operator<<”不匹配
Word.h
#ifndef WORD_H
#define WORD_H
class Word
{
private:
char *st
浏览 3提问于2014-11-30得票数 3
回答已采纳
1回答
Boost变体文档表示接受任意类型的构造函数的以下内容：
template<typename T> variant(T & operand);
要求：T必须明确地可转换为有界类型之一(即T1、T2等)。
接受const T&和T&&的构造函数也是如此。因此，我希望下面的代码不会编译：
boost::variant<std::string, bool> v = "text";
但是代码编译，v变成了一个bool，这是我绝对不想要的。当然，解决方案是将字符串文字包装在std::string构造函数中。我的问题是：
浏览 3提问于2014-09-12得票数 8
回答已采纳
为什么模板变体返回类型会导致bad_variant_access异常？
Unhandled exception at 0x779508B2 in Project2.exe: Microsoft C++ exception: std::bad_variant_access at memory location 0x00B3FB00.
在另一个较大的程序中，main中的语句执行时没有错误，但输出了一些142以外的奇怪值。这似乎是一种未定义的行为。
/////////////////////minified_main.cpp/////////////////
#include <iostrea
浏览 2提问于2019-10-24得票数 1
回答已采纳
考虑：
#include <variant>
#include <iostream>
int main()
{
double foo = 666.666;
std::variant<double, uint64_t> v = foo;
std::cout << std::get<uint64_t>(v) << std::endl;
return 0;
}
这导致：
terminate called after throwing an instance of 'std::bad_va
浏览 9提问于2020-04-15得票数 2
回答已采纳
2回答
为了阻止的评论中的论点，我想对以下问题作出一些建设性的回答：
引用的生存期是否与它所引用的对象不同？引用仅仅是其目标的别名吗？
在一个结构良好的程序中，引用是否能够在不导致未定义的行为的情况下超过其目标？
如果为原始对象分配的存储被重用，可以引用新对象吗？
下面的代码是否在不调用未定义的行为的情况下演示了上述点？
由编写并简化的示例代码(在上运行)：
#include <iostream>
#include <new>
struct something
{
int i;
};
int main(void)
{
char buf
浏览 2提问于2012-02-15得票数 6
回答已采纳
我想问，有这样的变体安全吗？
struct A
{
unique_ptr<T> anything;
};
struct B
{
int x = 0;
int y = 0;
};
variant<A, B> myVar;
myVar = ... A object;
myVar = ... B object;
myVar = ... another A object;
会对所有编译器调用std::unique_ptr析构函数吗？其想法是创建一个std::array of variant<A, B>，以便在FIFO中使用它。在Visual
浏览 4提问于2022-01-20得票数 4
回答已采纳
3回答
如果我有一种类型为std::is_nothrow_move_constructible，并且需要将其存储在std::any或std::variant中，那么您建议使用哪一种?为什么？哪一个的开销最小？编辑：std::variant和std::any的不同用例是什么？
class MyType
{
public:
MyType(const MyType&) = default;
MyType(MyType&&) = default;
MyType() = default;
};
int main(int argc, char* argv[])
{
浏览 8提问于2017-09-05得票数 5
回答已采纳
3回答
假设我有一个A类，它指定到int的转换
struct A {
int val = 42;
operator int() const {
return val;
}
所以我可以这样用它：
A a;
int a_int = a;
但是，如果我想使用指向该类的共享指针，怎么办：
auto a_ptr = std::shared_ptr<A>(new A);
int a_int = a_ptr; // ???
就像A类型的变量被隐式转换为int一样，我也希望对智能指针进行同样的转换。我怎样才能做到这一点？
更新
对不起，也许我问错了方向。真正的交易要复杂一些。我用QVari
浏览 10提问于2016-04-16得票数 1
2回答
更改构造函数优先级
、、、
是否可以为所有派生类型定义一个构造函数和一个模板构造函数？我写了这个测试用例来说明我的问题：
#include <iostream>
class Variant;
class CustomVariant;
class Variant
{
public:
Variant(void)
{}
Variant(const Variant&)
{
std::cout << "ctor" << std::endl;
}
Variant(
浏览 3提问于2011-04-20得票数 4
回答已采纳
1回答
在C++中，可以将右值传递给接受常量左值引用的函数。我不明白为什么会这样。
表达式Function(Entity())表面上是一个右值，它在内存中没有可识别的位置。如果Function()采用Entity&而不是const Entity&，那么这将不起作用。但是，如果函数采用常量左值引用而不是左值引用，则可以很好地工作。
有人能解释一下这是如何工作的吗?为什么？
class Entity
{
Entity()
{
std::cout << "Entity created\n";
}
}
void Function(co
浏览 4提问于2019-09-23得票数 0
这个问题是关于接受静态已知大小的数组的函数。
以下面的最小程序为例：
#include <iostream>
template<size_t N>
void arrfun_a(int a[N])
{
for(size_t i = 0; i < N; ++i)
std::cout << a[i]++ << " ";
}
int main()
{
int a[] = { 1, 2, 3, 4, 5 };
arrfun_a<5>(a);
std::cout <&
浏览 2提问于2012-05-09得票数 9
回答已采纳
1回答
类型转换操作符不被调用。
、、、
我试图为对象之间的类型转换做一些示例代码，就像显示的那样。
这是父类
// ParentClass.h
class ParentClass {
public:
ParentClass();
virtual ~ParentClass();
};
这只是一些概念证明，它唯一能做的就是打印一些东西。
#include <iostream>
#include "ParentClass.h"
ParentClass::ParentClass()
{
std::cout << "Parent\tDefault constructor\
浏览 2提问于2015-08-05得票数 1
回答已采纳
C++17提供和，它们都能够在对象下存储不同类型的值。对我来说，它们在某种程度上很相似(是吗？)
此外，std::variant还限制条目类型，除此类型外。为什么我们应该更喜欢std::variant而不是更容易使用的std::any呢？
浏览 1提问于2019-05-25得票数 51
回答已采纳
2回答
我试图理解以下代码中的类型转换是做什么的
UA_Variant Variant;
Int32_t Variable;
variable = *(int32_t *) Variant.data;
printf("%d", variable);
这是UA_Variant的结构
typedef struct
{
const UA_DataType *type; /* The data type description */
UA_VariantStorageType storageType;
size_t arrayLength;
浏览 10提问于2020-12-28得票数 2
1回答
std：：绑定头文件声明
、、、、
我希望为cpp文件中的函数创建一个std::bind，而不是我的主文件，也要创建一个不同的名称空间。我遇到的问题是如何在头文件中声明上述函数，因为绑定本身依赖于main.cpp不可用的变量。
它是这样的：
function.cpp
#include "function.h"
namespace A{
void function(int i) { ... } // supposed to be invisible from outside
namespace A1{
int varA1;
auto func = std::bin
浏览 3提问于2015-11-24得票数 2
回答已采纳
2回答
下列程序中止：
#include <boost/variant.hpp>
using variant_type = boost::variant< int&, std::string& >;
int main () {
int a, b;
variant_type v (a), u (b);
v == u;
return 0;
}
通过以下方式：
$ g++ -std=c++14 t.cpp && ./a.out
a.out: /opt/boost/default/include/boost/va
浏览 1提问于2015-10-23得票数 4
回答已采纳
4回答
我没有完全理解变体的用法，也许有人可以澄清我做错了什么(可能是我的方法)。
让变量对象是两个类的_Types，两个类都继承同一个类。
class base
{
public:
int foo;
};
class a: public base
{
int bar;
};
class b: public base
{
float bar;
};
byte variant_id = 0; // 0 for class A, 1 for class B
std::variant< base, a, b > variant;
下面是我如何使用这个变体：
void f
浏览 0提问于2018-11-06得票数 2
回答已采纳
3回答
我试图为变量值编写一个接口。基类只提供一个enum字段，其中存储变量的类型(如int、char等)还有一些虚拟函数。继承此接口的类应该实现每个变量类型的表示形式。
#include <iostream>
enum Type
{
INT, CHAR
};
class Var
{
Type type;
public:
Var(Type t):
type(t)
{}
virtual void printValue()
{
std::cout << "-\n";
}
浏览 4提问于2015-07-11得票数 3
回答已采纳
1回答
我试图编写一个非常简单的变体和访问者实现，如下所示，但我得到了编译错误，但我不知道为什么。
#include <variant>
#include <string>
#include <iostream>
struct foo
{
std::string s;
};
struct bar
{
double s;
};
using var = std::variant<foo, bar>;
struct visitor
{
template <class T>
auto operator()(co
浏览 0提问于2018-11-15得票数 1
回答已采纳
我正在尝试std::visit a std::variant of std::function types。 为什么以下代码不能编译： #include <functional>
#include <variant>
int main()
{
std::variant<
std::function< int () >,
std::function< float () >
> func_variant {std::in_place_index<0>, [] () { return 42;
浏览 78提问于2019-11-29得票数 2
回答已采纳
1回答
我怎么能有一副带参考向量的对呢？
、、、、
我确实需要在std::vector of std::pair中添加引用(&)，但是当我尝试使用push_back引用值时，它会在函数内部中断。调试后，我发现引用的地址与unique_ptr中的地址不同(但值是相同的)。
当我不使用(这里的foo())任何插入到向量中的函数时，它所引用的值是正确的，但是地址仍然不匹配。
#include <iostream>
#include <memory>
#include <iterator>
#include <string>
#include <vector>
void foo(st
浏览 2提问于2017-12-16得票数 1
回答已采纳
2回答
我有一个变体ScalarVar
using ScalarVar = std::variant<int, std::string>;
和一个变体Var，它本身可以是ScalarVar或std::vector of ScalarVar的
using Var = std::variant<ScalarVar, std::vector<ScalarVar>>;
我想要创建一个函数template<typename T, typename Variant> T Get(const Variant& var);，当给定一个不包含内部变量的变量时，它的
浏览 4提问于2020-02-27得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
