c语言 "正号运算符" "作用",Swift语言基本运算符（一）--算术运算符、比较运算符、赋值运算符...

基本运算符

运算符是检查、改变、合并值的特殊符号或短语。例如，加号(+)将两个数相加(如 let i = 1 + 2)。更复杂的运算例子包括逻辑与运算符 &&(如 if enteredDoorCode && passedRetinaScan)。

Swift 支持大部分标准 C 语言的运算符，且为了减少常见编码错误做了部分改进。如：赋值符(=)不再有返回值，这样就消除了手误将判等运算符(==)写成赋值符导致代码错误的缺陷。算术运算符(+，-，*，/，% 等)的结果会被检测并禁止值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见 溢出运算符。

Swift 还提供了 C 语言没有的区间运算符，例如 a.. 或 a...b，这方便我们表达一个区间内的数值。

本章节只描述了 Swift 中的基本运算符，高级运算符 这章会包含 Swift 中的高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。

运算符类型

运算符分为一元、二元和三元运算符:

一元运算符对单一操作对象操作(如 -a)。一元运算符分前置运算符和后置运算符，前置运算符需紧跟在操作对象之前(如 !b)，后置运算符需紧跟在操作对象之后(如 c!)。

二元运算符操作两个操作对象(如 2 + 3)，是中置的，因为它们出现在两个操作对象之间。

三元运算符操作三个操作对象，和 C 语言一样，Swift 只有一个三元运算符，就是三目运算符(a ? b : c)。

受运算符影响的值叫操作数，在表达式 1 + 2 中，加号 + 是二元运算符，它的两个操作数是值 1 和 2。

Swift语言提供了以下几种运算符：算术运算符

比较运算符

逻辑运算符

位运算符

赋值运算符

区间运算符

其他运算符

本章我们介绍算术运算符、比较运算符、赋值运算符。

算术运算符

以下表格列出了 Swift 语言支持的算术运算符，其中变量 A 为 10，变量 B 为 20：运算符描述实例+加号A + B 结果为 30

−减号A − B 结果为 -10

*乘号A * B 结果为 200

/除号B / A 结果为 2

%求余B % A 结果为 0注意：swift3 中已经取消了++、--。

Swift 中所有数值类型都支持了基本的四则算术运算符：加法(+)

减法(-)

乘法(*)

除法(/)1 + 2 // 等于 3

5 - 3 // 等于 2

2 * 3 // 等于 6

10.0 / 2.5 // 等于 4.0

与 C 语言和 Objective-C 不同的是，Swift 默认情况下不允许在数值运算中出现溢出情况。但是你可以使用 Swift 的溢出运算符来实现溢出运算(如 a &+ b)。详情参见 溢出运算符。

加法运算符也可用于 String 的拼接："hello, " + "world" // 等于 "hello, world"

求余运算符

求余运算符(a % b)是计算 b 的多少倍刚刚好可以容入 a，返回多出来的那部分(余数)。求余运算符(%)在其他语言也叫取模运算符。但是严格说来，我们看该运算符对负数的操作结果，「求余」比「取模」更合适些。

我们来谈谈取余是怎么回事，计算 9 % 4，你先计算出 4 的多少倍会刚好可以容入 9 中：

你可以在 9 中放入两个 4，那余数是 1(用橙色标出)。

在 Swift 中可以表达为：9 % 4 // 等于 1

为了得到 a % b 的结果，% 计算了以下等式，并输出 余数作为结果：a = (b × 倍数) + 余数

当 倍数取最大值的时候，就会刚好可以容入 a 中。

把 9 和 4 代入等式中，我们得 1：9 = (4 × 2) + 1

同样的方法，我们来计算 -9 % 4：-9 % 4 // 等于 -1

把 -9 和 4 代入等式，-2 是取到的最大整数：-9 = (4 × -2) + -1

余数是 -1。

在对负数 b 求余时，b 的符号会被忽略。这意味着 a % b 和 a % -b 的结果是相同的。

一元负号运算符

数值的正负号可以使用前缀 -(即一元负号符)来切换：let three = 3

let minusThree = -three // minusThree 等于 -3

let plusThree = -minusThree // plusThree 等于 3, 或 "负负3"

一元负号符(-)写在操作数之前，中间没有空格。

一元正号运算符

一元正号符(+)不做任何改变地返回操作数的值：let minusSix = -6

let alsoMinusSix = +minusSix // alsoMinusSix 等于 -6

虽然一元正号符什么都不会改变，但当你在使用一元负号来表达负数时，你可以使用一元正号来表达正数，如此你的代码会具有对称美。

比较运算符(Comparison Operators)

以下表格列出了 Swift 语言支持的比较运算符，其中变量 A 为 10，变量 B 为 20：运算符描述实例==等于(A == B) 为 false。

!=不等于(A != B) 为 true。

>大于(A > B) 为 false。

>=大于等于(A >= B) 为 false。

<=小于等于(A <= B) 为 true。

所有标准 C 语言中的比较运算符都可以在 Swift 中使用：等于(a == b)

不等于(a != b)

大于(a > b)

小于(a < b)

大于等于(a >= b)

小于等于(a <= b)Swift 也提供恒等(===)和不恒等(!==)这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在 类与结构 章节的 Identity Operators 部分。

每个比较运算都返回了一个标识表达式是否成立的布尔值：1 == 1 // true, 因为 1 等于 1

2 != 1 // true, 因为 2 不等于 1

2 > 1 // true, 因为 2 大于 1

1 < 2 // true, 因为 1 小于2

1 >= 1 // true, 因为 1 大于等于 1

2 <= 1 // false, 因为 2 并不小于等于 1

比较运算多用于条件语句，如 if 条件：let name = "world"

if name == "world" {

print("hello, world")

} else {

print("I'm sorry \(name), but I don't recognize you")

}

// 输出“hello, world", 因为 `name` 就是等于 "world”

关于 if 语句，请看 控制流。

如果两个元组的元素相同，且长度相同的话，元组就可以被比较。比较元组大小会按照从左到右、逐值比较的方式，直到发现有两个值不等时停止。如果所有的值都相等，那么这一对元组我们就称它们是相等的。例如：(1, "zebra") < (2, "apple") // true，因为 1 小于 2

(3, "apple") < (3, "bird") // true，因为 3 等于 3，但是 apple 小于 bird

(4, "dog") == (4, "dog") // true，因为 4 等于 4，dog 等于 dog

在上面的例子中，你可以看到，在第一行中从左到右的比较行为。因为 1 小于 2，所以 (1, "zebra") 小于 (2, "apple")，不管元组剩下的值如何。所以 "zebra" 大于 "apple" 对结果没有任何影响，因为元组的比较结果已经被第一个元素决定了。不过，当元组的第一个元素相同时候，第二个元素将会用作比较-第二行和第三行代码就发生了这样的比较。

当元组中的元素都可以被比较时，你也可以使用这些运算符来比较它们的大小。例如，像下面展示的代码，你可以比较两个类型为 (String, Int) 的元组，因为 Int 和 String 类型的值可以比较。相反，Bool 不能被比较，也意味着存有布尔类型的元组不能被比较。("blue", -1) < ("purple", 1) // 正常，比较的结果为 true

("blue", false) < ("purple", true) // 错误，因为 < 不能比较布尔类型Swift 标准库只能比较七个以内元素的元组比较函数。如果你的元组元素超过七个时，你需要自己实现比较运算符。

赋值运算符

下表列出了 Swift 语言的基本赋值运算符：运算符描述实例=简单的赋值运算，指定右边操作数赋值给左边的操作数。C = A + B 将 A + B 的运算结果赋值给 C

+=相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数。C += A 相当于 C = C + A

-=相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数。C -= A 相当于 C = C - A

*=相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数。C *= A 相当于 C = C * A

/=相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数。C /= A 相当于 C = C / A

%=求余后再赋值，将左右两边的操作数求余后再赋值给左边的操作数。C %= A is equivalent to C = C % A

<<=按位左移后再赋值C <<= 2 相当于 C = C << 2

>>=按位右移后再赋值C >>= 2 相当于 C = C >> 2

&=按位与运算后赋值C &= 2 相当于 C = C & 2

^=按位异或运算符后再赋值C ^= 2 相当于 C = C ^ 2

|=按位或运算后再赋值C |= 2 相当于 C = C | 2

赋值运算符(a = b)，表示用 b 的值来初始化或更新 a 的值：let b = 10

var a = 5

a = b

// a 现在等于 10

如果赋值的右边是一个多元组，它的元素可以马上被分解成多个常量或变量：let (x, y) = (1, 2)

// 现在 x 等于 1，y 等于 2

与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以下面语句是无效的：if x = y {

// 此句错误，因为 x = y 并不返回任何值

}

通过将 if x = y 标记为无效语句，Swift 能帮你避免把 (==)错写成(=)这类错误的出现。

组合赋值运算符

如同 C 语言，Swift 也提供把其他运算符和赋值运算(=)组合的组合赋值运算符，组合加运算(+=)是其中一个例子：var a = 1

a += 2

// a 现在是 3

表达式 a += 2 是 a = a + 2 的简写，一个组合加运算就是把加法运算和赋值运算组合成进一个运算符里，同时完成两个运算任务。组合赋值运算没有返回值，let b = a += 2 这类代码是错误。这不同于上面提到的自增和自减运算符。

更多 Swift 标准库运算符的信息，请看 运算符声明。 ‌