如何防止元组的联合变成联合的元组？
元组是Python中的一种数据类型，用于存储多个元素的有序集合。元组是不可变的，即一旦创建就不能修改。在Python中，元组的联合是指将两个或多个元组合并成一个新的元组。
要防止元组的联合变成联合的元组，可以采取以下方法：
- 使用元组解包：可以通过将元组解包为单独的变量，然后再进行联合操作。例如：
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = (*tuple1, *tuple2)- 使用列表代替元组：列表是可变的，可以进行修改和扩展。如果需要进行联合操作，并且希望结果是可变的，可以使用列表代替元组。例如：
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2- 使用其他数据结构：如果需要进行更复杂的操作，可以考虑使用其他数据结构，如集合（set）或字典（dict），根据具体需求选择合适的数据结构。
需要注意的是，以上方法都是基于Python语言的特性，不涉及具体的云计算相关知识。
关于元组的概念、分类、优势、应用场景以及腾讯云相关产品和产品介绍链接地址，可以参考以下内容：
- 概念：元组是Python中的一种不可变的数据类型，用于存储多个元素的有序集合。元组使用小括号进行表示，元素之间使用逗号分隔。
- 分类：元组可以分为普通元组和命名元组。普通元组是最常见的元组类型，元素的访问通过索引进行；命名元组是具有命名字段的元组，可以通过字段名进行访问。
- 优势：元组具有不可变性，因此在某些场景下可以提供更好的安全性和性能。另外，元组相对于列表来说，占用的内存空间较小。
- 应用场景：元组适用于存储一组不可变的数据，例如表示坐标、日期时间等。另外，元组还可以用于函数返回多个值的情况。
- 腾讯云相关产品和产品介绍链接地址：腾讯云提供了丰富的云计算产品和服务，包括云服务器、云数据库、云存储等。具体关于元组的相关产品和介绍，可以参考腾讯云官方文档或咨询腾讯云的客服人员。
请注意，以上内容仅为示例，实际情况可能因为产品更新或变化而有所不同。建议在提供答案时，结合最新的腾讯云产品和文档进行参考。
相关·内容
给予：
type UserObj = { name: string; age: number; role: "admin" | "standard"; };
type ObjValues = UserObj[string];
type UserTuple = [ string, number, "admin" | "standard" ];
type TupleValues = UserTuple[number];
为什么TupleValues类型检查而ObjValues不检查？
我很清楚我可以使用keyof
浏览 2提问于2022-10-19得票数 1
回答已采纳
尝试编写一个函数，以便在发生意外的“失败”时优雅地返回。我考虑在这个函数上使用go风格的返回值，并将返回值键入为[Val, null] | [null, Error]。
但是，当尝试使用if语句对返回值进行类型保护时，
const [val, err] = myFunc(); // => [Val, null] | [null, Error]
if (err) {
handle(err);
return;
}
// At this point in code, return value has to be of type [Val, null]
doSomethingWit
浏览 7提问于2021-02-16得票数 2
回答已采纳
在TypeScript 4.2中，需要检查元组类型是以特定类型开始还是以特定类型结束：
type HeadIsString<T extends any[]> = T extends [string, ...any[]] ? true : false;
type TailIsString<T extends any[]> = T extends [...any[], string] ? true : false;
但是，我想检查元组在元组中的任何位置是否包含特定类型。像这样的事情目前是不可能的
type IncludesString<T extends any[]
浏览 2提问于2022-07-05得票数 1
回答已采纳
我有一个大的常量JavaScript对象。就像这样：
const commonStyles = {
fullContainer: {
flex: 1,
alignItems: 'stretch',
justifyContent: 'flex-start',
},
justifyEvenly: {
justifyContent: 'space-evenly',
},
widthBound: {
width: '100%&#
浏览 3提问于2021-05-06得票数 0
回答已采纳
2回答
数组类型的类型记录接口
、、、
我需要强制一个数组拥有一组特定的值，这些值应该是我的接口的键。我可以用
type SomeProperties = ['prop1', 'prop2', 'prop3'];
但我不知道如何强制一个接口拥有这些属性。我试过
type MyInterface = {
[key in keyof SomeProperties]: string;
}
但是很明显，数组的键只是数字，所以我的接口变成了
interface MyInterface {
0: string;
1: string;
2: string;
}
而不是想要的接口
in
浏览 2提问于2017-08-10得票数 7
回答已采纳
我怎样才能做到这一点：
type ActionNames = 'init' | 'reset';
type UnionToObj<U> = {/* TODO HERE */}
type Result = UnionToObj<ActionNames>;
// expect type Result to be `{ init: any, reset: any }`
我已经写了一个实现，但是它不能正常工作，它满足了联合扩展协方差问题：
type UnionToObj<U> = U extends string ? { [K i
浏览 3提问于2021-01-26得票数 0
我已经知道如何将类型推到元组的末尾：
type Cons<H, T extends readonly any[]> =
((head: H, ...tail: T) => void) extends ((...cons: infer R) => void) ? R : never;
type Push<T extends readonly any[], V>
= T extends any ? Cons<void, T> extends infer U ?
{ [K in keyof U]: K extends keyo
浏览 2提问于2019-10-25得票数 1
回答已采纳
const source = [
{ group: 'first', key: 'A' },
{ group: 'first', key: 'B' },
{ group: 'second', key: 'A' }
] as const;
type DerivedGroupKeys = `${typeof source[number]['group']}.${typeof source[number]['key']}`;
//gives "firs
浏览 4提问于2021-02-10得票数 1
回答已采纳
我在追踪一个
我有以下模式：
const schemas = {
POST: {
$schema: 'https://json-schema.org/draft/2019-09/schema#',
$id: 'https://api.netbizup.com/v1/health/schema.json',
type: 'object',
properties: {
body: {
type: 'object',
properties: {
浏览 9提问于2022-03-08得票数 0
回答已采纳
我已经阅读了Natural Join的一个例子，它涉及两个具有两个相同列名的关系。我理解那些在两个表中有一个相同的列名的人，但是对于这种情况，我真的不知道。有人能向我解释如何获得输出(不是在Sql命令中)吗？
谢谢!
浏览 0提问于2016-11-05得票数 2
回答已采纳
1回答
基于类型数组创建联合类型
、、、
是否可以像这样定义联合类型： Union<T extends any[]> = // something... ，并将像这样使用 Union<[string, number]> // would create (string | number) 我知道我可以直接在上面定义联合，但我需要在泛型中使用它，因为它最终会是像Union<[TDynamic, UDynamic]>这样的东西
浏览 14提问于2019-10-06得票数 1
回答已采纳
假设我有两个sum类型(这里是F和G )，它们的成员是一对一的关系(例如，strings与boolean，number与object)。 我想定义一个函数F -> G -> something，它的签名只允许某些参数对。 我可以用函数重载很容易做到这一点，如下所示： type F = string | number
type G = boolean | object
function f(x: string, y: boolean): any
function f(x: number, y: object): any
function f(x: F, y: G): any {
浏览 12提问于2019-09-24得票数 1
回答已采纳
1回答
考虑一下这个微不足道的例子：
abstract class Foo {
public abstract functionAdd(number1, number2, number3): number
public abstract functionMultiply(number1, number2, number3): number
}
interface Numbers {
number1: number
number2: number
number3: number
}
如何使用接口Numbers来描述这两种方法的参数？也许还有其他更惯用的方法来定义抽象方法？
浏览 4提问于2022-02-05得票数 1
回答已采纳
1回答
发出联合类型和条件类型
、、、、
我有以下类型声明：
class MyGeneric<T> { }
type ReplaceType<T> = T extends Function ? T : MyGeneric<T> | T;
ReplaceType<T>应该解析为MyGeneric<T> | T或T，这取决于T，它是一个函数还是非函数：
// Input type: string
// Expected type: string | MyGeneric<string>
// Actual type: string | MyGeneric&l
浏览 1提问于2018-07-16得票数 4
回答已采纳
type Tuple=[{a:string,x:string,z:string},{b:string,x:string,z:string}]
type IntersectionOfTupleElementKeys<T>=...
type MyType = IntersectionOfTupleElementKeys<Tuple> // = ('a'|'x'|'z')&('b'|'x'|'z')='x'|'z'
我有一个元组类型，每个元素
浏览 4提问于2020-11-01得票数 2
回答已采纳
1回答
C++11元组中的树
、、、、
我想用Python风格在C++11元组中实现一个简单的树。在Python中，我们可以使用类型(Obj)来检查运行时的对象类型，并将不同类型的对象传递给一个函数，我已经为calc()写了伪代码，在c++中如何做到这一点？
我尝试打印类型I(Child1).name()和类型I(树).name()，它们是'St5tupleIIciiEE‘和’St5tupleIIcSIIciiEES0EE‘。
我的环境是g++ 4.8.1。谢谢!
// pseudo code
int calc(tuple tree) {
symbol = type(get<0>(tree));
l_ch
浏览 2提问于2013-06-24得票数 1
在中，Action传递给checkbox函数的tag参数(第51-53行)。
我不明白这个参数的类型签名如何是(Bool -> Action)，以及如何在第69行中使用函数组合运算符<<将Bool从targetChecked转换为完整的Action类型。
编辑：
这个问题可以归结为“为什么要做以下工作？”
type Action = Edit Int
do : (Int -> Action) -> Action
do tag = tag(123)
result : Action
result = do(Edit)
浏览 1提问于2015-11-17得票数 2
回答已采纳
1回答
我刚刚从的答案中学习了使用区分元组作为参数的方法，但是当我在一些旧代码上尝试这个概念时，我发现我无法让它像我预期的那样工作。请考虑以下示例：
class Fraction {
constructor(r: Rational) {
/* Not important */
}
}
type Rational = number | Fraction;
class Couple {
private _x: Fraction;
private _y: Fraction;
constructor(c: Couple);
construct
浏览 0提问于2019-07-02得票数 1
回答已采纳
5回答
我有一个字符串联合类型如下：
type Suit = 'hearts' | 'diamonds' | 'spades' | 'clubs';
我想要一种类型安全的方法来获取可以在这个字符串联合中使用的所有可能的值。但是，由于接口在很大程度上是一种设计时构造，所以我所能做的最好的就是：
export const ALL_SUITS = getAllStringUnionValues<Suit>({
hearts: 0,
diamonds: 0,
spades: 0,
clubs: 0
})
浏览 1提问于2017-06-11得票数 154
回答已采纳
如果我有两个空列表，并且希望在同一个对象中填充所有的“a”和“b”，我可以这样做：
a, b = [foo.a, foo.b for foo in foo]
因为目前我把它们分成两个独立的列表理解。
a = [foo.a for foo in foo]
b = [foo.b for foo in foo]
所以我想知道我能不能把它们合并成一条线和一个论点。
浏览 6提问于2022-08-08得票数 0
因此，我有一个工厂模式，可以用正确的类型创建服务类的新实例。为此，我需要提取一个键的类型：
type ServiceSingleKeys<T> = [T] extends (
T extends 'foo' | 'oof' ? [T] : never
)
? T
: never;
上面的代码来自我找到的一个代码片段，但是这个代码片段没有得到解释。可悲的是，我失去了链接到片段，所以我不能提供这里的链接。
下面是一个更详细的复制：
[T]是做什么的？(在评论中回答->元组)
如果[T]扩展了(T extends ServiceKeys
浏览 4提问于2022-09-01得票数 3
回答已采纳
我正在使用来学习TypeScript中的类型关系。
定义了类型函数IsAssignableTo
type IsAssignableTo<A, B> = A extends B ? true : false
我得到了想要的结果
type MyGoodType1 = IsAssignableTo<42, Object> // MyGoodType1 === true
type MyGoodType2 = IsAssignableTo<42, object> // MyGoodType2 === false
type MyG
浏览 4提问于2021-07-29得票数 1
回答已采纳
我有一个类型，如果我不给出任何值，我想用any将对象键定义为可选。
type OptionalData<T> = T extends undefined ? { data?: any } : { data: T };
export type DataObject<T = any> = {
item?: string | null;
} & OptionalData<T>;
在我将我的泛型设置为something | undefined之前，它工作正常。
const data: DataObject<string | undefined&g
浏览 3提问于2020-07-14得票数 5
回答已采纳
改进了参数列表。
我正在看Object.assign的类型定义，它看起来像这样：
interface ObjectConstructor {
assign<T, U>(target: T, source: U): T & U;
assign<T, U, V>(target: T, source1: U, source2: V): T & U & V;
assign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U &
浏览 0提问于2018-07-31得票数 9
例如：
我有两个DataStream<Tuple4<String, String, Date, String>>，名为ds1和ds2，DataStream ds3 = ds1.union(ds2).Then，我想知道如何从ds3获得ds1.f2和ds2.f2的值。
谢谢。
浏览 0提问于2018-06-29得票数 0
回答已采纳
1回答
这可能是个糟糕的问题，甚至是不可能的，但我已经用头撞了一段时间，弄不明白。提前感谢！
T泛型创建一个连接类型：
const arrayToArray = <T>(values: T[]) => values;
当我使用这个函数时：
const result = arrayToArray([1, 'hi', 3]);
它创建了以下类型：
const result: (string | number)[]
我在寻找它来创造：
const result: [number, string, number]
我希望'one'和'three
浏览 0提问于2019-02-20得票数 2
回答已采纳
1回答
让我们假设我有一个符合定义类型的输入：
interface Person {
name: string;
age: number;
}
现在，我想要一个函数来接受一个键值对数组，例如：
function acceptsPersonProperties(tuple: Array<PersonTuple>) { ... }
// this should be fine:
acceptsPersonProperties([['name', 'Bob'], ['age', 42]]);
// this should giv
浏览 0提问于2017-04-27得票数 6
1回答
我有一个Type<T>，它应该有一个带有T[]类型的字段additionalField。我需要使这个字段是可选的，这取决于是否有泛型正在传递。所以我介绍了一个ConditionalType<T = void>，如果我不传递一个泛型，那么就没有additionalField。
所以我有一个枚举MyEnum，在ConditionalType<MyEnum>中，我希望additionalField是MyEnum[]类型的。相反，additionalField有一种类型的MyEnum.TEST_1[] | MyEnum.TEST_2[]。
下面是完整的代码：
typ
浏览 7提问于2022-11-17得票数 1
回答已采纳
1回答
我使用下面的代码来重载一个定义“event”处理程序的函数。
export function on(eventName: 'created', eventCallback: (args: { uuid: string }) => void): any;
export function on(eventName: 'updated', eventCallback: (args: { id: number }) => void): any;
export function on(eventName: any, eventCallback: any) {
浏览 18提问于2020-05-21得票数 0
回答已采纳
1回答
问题
如何推断泛型类的泛型需求(扩展部分中的内容)？
解释
// UserGivenClassThatCouldHaveAnyGeneric
class A<T extends string> {
constructor(a: T) {}
}
我如何推断泛型T必须扩展string。我需要有条件的陈述中的这些信息。
我试过以下几种方法
type E<W> = any extends A<infer T> ? W extends T ? A<W> : void : void
当给定E不扩展T所需的内容时，W应该是无效的，但是当它扩展时，它应该是A
浏览 5提问于2020-04-08得票数 0
回答已采纳
假设我有一个简单的类型，它表示一个Thing键
type ThingKey = "a" | "b" | "c"
我希望为每个值创建一个包含一些元数据的条目，以便稍后对其进行迭代，或者将其用作映射：
interface Thing {
key: ThingKey
stuff: string
moreStuff: number
}
const things: Thing[] = [
{
key: "a",
stuff: "AAA",
moreStuff: 42,
},
浏览 4提问于2019-10-02得票数 0
假设我有一个值列表：
l = [1, -1]
我想取更接近其他值的列表值，例如0，我可以这样做：
min(l, key=lambda v: abs(v - 0))
# prints 1
但是，如果我更改列表中值的顺序，如下所示：
l = [-1, 1]
我调用上面的相同函数，得到的是-1，而不是1，那么在相同距离上有正值和负值的情况下，如何总是得到正值呢？
浏览 5提问于2013-04-07得票数 2
回答已采纳
1回答
如果我没有误解摊销分析，那么这个试题就很狡猾。所以我想我是误会了。
“实现容量为n的集ADT，该集合可以包含小于或等于n的所有正整数。
新集(N)- O(n)
插入(I)- O(1)
成员(I)- O(1)
并(S)- O(1)，其中s是同一类型的集合。如果你愿意，你可以毁了她。
对操作进行运行时间分析。如果你愿意的话，可以使用摊销分析。“
您可以将其实现为一个大小为n的布尔数组。唯一困难的地方是联合行动。我无法解决这个问题，解决方案建议了一个for循环来执行'size(s)‘和操作，这显然是O(n)。但是在for循环之后，他们将s的布尔数组设置为null，并声称这使得摊销运行时间O(
浏览 2提问于2014-12-11得票数 1
回答已采纳
当没有显式类型参数的情况下调用getValues()函数时，下面的类型代码工作得很好。但是，当使用显式类型参数调用它时，可能会导致错误(请参阅下面的调用getValues<'a' | 'b' | 'c' >(store, 'a', 'b') )。
type Store = Record<string, string>;
function getValues<T extends string>(
store: Store, ...keys: T[]
): {[P in T
浏览 2提问于2021-01-14得票数 2
回答已采纳
3回答
假设我有以下数组文字：
const list = ['foo', 'bar', 'baz'] as const;
我试图生成一个类型，它表示这个数组的可能索引。我试图按以下方式实现这一点：
const list = ['foo', 'bar', 'baz'] as const;
type ListIndex = Exclude<keyof (typeof list), keyof []>;
但是ListIndex现在变成了"0" | "1" | "
浏览 1提问于2019-12-04得票数 3
回答已采纳
4回答
元组中的项目没有名称，这意味着您通常没有一种清晰的方法来记录每个项目的含义。
例如，在这个有区别的组合中：
type NetworkEvent =
| Message of string * string * string
| ...
我想说明的是，第一项和第二项分别是发件人和收件人的姓名。做这样的事情是不是很好的做法：
type SenderName = string
type RecipientName = string
type NetworkEvent =
| Message of SenderName * RecipientName * string
| ...
许多C/C++库都
浏览 3提问于2011-12-21得票数 13
回答已采纳
1回答
我正在创建一个函数，其中第一个参数是一个“服务”数组，第二个参数推断这些服务的返回类型。例如：
const serviceOne = createService([], () => Promise.resolve({} as Service1));
const serviceTwo = createService([], () => Promise.resolve({} as Service2));
const serviceThree = createService(
[serviceOne, serviceTwo],
(one, two) => Promise.
浏览 6提问于2022-10-04得票数 0
回答已采纳
1回答
我想要一个并将它的元素转换为一个interface。也就是说，从下面的示例中，我想使用props数组并合成Props接口( Props属性的实际类型与我无关)。
// Given
const props: ReadonlyArray<string> = [ 'a', 'b', 'c' ];
// Output
interface Props {
a: number;
b: number;
c: number;
}
另一种方法可能是从Props接口开始，然后获取props数组。尽管基于这个来自开发人员的TypeScript
浏览 1提问于2019-03-13得票数 0
回答已采纳
我有一个包含以下格式数据的文件：
abc 123 456
cde 45 32
efg 322 654
abc 445 856
cde 65 21
efg 147 384
abc 815 078
efg 843 286
诸若此类。如何使用pig将其转换为以下格式
abc 123 456 cde 45 32 efg 322 654
abc 445 856 cde 65 21 efg 147 348
abc 815 078 efg 843 286
此外，如果abc后缺少cde，则应改为插入空格，因为它是固定宽度的文件。
我试过分组，但对
浏览 0提问于2017-05-18得票数 0
我无法理解在创建Tuple类型的库中看到的代码。
type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N
? R
: _TupleOf<T, N, [T, ...R]>;
export type Tuple<T, N extends number> = N extends N
? number extends N
? T[]
: _TupleOf<T, N, []>
: never;
而且它被使
浏览 7提问于2022-03-31得票数 2
回答已采纳
2回答
我在学习SML方面取得了一些进展，试图巩固我对一些最基本概念的理解。下面的练习证明，还有很多东西要学。
我被要求实现一个名为add的函数，它接收两个数字并返回它们的和。问题是，add应该接收整数和实数的不相交并，并以下列方式返回一个不相交的并:如果接收到的两个数字都是整数，则应该将和作为整数返回。否则，如果这两个参数中有一个是实的，则应将和作为实数返回。
最合理的解决方案是使用数据类型，但我被特别指示不要以任何方式、形状或形式使用它。换句话说，我应该实现某种机制来确定参数的类型，然后确定返回类型。
所有的尝试都是徒劳的。无论是SML推断我的参数是一种特定类型(情况并非如此)，还是要求返回值为某
浏览 2提问于2015-11-14得票数 2
回答已采纳
我有一个属性，基本上可以包含4个可能的字符串。
目前我使用的是一个简单的|，但是我需要重用这些类型，但是我如何为这4个值创建一个接口：
selectedState?: "" | "IN_PROGRESS" | "SUCCESS" | "ERROR"
我希望做一些像这样的事情：
interface SelectedStates: "" | "IN_PROGRESS" | "SUCCESS" | "ERROR"
然后
selectedState?: SelectedSta
浏览 0提问于2020-04-17得票数 2
5回答
例如，我有一个类型：
type abc = 'a' | 'b' | 'c';
如何在编译时生成包含联合所有元素的元组类型？
type t = ['a','b', 'c'];
浏览 7提问于2019-03-12得票数 45
回答已采纳
我有一种类型是元组的结合：
type TupleUnion = ["a", string] | ["b", number] | [Foo, Bar] // ...
我想要定义一个函数，它接受任何类型的K extends TupleUnion[0]参数，并且我希望将返回类型推断为同一元组的第二个元素：
function f<K extends TupleUnion[0]>(key: K): ValueFor<K>
如何定义ValueFor<K extends TupleUnion[0]>以达到预期的结果？
浏览 11提问于2022-07-20得票数 1
在这个中，我看到了一个用方括号包装的联合类型定义(编辑：问题已经解决了)。到目前为止，我只看到没有方括号的联合类型。例如：
type UnionA = number | string;
type UnionB = [number | string];
我知道TS中方括号的以下含义：
数组类型T[]
对象索引结构()
浏览 1提问于2019-07-21得票数 4
回答已采纳
它只是一个肮脏的地形，上面有草块。(这些只是带绿色顶部的土块。)
我对一个统一地形的高度图进行了采样，并在此基础上构造了一个体素地形，并将其划分为若干块，然后将网格组合在一起。
可悲的是，生成的mipmap是坏的，mipmap的变化很容易被注意到:首先绿色的变化，然后它完全变成污垢色。
📷
📷
📷
浏览 0提问于2020-01-21得票数 1
回答已采纳
1回答
我有这段代码，其目的是只打印联合类型Event的案例
type CustomerPromoted = { id: string; level: int }
type CustomerCreated = { id: string; companyName: string }
type Event =
| Created of CustomerCreated
| Promoted of CustomerPromoted
let printEvents (events: Event list) =
events
|> List.iter (fun event -> pr
浏览 6提问于2021-03-06得票数 0
回答已采纳
1回答
关于关系代数(而不是SQL)中的操作的
：
我很难理解为什么两个关系必须是联盟兼容的，才能将联合操作应用到它们上。我在Ramez Elmasri的数据库系统基础知识中遇到了这个问题。
什么是工会兼容性？为什么联合、交叉和差异操作要求应用它们的关系是一致兼容的？
我可以理解为什么在交集和差异中会出现这种情况，但我不明白为什么这个约束也适用于UNION操作。为什么我们不能把两种关系结合在一起(就像一个完全的外部连接)？是什么阻止了任何人这么做？
根据我在Google搜索中收集到的信息，答案是这样的，因为UNION，交集和差分是二进制的集合操作，所以如果结果是一个关系，它必然有相同数量的属性的元组，
浏览 0提问于2017-10-31得票数 -1
我正在编写一个程序，它可以打印出每一个字母组合在2到4个字符之间。正如我现在所拥有的，这个程序工作得很好，但它的实现远非理想。这就是现在的情况：
# make a list that contains ascii characters A to z
ascii = list(range(65, 123))
del ascii[91 - 65 : 97 - 65] # values 91-97 aren't letters
for c1, c2 in product(ascii, repeat=2):
word = chr(c1) + chr(c2)
print(wor
浏览 1提问于2017-12-08得票数 1
回答已采纳
我有一个关于Python的初学者问题。如果我有一个python tuple：
x = ('a', 'b', 'c')
然后x + x会给我：
('a', 'b', 'c', 'a', 'b', 'c')
问题：
当新的Python Tuple被添加到自身的x + x中时，它会发生什么？我可以引用元组x，但是如何引用新的元组x + x呢？它是否变成了一个未引用的内存，这意味着没有指针可以引用它？
谢谢,
G.
浏览 16提问于2018-09-06得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
