内部可变性与数据隐藏保持固定可变借入的引用
内部可变性是指对象的内部状态可以被修改的能力。数据隐藏是指将对象的内部状态隐藏起来，只允许通过特定的接口来访问和修改对象的状态。保持固定可变借入的引用是指在借用引用的过程中，保持引用指向的对象不变，但允许修改对象的状态。
内部可变性和数据隐藏是面向对象编程中的重要概念。通过将对象的内部状态隐藏起来，可以提高代码的安全性和可维护性。只允许通过特定的接口来访问和修改对象的状态，可以避免直接修改对象的内部状态，从而减少了代码中的错误和bug。
保持固定可变借入的引用是一种编程技术，它允许在借用引用的过程中修改对象的状态，但要求保持引用指向的对象不变。这种技术可以在某些特定的场景下提高代码的效率和灵活性，但需要注意避免引起数据竞争和并发访问的问题。
在云计算领域，内部可变性和数据隐藏可以应用于开发和管理云服务的过程中。通过将云服务的内部状态隐藏起来，只允许通过特定的接口来访问和修改服务的状态，可以提高服务的安全性和可靠性。保持固定可变借入的引用技术可以在云服务的开发过程中使用，以提高代码的效率和灵活性。
腾讯云提供了一系列与云计算相关的产品，包括云服务器、云数据库、云存储、人工智能服务等。这些产品可以帮助开发者快速构建和部署云服务，提供高性能和可靠性的计算、存储和分析能力。具体的产品介绍和相关链接可以在腾讯云官网上找到。
相关·内容
我有以下代码，采取管道行的文本和日志手指移动需要键入某些字符。LogReport采用存储详细信息的&KeyLogger%s。LogReport随后会将多个&KeyLogger中的详细信息打印为目录。
let keyboard = KeyboardBuilder::build(...);
let mut key_logger: KeyLogger = KeyLogger::new(keyboard);
let mut report = LogReport::new();
report.add_logger(String::from("QWERTY"), &
浏览 1提问于2021-05-28得票数 0
1回答
根据，Vec<T>实现了Sync，如果T实现了Sync。它似乎是由某种魔法自动生成的，但我觉得这是违反直觉的，因为向量的天真实现并不是线程安全的。
铁锈中的Vec<T>真的是Sync吗？
浏览 0提问于2018-09-01得票数 5
回答已采纳
我有一个所有状态的哈希映射，这是一个HashMap<String, Rc<State>>，我想调用当前状态的成员fn init(&mut self)。但是，下面的代码出错了：
...
if let Some(state) = self.states.get_mut(state_id) {
(*state).init();
}
...
以下是错误：
src/main.rs:70:25: 70:33 error: cannot borrow immutable borrowed content as mutable
src/main.rs:70
浏览 2提问于2015-08-03得票数 2
回答已采纳
1回答
我试图理解锈蚀指针类型及其与易变性的关系。具体来说，声明一个包含指针并且本身是可变的变量的方式--即可以指向其他内存，并且声明数据本身是可变的--即可以通过指针变量的值进行更改。
这就是我如何理解普通引用工作的方式：
let mut a = &5; // a is a mutable pointer to immutable data
let b = &mut 5; // b is an immutable pointer to mutable data
因此，a可以更改为指向其他东西，而b不能。然而，b指向的数据可以通过b更改，而不能通过a更改。我理解得对吗？
关于问题的第二
浏览 1提问于2015-07-22得票数 2
回答已采纳
我一直在尝试在Rust中实现一个自上而下的递归下降解析器。但我也在学习Rust，我大部分时间都在与编译器或更具体地说是借用检查器进行斗争。
我已经有了解决方案，并且已经在非系统GC语言中实现了它，并且它正在工作。但在Rust中尝试实现它时，我遇到了相当多的问题。但我几乎已经修复了大部分问题，方法是完全按照编译器的要求进行操作，并来回查看文档并修复问题。但这最后一个错误(或者我是这么认为的)不会轻易消失。我已经试着解决它两天了，我对它感到非常沮丧，所以我来了
以下是我正在尝试做的事情的片断。
首先，我像这样实现了一个名为Parser的结构。生命周期source是必需的，我认为Scanner结构的
浏览 2提问于2021-04-23得票数 0
1回答
人们通常说，不可变的数据结构对并发编程更“友好”。解释是，如果一个数据结构是可变的，并且一个线程修改了它，那么另一个线程将“看到”该数据结构的前一个模式。
虽然不可能修改不可变的数据结构，但如果需要更改它，可以创建一个新的数据结构，并为其提供“旧”数据结构的引用。
在我看来，这种情况也不是线程安全的，因为一个线程可以访问旧的数据结构，另一个线程可以访问新的数据结构。如果是这样的话，为什么不可变的数据结构被认为是更线程安全的？
浏览 12提问于2016-08-14得票数 0
在下面的代码中，我试图通过调用一个refcounted对象的方法来更改它的值：
use std::rc::Rc;
fn main() {
let mut x = Rc::new(Thing { num: 50 });
x.what_to_do_to_get_mut_thing().change_num(19); //what do i do here
}
pub struct Thing {
pub num: u32,
}
impl Thing {
pub fn change_num(&mut self, newnum: u32) {
浏览 0提问于2018-10-25得票数 13
回答已采纳
pub struct Notifier<'a, T> {
callbacks: Vec<Box<'a + FnMut(&T)>>
}
impl<'a, T> Notifier<'a, T>{
fn add_callback<F: 'a + FnMut(&T)>(&mut self, callback: F) {
self.callbacks.push(Box::new(callback));
}
fn tri
浏览 1提问于2017-05-24得票数 1
fn main() {
// block1: fails
{
let mut m = 10;
let n = {
let b = &&mut m;
&**b // just returning b fails
};
println!("{:?}", n);
}
// block2: passes
{
let mut m = 10;
let n = {
浏览 0提问于2018-07-30得票数 10
回答已采纳
我试图将一个可变的切片传递给一个函数，并在其中的几个循环中使用它。
function1会产生一个错误。更改为function2或function3会使错误消失，但我不理解function1和function2之间的区别。v和&mut *v在我看来很相似。
为什么function1不能工作，而其他的工作呢？
fn main() {
let mut v = Vec::new();
function1(&mut v);
function2(&mut v);
function3(&mut v);
}
// Move Error
fn
浏览 2提问于2017-10-06得票数 5
回答已采纳
我在试着用铁锈做一个像图一样的结构。我的第一个实现编译得很好：
fn main() {
let mut graph: Graph = Graph::new(); // Contains a vector of all nodes added to the graph. The graph owns the nodes.
// Create a node
let parent: usize = graph.add_node(ParentNode::new()); // Returns the ID of the node.
let parent: &N
浏览 2提问于2018-01-05得票数 3
回答已采纳
工作守则：
use std::cell::{Ref, RefCell};
use std::rc::Rc;
struct ValueHolder {
value: i32
}
fn give_value(wrapped: &Rc<RefCell<ValueHolder>>) -> Ref<i32> {
Ref::map(
(**wrapped).borrow(),
|borrowed| { &(*borrowed).value },
)
}
fn main() {
p
浏览 4提问于2020-11-19得票数 2
回答已采纳
在我的代码中，我有一个HashMap充当查找表，映射ID <->数据。 我需要根据我的ID查找一些数据(让我们称之为数据A)，然后读取内容。根据内容中的条目，我需要在相同的查找表中查找另一个值，读取这些数据，并进行一些计算，更新我的原始数据A。 下面是一个最小的工作示例： playground use std::collections::HashMap;
struct MyData {
id: i32,
result: i32,
complex_data: Vec<i32>
}
impl MyData {
fn new(id: i3
浏览 24提问于2021-11-16得票数 0
回答已采纳
2回答
如果我建立了一个数据字典，我有以下奇怪的行为(使用熊猫0.19.2，python 3.5)：
df1 = pd.DataFrame(index=['a', 'b'], columns=['c1', 'c2'], data=[[0,1],[2,3]])
df2 = pd.DataFrame(index=['a', 'b'], columns=['c1', 'c2'], data=[[4,5],[6,7]])
my_dict = {'f1': df1,
浏览 7提问于2017-05-17得票数 0
回答已采纳
1回答
回到另一个关于锈菌基本设计决策的新问题。
我在写一个简单的小游戏。我在一个数据结构中有一个游戏对象池，由它们的"id“键构成。我的问题是如何处理与池中的对象有关系的其他结构(比池中的结构更短)。
一开始我做了以下几件事：
struct Foo<'a> {
game_obj: &'a GameObject
// etc.
}
但是，当我试图(不断地)引用与现存的GameObject相同的范围内的GameObject时，我遇到了一系列的问题。
所以现在我在考虑这样的事情：
struct Foo {
game_obj_id: uint,
/
浏览 5提问于2014-09-05得票数 1
回答已采纳
在Java ObjectInputStream中有两个类似的方法：
和
这些文件指出：
public Object readUnshared() throws IOException, ClassNotFoundException
从ObjectInputStream读取“未共享”对象。此方法与readObject相同，只不过它防止后续对readObject和readUnshared的调用返回对通过此调用获得的反序列化实例的附加引用。具体地说：
如果调用readUnshared来反序列化回引用(先前写入流的对象的流表示)，则将引发ObjectStreamException。
如果read
浏览 3提问于2015-04-02得票数 6
2回答
早些时候我有一个Sync + Send特征SyncMessenger
trait Messenger {
fn send_message(&self, user_id: UserId, text: &str);
}
trait SyncMessenger: Messenger + Sync + Send {}
它的实现：
pub struct DiscordMessenger {
discord: Arc<Discord>, // (Discord is Sync and Send already)
}
impl Messenger for Dis
浏览 2提问于2017-05-23得票数 3
回答已采纳
如果这是一个显而易见的问题，我很抱歉，因为我是Java的初学者。
字符串对象是不可变的，这意味着它们不能被更改。因此，如果实例化：
String s = "hello";
然后更改s的内容，
s = "goodbye";
这是否意味着创建了一个新的字符串对象，也称为s？原始变量的值是否正在更改？还是它的引用被改变了？先谢谢你，因为字符串不变的概念让我很困惑。
浏览 2提问于2019-12-25得票数 0
回答已采纳
据我所知，变量类型签名中没有反映可更改性。例如，这两个引用具有相同类型的签名&i32。
let ref_foo : &i32 = &foo;
let mut ref_bar : &i32 = &bar;
为什么是这种情况？这似乎是个相当大的疏忽。我的意思是，即使是C/C++，使用两个const来表示我们有一个指向const数据的const指针，也可以更明确地说明这一点：
const int * const ptr_foo = &foo;
const int * ptr_bar = &bar;
有没有更好的思考方法？
浏览 3提问于2020-01-13得票数 8
回答已采纳
我发现很多问题都是不可变的，但我不太清楚我在这段代码中做错了什么。
我遇到的错误是：“不能借用values不可变，因为它也是作为可变借来的。”
fn modify_vec_get_slice(values: &mut Vec<i32>) -> &[i32] {
// Modify "values" in some way
values.push(5);
// Return a slice into "values" (dummy code)
values.split_at(values.len(
浏览 3提问于2022-03-09得票数 2
回答已采纳
7回答
更改不可变对象的值是否正确？
我有两个关于readonly的场景，我想了解这些场景：
如果我有一个集合并将其标记为readonly，如下面所示。我还能打电话给_items.Add吗？
私有只读ICollection _items；
对于下面的变量，如果稍后我调用_metadata.Change，它将更改Metadata实例中的一对成员变量的内部值。_metadata仍然是不变的吗？
私有只读元数据_metadata；
对于上面的两个变量，我完全理解我不能在初始化器和构造函数之外直接给它们分配新的值。
浏览 0提问于2011-07-27得票数 14
let mut set = HashSet::<u32>::new();
let a = set.get(&1);
set.remove(&1);
a.unwrap(); // cannot borrow `set` as mutable because it is also borrowed as immutable
这是我的代码。我明白了这个错误意味着什么，以及为什么锈会阻止我这么做。但我在set.rs中找不到任何类型注释来导致该错误的发生。
pub fn get<Q: ?Sized>(&self, value: &Q) ->
浏览 0提问于2019-10-12得票数 0
我只是被生锈编译的错误弄糊涂了。
假设代码片段如下所示：
fn process(map: &mut HashMap<String, String>, key: String) {
match map.get_mut(&key) {
Some(value) => println!("value: {}", value),
None => {
map.insert(key, String::new());
}
}
}
我这样称呼它：
fn main() {
浏览 3提问于2019-10-27得票数 1
回答已采纳
我在Rust中有一个Graph数据结构： type NodeIndex = usize;
struct Graph {
nodes: Vec<NodeIndex>,
edges: Vec<(NodeIndex, NodeIndex)>,
} 我想迭代一个函数中的所有节点，并调用一个函数，该函数使用每个节点作为元素来改变图形，比如： impl Graph {
fn mutate_fn(&mut self) {
for node in self.nodes {
self.mutate_using_n
浏览 24提问于2020-07-15得票数 6
将包含!Send字段(如Rc或NonNull)的类型标记为Send特征背后的原因是什么？例如，标准库的以这种方式工作:它包含Option<NonNull<_>>字段并实现Send特征(当T为Send时)。
这是如何安全的，有什么保证和方法来安全地使用这样的类型？
浏览 0提问于2018-10-22得票数 7
1回答
我希望获取一个链接列表，并使用结构实例填充它，但前提是该列表不包含我正在考虑添加的项。
我正在处理点，所以如果(3,5)在列表中，我不想添加它，否则我会添加它。
我现在的代码是：
use std::collections::LinkedList;
struct Location {
x: i32,
y: i32,
}
fn main() {
let mut locations = LinkedList::new();
loop {
let location_set = &mut locations;
// Scann
浏览 0提问于2017-03-05得票数 1
回答已采纳
2回答
我经常看到这样的说法:编程语言特性消除了整个类错误。
例如，我看到有人声称：
强类型系统消除了由于使用类型不支持的功能而导致的错误类别。
自动内存管理消除了与为对象/结构分配正确的内存量有关的错误类别。
强制变量初始化消除空指针或空引用错误。
不可变的数据结构消除了由于不理解更改可变状态的影响而引起的错误类别。
我并不是想弄清楚上面的说法是否属实，而是汇编了一份足以让我研究和评估自己的这类索赔的清单。
还有哪些其他特定的特性可以消除一整类错误？
是否有一个一般的原则或理论来识别这样做的特征，或识别没有这样的特征？
(请注意，我做了，而不是，包含了明显的模糊或主观的断言，
浏览 4提问于2014-02-26得票数 2
回答已采纳
好的，我有一个方法，它接受一个NSString作为输入，对这个字符串的内容执行一个操作，然后返回处理后的字符串。所以声明是：
- (NSString *) processString: (NSString *) str;
问题是:我应该只返回用作“工作”缓冲区的NSMutableString实例，还是应该围绕可变的NSString创建一个新的实例并返回它？
那么我应该这样做吗：
- (NSString *) processString: (NSString *) str
{
NSMutableString *work = [NSMutableString stringWithStrin
浏览 0提问于2010-05-29得票数 4
回答已采纳
2回答
关于这个基本问题真的很抱歉。
我试图模拟类似web服务器调用的内容，并从外部范围捕获一个变量。
fn http_get(path: &str, f: &dyn Fn()) {
f();
}
fn main() {
let mut counter = 0;
http_get("/foo", &|| {
counter = counter + 1;
println!("/foo: {}", counter);
});
http_get("/bar", &|| {
浏览 0提问于2021-09-30得票数 1
回答已采纳
我正在编写一个函数，它从单链列表中移除最后一个节点：
#[derive(PartialEq, Eq, Debug)]
struct Node<T> {
value: T,
next: Option<Box<Self>>,
}
以下是我的递归版本：
fn remove_last_node_recursive<T>(node_ref: &mut Option<Box<Node<T>>>) {
let next_ref = &mut node_ref.as_mut().unwr
浏览 0提问于2019-08-25得票数 1
回答已采纳
3回答
我有一个WCF应用程序，它从客户端应用程序接收一些字符串数组。然后，将这些数组作为参数传递给一些自定义类的构造函数。我自己并没有创建任何线程(甚至没有使用System.Threading)，但是我想知道在每个构造函数中使用lock (param.SyncRoot)只是为了安全起见是不是很糟糕？这是因为我让我所有的对象都是不可变的，并且我想确保数组不会以任何方式改变。
浏览 0提问于2011-06-27得票数 0
回答已采纳
5回答
我知道整数在Java中是不可变的。但是为什么它是这样设计的呢？
在问这个问题之前，我先看了一下其他的答案：
但是我找不到这个用例，它要求Integer是不可变的。有什么技术原因像字符串一样吗？
在网络连接、数据库URL等方面，字符串被用作参数，如果字符串是可变的，它很容易被破坏。
支持StringPool设施。
以支持使用String作为参数的类加载机制。字符串是可变的，会导致加载错误的类。
我知道像AtomicInteger这样的包装器是可变的。
更新：
从谈话中看，没有普遍的理由可以强制要求整数是不可变的。但是，通过执行不变的操作，它提供了一些额外的好处，如答案中
浏览 2提问于2014-04-01得票数 13
回答已采纳
1回答
使用捕获模式匹配突变Vec元素
、、、、
我可以更改vec的最后一个元素：
#[derive(Debug)]
enum Type {
A,
B,
C,
}
fn main() {
let mut v = vec![Type::A, Type::B, Type::B];
match v.last_mut(){
None => v.push(Type::A),
Some(last) => *last = Type::C,
}
println!("{:?}", v)
}
==>打印[A, B, C]
浏览 6提问于2021-04-17得票数 1
回答已采纳
2回答
我遇到了借用检查器的问题。我有一个特征(Physics)，它有getter(例如velocity)和setter(例如velocity_mut)。它还有使用getters和apply_force的默认方法accelerate和setter。为什么有多个借阅是不好的，解决这个问题的方法是什么？下面是一条错误消息： 13:18 rustc error cannot borrow `*self` as immutable because it is also borrowed as mutable
浏览 28提问于2021-01-15得票数 2
回答已采纳
2回答
查看下面的Rust代码。它会编译
fn main() {
let vec0 = Vec::new();
let mut vec1 = fill_vec(vec0);
println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
vec1.push(88);
println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}
f
浏览 0提问于2020-06-28得票数 3
1回答
我的目标是建立一个独立于底层数据结构的功能(具体来说，洪涝)。我试图通过传入两个闭包来做到这一点:一个用于查询，一个用于永久借用一些数据，另一个用于可变地借用相同的数据。
示例(在上测试)：
#![feature(nll)]
fn foo<F, G>(n: i32, closure: &F, mut_closure: &mut G)
where
F: Fn(i32) -> bool,
G: FnMut(i32) -> (),
{
if closure(n) {
mut_closure(n);
}
}
f
浏览 0提问于2018-04-07得票数 9
回答已采纳
2回答
我是使用不可变值进行编程的Clojure / functional方法的铁杆粉丝。
然而，我不确定是否应该被视为不可变值(假设您延迟了一个纯函数)。我特别感兴趣的是在较大的不可变数据结构中存在一个或多个延迟的情况。
例如，包含延迟的向量：
[1 2 (delay (reduce + (range 1000)))]
据我所知，它的行为就像是一个不可变值，在这种意义上，你不能看到延迟的结果，直到你强制它求值-然后结果被缓存，值在那之后永远不会改变。
以这种方式将延迟视为不可变值有什么问题吗？
浏览 5提问于2012-05-29得票数 3
回答已采纳
似乎u，一种可变的借用，在
let v = &*u;
然后，u和v都是不可变的借用引用，因此它们都被允许使用。
use std::ascii::AsciiExt;
fn show(a: &str) {
println!("a={}", a);
}
fn main() {
let mut t = String::new();
t.push('s');
let u = &mut t;
u.make_ascii_uppercase(); // u is really mutable here
浏览 7提问于2016-11-17得票数 3
回答已采纳
在下面的示例中，我想为每个简单的spin smol_socket_handle调用usize。
pub fn spin_all(&mut self) -> u8 {
for (smol_socket_handle, _) in self.smol_sockets.iter_mut() {
self.spin(smol_socket_handle.clone());
}
0
}
pub fn spin(&mut self, smol_socket_handle: usize) -> u8
浏览 3提问于2020-07-22得票数 1
嗨，我遇到了一些有趣的行为，我找不到解释。
我有个叫combinedDict的白痴。它有字符串键，它的元素是熊猫的数据。
我想选择名为“早期”的数据格式。我创建了一个变量，等于该数据。然后，我希望通过将字符串'_early‘附加到该列的每一行来编辑该数据文件中的ID列。我使用以下代码执行此操作：
a = combinedDict['early']
a['ID'] = [(s + '_early') for s in a['ID'].tolist()]
当我这样做时，字符串'_early‘被追加到dataframe中
浏览 0提问于2016-03-24得票数 2
3回答
给定，
public class SomeClass {
public string SomeName{get;}
public List<string> RelatedNames{get;}
}
public class Program{
public void Main(){
var someClassInstance = new SomeClass(){ SomeName = "A", RelatedNames = new List<string>(1){ "a" }};
浏览 0提问于2012-01-21得票数 0
回答已采纳
1回答
我的程序使用rusqlite从另一个数据源构建数据库。数据库以相同的方式构建多个表，因此我认为我应该创建一个可重用的函数来这样做：
fn download_generic<Inserter>(table_name: &str,
connection: &mut rusqlite::Connection,
inserter: &mut Inserter)
-> Result&l
浏览 2提问于2017-01-15得票数 6
回答已采纳
如果我创建一个不可变的类。所有字段都必须是最终字段。如果我像下面这样使用stringbuilder s= StringBuilder StringBuilder("Hello ")；
，则append函数可以附加s的值，并且类不会是不可变的。敬请指教。
浏览 0提问于2019-09-18得票数 2
最小的例子是这个()
#[derive(Debug)]
struct Node {
id: usize,
subs: Vec<Node>,
}
impl Node {
fn refmut_nth_subnode(&mut self, n:usize)->Option<&mut Node> {
if self.subs.is_empty() {
return None;
}
else {
return Some(&mut
浏览 8提问于2022-03-19得票数 0
我有一个Needle，它在借来的tape中拥有current的地位。它的say()方法会扰乱编译器。
我很难理解为什么&self在与对advance()的调用发生冲突之前被拖到了终身'b中。我试着在被剥夺了的生命中写作。
在read()中，根据生命周期省略的第二条规则，&self必须至少与返回的&char一样长。但是，对read() in say()的调用不需要创建新的&self。它只是在&mut self中传递具有生存期'b的参数，并将参数处理为&self。&self不是在read()的末尾掉了吗？
&self感
浏览 2提问于2021-08-18得票数 0
回答已采纳
2回答
什么是深度不变？
、、
在阅读规范时，我遇到了术语“深度不变”。案文说：
在这里，“不能改变”意味着不可变的身份(即===)，但并不意味着深层的不可变性。
什么是深度不变？有人能举个例子解释一下吗？
浏览 2提问于2017-09-28得票数 4
回答已采纳
我的模板中有一个包含动画项(:enter & :leave animations)的简单列表：
@itemAnimation *ngFor="let item of list;
还有一个" add“按钮，它以模式对话框的形式打开表单，用户可以向列表中添加新的项目。
用户在model上点击“保存”后，模型将关闭。在此之后，为了始终显示最新的数据(即在多选项卡情况下)，我们再次从后端加载所有项目，并再次设置列表：
this.list = ....
在这种情况下，所有的项目都将被再次动画，而不仅仅是新的项目(或更改的项目)，因为Angular认为它们都是新的项目。怎样才能使
浏览 2提问于2019-02-19得票数 1
从中，我看到Cell“只与实现Copy的类型兼容”。这意味着我必须将RefCell用于非Copy类型。
当我有一个Copy类型时，使用一种类型的单元而不是另一种类型有好处吗？我想答案是“是”，因为否则这两种类型都不存在！使用一种类型和另一种类型的好处和权衡是什么？
下面是一个愚蠢的、虚构的示例，它使用Cell和RefCell来实现相同的目标：
use std::cell::{Cell,RefCell};
struct ThingWithCell {
counter: Cell<u8>,
}
impl ThingWithCell {
fn new() ->
浏览 2提问于2015-05-16得票数 51
回答已采纳
1回答
以下是对可变对象和不可变对象的global的正确理解吗？
immutable1 = 'abc'
immutable2 = '123'
mutable = {}
def change():
mutable['CHANGED'] = 'CHANGED' # this will change the global variable mutable
global immutable1
immutable1 = 'abc-CHANGED' # this will change the glo
浏览 4提问于2019-10-20得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
