최고의 언어 연산자 이동 튜토리얼 2024년, 이 튜토리얼에서는 산술 연산자,관계 연산자,논리 연산자,비트 연산자,할당 연산자,다른 연산자,연산자 우선 순위,를 배울 수 있습니다.
연산자는 실행중인 애플리케이션에 수학적 또는 논리적 연산을 수행하는데 사용된다.
이동 통신 사업자는 언어에 내장되어 있습니다 :
의 도입 연산자 세부 사항의 각 살펴 보자.
다음 표는 모든 언어는 산술 연산자를 이동합니다. 가정 A는 10입니다, B는 20입니다.
운영자 | 기술 | 예 |
---|---|---|
+ | 첨가 | A + B 출력 (30) |
- | 뺄셈 | A - B 출력 -10 |
* | 곱한 | A * B (200)의 출력 |
/ | 분할 된 | B / A 출력 2 |
% | 나머지 | B의 % A를 출력 0 |
++ | 증가 | ++ 출력 (11) |
- | 감소 | 할까 ko 출력 (9) |
다음의 예는 다양한 산술 연산자의 사용법을 보여줍니다
package main import "fmt" func main() { var a int = 21 var b int = 10 var c int c = a + b fmt.Printf("第一行 - c 的值为 %d\n", c ) c = a - b fmt.Printf("第二行 - c 的值为 %d\n", c ) c = a * b fmt.Printf("第三行 - c 的值为 %d\n", c ) c = a / b fmt.Printf("第四行 - c 的值为 %d\n", c ) c = a % b fmt.Printf("第五行 - c 的值为 %d\n", c ) a++ fmt.Printf("第六行 - c 的值为 %d\n", a ) a-- fmt.Printf("第七行 - c 的值为 %d\n", a ) }
상기 동작 결과의 예 :
第一行 - c 的值为 31 第二行 - c 的值为 11 第三行 - c 的值为 210 第四行 - c 的值为 2 第五行 - c 的值为 1 第六行 - c 的值为 22 第七行 - c 的值为 21
다음 표는 이동 언어 관계 연산자를 모두 나열합니다. 가정 A는 10입니다, B는 20입니다.
운영자 | 기술 | 예 |
---|---|---|
== | 두 값이, 그렇지 않으면 거짓 경우 사실과 동일, 동일 반환됩니다 확인하십시오. | (A == B는) False입니다 |
! = | 두 값이 동일하지 여부, 그렇지 않은 경우는 false 경우 동일한 True를 반환하지, 확인합니다. | (A! = B)은 True입니다 |
> | 왼쪽 값이 오른쪽 값 true, 그렇지 않은 경우는 false 반환보다 큰 확인합니다. | (A> B)은 False입니다 |
< | 왼쪽 값이 오른쪽 값 true, 그렇지 않은 경우는 false 반환 미만인 확인합니다. | (A는 <B) True입니다 |
> = | 이렇게하지 않으면 거짓이면 값이 적절한 값으로 좌 이상인지 여부가 True를 반환 확인한다. | (A> = B)은 False입니다 |
<= | 이렇게하지 않으면 거짓이면 값이 적절한 값으로 왼쪽 이하인지 여부를 확인 TRUE를 반환한다. | (A <= B)은 True입니다 |
다음의 예는 관계 연산자의 사용법을 보여줍니다
package main import "fmt" func main() { var a int = 21 var b int = 10 if( a == b ) { fmt.Printf("第一行 - a 等于 b\n" ) } else { fmt.Printf("第一行 - a 不等于 b\n" ) } if ( a < b ) { fmt.Printf("第二行 - a 小于 b\n" ) } else { fmt.Printf("第二行 - a 不小于 b\n" ) } if ( a > b ) { fmt.Printf("第三行 - a 大于 b\n" ) } else { fmt.Printf("第三行 - a 不大于 b\n" ) } /* Lets change value of a and b */ a = 5 b = 20 if ( a <= b ) { fmt.Printf("第四行 - a 小于等于 b\n" ) } if ( b >= a ) { fmt.Printf("第五行 - b 大于等于 b\n" ) } }
상기 동작 결과의 예 :
第一行 - a 不等于 b 第二行 - a 不小于 b 第三行 - a 大于 b 第四行 - a 小于等于 b 第五行 - b 大于等于 b
다음 표는 모든 언어는 논리 연산자를 이동합니다. A는 사실이다, B는 거짓입니다 가정합니다.
운영자 | 기술 | 예 |
---|---|---|
&& | 논리 AND 연산자입니다. 피연산자의 양면에 해당하는 경우, 조건은 true, 그렇지 않은 경우는 false입니다. | (A && B는) False입니다 |
|| | 논리 OR 연산자입니다. 양쪽 피연산자 진정한있는 경우, 조건은 참 그렇지 않으면 거짓이다. | (A || B는) True입니다 |
! | 논리 NOT 연산자. 조건이 참이면, 논리, 그렇지 않으면 참, 거짓 컨디셔닝 없습니다. | ! (A && B는) True입니다 |
다음의 예는 논리 연산자를 사용하는 방법을 보여줍니다 :
package main import "fmt" func main() { var a bool = true var b bool = false if ( a && b ) { fmt.Printf("第一行 - 条件为 true\n" ) } if ( a || b ) { fmt.Printf("第二行 - 条件为 true\n" ) } /* 修改 a 和 b 的值 */ a = false b = true if ( a && b ) { fmt.Printf("第三行 - 条件为 true\n" ) } else { fmt.Printf("第三行 - 条件为 false\n" ) } if ( !(a && b) ) { fmt.Printf("第四行 - 条件为 true\n" ) } }
상기 동작 결과의 예 :
第二行 - 条件为 true 第三行 - 条件为 false 第四行 - 条件为 true
메모리 비트 정수에 비트 연산자는 작동합니다.
다음 표는 비트 연산자 &, 나열 |, 그리고 ^ 계산된다 :
피 | 큐 | P & Q | P | Q | P ^ q를 |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | (1) | 0 | (1) | (1) |
(1) | (1) | (1) | (1) | 0 |
(1) | 0 | 0 | (1) | (1) |
가정이 A = 60, B = 13; 이진 수 :
A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
다음 표에 표시된 비트 컴퓨팅 지원 C 언어 기호입니다. B (13), 즉 A가 60라고 가정합니다 :
운영자 | 기술 | 예 |
---|---|---|
및 | 비트 AND 연산자 "&"이진 연산자이다. 그 기능은 동작 및 참여의 각 상에 대응하는 2 개의 이진수이다. | (A & B) 결과가 12, 이진 1100 0000 |
| | 비트 OR 연산자는 "|"이진 연산자입니다. 그 기능은 두 숫자 각각 대응하는 이진 위상 또는 동작에 참여하는 | (A는 | B) 결과는 61이고, 진은 00111101이고 |
^ | 비트 단위 배타적 논리합 연산자 "^"이진 연산자이다. 그 기능은 두 개의 숫자 해당 이진 비트 상이하고, 그 결과가 1 대응하는 각 이진 XOR의 조작에 참여한다. | (A ^ B)는 49 바이너리 00110001에 대한 결과 |
<< | 왼쪽 시프트 연산자 "<<"이진 연산자이다. N 비트 좌측 시프트는 2 ^ N에 의해 곱해진다. 숫자 "<<"소수점 이동의 권리, 폐기 높고 낮은 0으로 지정된 비트의 모든 숫자의 왼쪽 피연산자의 왼쪽 "<<"각 이진의 기능. | (240) 진에 대한 <<이 결과는 11110000입니다 |
>> | 오른쪽 시프트 연산자는 ">>"이진 연산자입니다. 오른쪽으로 N 비트는 2 ^ n으로 나누어진다. 그 기능은 오른쪽에있는 ">>"다양한 이진 ">>"왼쪽 피연산자 몇 가지 모두 오른쪽으로 지정된 비트의 수입니다. | >> 15 0000 1111 이진 시스템에 대한 2 결과 |
다음의 예는 논리 연산자를 사용하는 방법을 보여줍니다 :
package main import "fmt" func main() { var a uint = 60 /* 60 = 0011 1100 */ var b uint = 13 /* 13 = 0000 1101 */ var c uint = 0 c = a & b /* 12 = 0000 1100 */ fmt.Printf("第一行 - c 的值为 %d\n", c ) c = a | b /* 61 = 0011 1101 */ fmt.Printf("第二行 - c 的值为 %d\n", c ) c = a ^ b /* 49 = 0011 0001 */ fmt.Printf("第三行 - c 的值为 %d\n", c ) c = a << 2 /* 240 = 1111 0000 */ fmt.Printf("第四行 - c 的值为 %d\n", c ) c = a >> 2 /* 15 = 0000 1111 */ fmt.Printf("第五行 - c 的值为 %d\n", c ) }
상기 동작 결과의 예 :
第一行 - c 的值为 12 第二行 - c 的值为 61 第三行 - c 的值为 49 第四行 - c 的值为 240 第五行 - c 的值为 15
다음 표는 이동 언어 할당 연산자를 모두 나열합니다.
운영자 | 기술 | 예 |
---|---|---|
= | 단순 대입 연산자는 좌변의 값 식을 할당 | C = A + B A를 B + C는 식 결과에 할당 될 |
+ = | 할당하기 전에 함께 추가 | C + = A는 C = C + A와 동일 |
- = | 빼기 대입 한 후 | C - = A는 C = C와 동일는 - |
* = | 그런 다음 할당을 곱하여 | C * = A는 C = C의 * A와 동일 |
/ = | 지정 후 분할 | C / = A는 C = C / A와 동일 |
(%) = | 할당 한 후 나머지 | C의 % = A는 C = C의 % A와 동일 |
<< = | 할당 후 왼쪽 | C << = C와 같은 2 = C << 2 |
>> = | 마우스 오른쪽 버튼으로 할당 후 | C는 >> 2 C = C와 동일한 >> 2 = |
& = | 비트 AND 대입 후 | C = C & 2와 동일한 C & = 2 |
^ = | 비트 XOR 할당을 누른 후 | C = C ^ 2 C ^ = 2와 동일 |
| = | 위치 또는 할당을 누른 후 | C | 2 | = 2 C = C와 동일 |
다음은 대입 연산자 사용을 보여줍니다
package main import "fmt" func main() { var a int = 21 var c int c = a fmt.Printf("第 1 行 - = 运算符实例,c 值为 = %d\n", c ) c += a fmt.Printf("第 2 行 - += 运算符实例,c 值为 = %d\n", c ) c -= a fmt.Printf("第 3 行 - -= 运算符实例,c 值为 = %d\n", c ) c *= a fmt.Printf("第 4 行 - *= 运算符实例,c 值为 = %d\n", c ) c /= a fmt.Printf("第 5 行 - /= 运算符实例,c 值为 = %d\n", c ) c = 200; c <<= 2 fmt.Printf("第 6行 - <<= 运算符实例,c 值为 = %d\n", c ) c >>= 2 fmt.Printf("第 7 行 - >>= 运算符实例,c 值为 = %d\n", c ) c &= 2 fmt.Printf("第 8 行 - &= 运算符实例,c 值为 = %d\n", c ) c ^= 2 fmt.Printf("第 9 行 - ^= 运算符实例,c 值为 = %d\n", c ) c |= 2 fmt.Printf("第 10 行 - |= 运算符实例,c 值为 = %d\n", c ) }
상기 동작 결과의 예 :
第 1 行 - = 运算符实例,c 值为 = 21 第 2 行 - += 运算符实例,c 值为 = 42 第 3 行 - -= 运算符实例,c 值为 = 21 第 4 行 - *= 运算符实例,c 值为 = 441 第 5 行 - /= 运算符实例,c 值为 = 21 第 6行 - <<= 运算符实例,c 值为 = 800 第 7 行 - >>= 运算符实例,c 值为 = 200 第 8 行 - &= 运算符实例,c 值为 = 0 第 9 行 - ^= 运算符实例,c 值为 = 2 第 10 行 - |= 运算符实例,c 值为 = 2
다음 표는 다른 사업자의 언어를 이동 보여줍니다.
운영자 | 기술 | 예 |
---|---|---|
및 | 변수의 메모리 주소를 반환 | & A는, 변수의 실제 주소를 제공합니다. |
* | 포인터 변수입니다. | * A는, 포인터 변수는 |
다음의 예는 다른 연산자의 사용법을 보여줍니다
package main import "fmt" func main() { var a int = 4 var b int32 var c float32 var ptr *int /* 运算符实例 */ fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a ); fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b ); fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c ); /* & 和 * 运算符实例 */ ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */ fmt.Printf("a 的值为 %d\n", a); fmt.Printf("*ptr 为 %d\n", *ptr); }
상기 동작 결과의 예 :
第 1 行 - a 变量类型为 = int 第 2 行 - b 变量类型为 = int32 第 3 行 - c 变量类型为 = float32 a 的值为 4 *ptr 为 4
왼쪽에서 오른쪽으로 약간 운영자가 더 높은 우선 순위를 가지고 이진 연산자 동작 방향이다. 다음 표는 모든 연산자와 우선 순위, 정상에서 하강 우선 순위가 아래로 대표 나열
우선 | 운영자 |
---|---|
(7) | ^! |
6 | * / % ^ & << >> & |
(5) | + - | ^ |
4 | ==! = << => => |
3 | <- |
이 | && |
(1) | || |
물론 일시적 발현의 동작의 전반적인 우선 순위를 향상시키기 위해 괄호를 사용할 수있다.
상기 동작 결과의 예 :
package main import "fmt" func main() { var a int = 20 var b int = 10 var c int = 15 var d int = 5 var e int; e = (a + b) * c / d; // ( 30 * 15 ) / 5 fmt.Printf("(a + b) * c / d 的值为 : %d\n", e ); e = ((a + b) * c) / d; // (30 * 15 ) / 5 fmt.Printf("((a + b) * c) / d 的值为 : %d\n" , e ); e = (a + b) * (c / d); // (30) * (15/5) fmt.Printf("(a + b) * (c / d) 的值为 : %d\n", e ); e = a + (b * c) / d; // 20 + (150/5) fmt.Printf("a + (b * c) / d 的值为 : %d\n" , e ); }
상기 동작 결과의 예 :
(a + b) * c / d 的值为 : 90 ((a + b) * c) / d 的值为 : 90 (a + b) * (c / d) 的值为 : 90 a + (b * c) / d 的值为 : 50