本篇文章给大家谈谈JS基础-运算符-函数，以及js基本运算符的知识点，同时本文还将给你拓展#c++运算符重载之前置++，后置++，负号运算符，类型转换函数，以及输入输出运算符、7大运算符：（算数运算符
本篇文章给大家谈谈JS基础-运算符-函数，以及js基本运算符的知识点，同时本文还将给你拓展# c++运算符重载之 前置++， 后置++， 负号运算符， 类型转换函数， 以及输入输出运算符、7大运算符：（算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符）与其优先级关系、C#小白(基础篇)2 （值类型、字符串类型、算数运算符、赋值运算符、关系运算符 等）、C++编程基础一 22-组合赋值运算符和关系运算符等相关知识，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：- JS基础-运算符-函数（js基本运算符）
- # c++运算符重载之 前置++， 后置++， 负号运算符， 类型转换函数， 以及输入输出运算符
- 7大运算符：（算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符）与其优先级关系
- C#小白(基础篇)2 （值类型、字符串类型、算数运算符、赋值运算符、关系运算符 等）
- C++编程基础一 22-组合赋值运算符和关系运算符
JS基础-运算符-函数（js基本运算符）
1.运算符
1.赋值运算符和扩展运算符
1.赋值运算符 =
2.扩展运算符
+=，-=，*=，/=，%=，^=....
ex:
a=a+b;--> a+=b;
a=a+1;--> a++,a+=1,++a
实现两个数字的换位：
a^=b;
b^=a;
a^=b;
2.条件运算符
条件运算符又称三目运算符。
单目（一元）运算符，只需要一个操作数或表达式。
ex:++，--，！
双目（二元）运算符，需要两个操作或表达式
ex:+,-,*,/,%,>,<,>=,<=,==,===,!=,!==,&,|,^,&&,||
三目（三元）运算符，需要三个表达式或操作数。
语法：
条件表达式？表达式1：表达式2；
先判断条件表达式的值，如果条件为true,则执行表达式1，如果条件为false,则执行表达式2。
ex:
从弹出框中输入成绩，如果成绩大于60，则输出及格，否则输出不及格。
练习：
从弹出框中输入成绩：
如果成绩等于100，则输出"奖励1000元"，
如果成绩>=90，则输出"奖励100元"，
如果成绩>=70，则输出"奖励10元素"，
否则，输出"请大家吃饭"。
2.函数
1.什么是函数
函数，function,也称为方法
函数-功能。
函数是一段预定义好，并可以被反复执行的代码块。
预定义：提前定义好，并非马上执行。
反复执行：允许被多次调用。
代码块：可以包含多条可执行的语句
使用过的函数：
parseInt();
parseFloat();
Number();
alert();
document.write();
2.定义和使用函数
1.普通函数的声明和使用
1.声明
function 函数名(){
//函数体-若干可执行的代码
}
2.调用函数
在任意javascript合法位置处通过
函数名(); 对函数进行调用。
3.要同时调用多个函数方式如下：
function test(){
calculate(); //调用函数1
print();//调用函数2
}
练习：
1.定义一个函数名称calaulate(计算)
在函数体内，定义两个变量,num1, num2并赋值为数字，计算两个数字之和，并打印在控制台。
2.在网页中添加一个按钮，单击按钮时调用函数。
2.带参函数的声明和使用
1.声明
function 函数名(参数列表){
//函数体-js语句
}
参数列表：可以声明1个或多个参数，多个参数间用逗号分隔。
声明函数时，声明的参数称为“形参”。
2.调用
函数名(参数值列表);
注意：尽量按照声明函数的格式进行调用
调用时，传递的参数值称为“实参”。
练习：
定义带参函数，函数体内计算两个参数的乘积，并打印输出。单击按钮时调用函数。
3.带返回值函数的声明和使用
1.声明
function 函数名(){
//函数体
return 值;
}
2.调用
允许使用一个变量接收函数的返回值
var result=函数名();
练习：
定义一个可以接收三个参数的函数，函数体内返回三个数字的和。并将结果打印在控制台。
3.函数的作用域
1.变量作用域
作用域表示的是变量或函数的可访问范围。
js中的作用域分为两种：
1.函数作用域：只在函数范围内有效
函数作用域又称为局部变量，只在声明的函数中有效
2.全局作用域：js代码的任何位置都有效
全局作用域又称全局变量，一经声明，任何位置都能使用。
1.不在function中声明的变量，为全局变量
2.声明变量不使用var ,无论任何位置声明，都是全局变量（不推荐）
2.注意
1.全局变量和局部变量冲突时，优先使用局部变量。
2.声明提前
js程序正式执行之前，function声明的函数，会将所有var声明的变量，都预读到所在作用域的顶部，但赋值还是保留在原位置。
函数同样也有声明提前的功能。
3.按值传递
1.什么是按值传递
原始数据类型，在做参数传递时，都是按照“值传递”的方式来传参。
值传递：真正传递参数时，实际上传递的是值的副本（复制出来一个值），而不是原始值。
*以后不要把原始数据类型拿到函数中去修改值。
练习：
1.创建变量score,赋值为90；
2.再创建函数changeScore(num),在函数体内将num+5再输出。
3.调用changeScore函数,并将score以实参传入函数，再输出score的值。
3.函数作用域
分为两种：
1.局部函数
在某个function中声明的函数
2.全局函数
在最外层<script>定义的函数就是全局函数，全局函数一经定义，任何位置都能调用。
4.ECMAScript提供一组全局函数
1.parseInt();
2.parseFloat();
3.Number();
4.isNaN();
5.encodeURI();
URL:Uniform Resource Locator统一资源定位器，俗称：路径
URI:Uniform Resource Identifier(标识符)
作用：对统一资源标识符进行编码，并返回编码后的字符串。
所谓的编码，就是将地址中多字节的文字编码成单字节文字。
6.decodeURI();
作用：对已编码的URI进行解码，并返回解码后的字符串。
7.encodeURIComponent();
在encodeURI的基础上，允许对特殊字符进行编码。
8.decodeURIComponent();
允许对特殊字符解码。
9.eval();
作用：执行以字符串表示的js代码
练习：
定义一个函数，在函数体内接收弹出框输入的一段js代码（document.write("<h1>js全局函数</h1>")），并用eval函数来执行该段js代码。
5.递归调用
递归：在一个函数的内部再一次调用自己。
问题：想要求5的阶乘
5！ 5*4*3*2*1 -->5*4！
4！ 4*3*2*1 -->4*3!
3！ 3*2*1 -->3*2!
2！ 2*1 -->2*1!
1！ 1*1
求n的阶乘，用一个函数表示？
function f(n){
/*if(n==1){
return 1;
}else{
return n*f(n-1)
}*/
return n==1?1:n*f(n-1)
}
效率：
在本次调用还未结束时，就开始下次的调用，本次调用就会被挂起，直到所有的调用都完成之后，才会依次返回，调用次数越多，效率越低。
练习：
以下数列（斐波拉契数列）
1,1,2,3,5,8,13,21,34,55......
通过f(n)计算数列中第n个数字的值。
已知：
该数列中第一个数和第二个数都是1。
从第三个数开始，每个数字都是前两个数字的和。
f(1)=1
f(2)=1
f(3)=f(2)+f(1)
f(4)=f(3)+f(2)
...
f(n)=f(n-1)+f(n-2)
# c++运算符重载之 前置++， 后置++， 负号运算符， 类型转换函数， 以及输入输出运算符
c++运算符重载之 前置++， 后置++， 负号运算符， 类型转换函数， 以及输入输出运算符
标签（空格分隔）： c++
前言
我在c++学习的过程中， 对这几个不太常见的运算符重载不太会写。出现了很多bug，而且搜索网上东西也比较少，所以特地写这一篇来分享给大家，同时加深印象。有出错的地方希望给位朋友斧正。
先看例子, 我定义一个类 Int 和我们基础的c++ int是一个意思
using namespace std;
#include <iostream>
class Int
{
int data;
public:
Int &operator++()； //前置++
operator int()； //转换运算符
Int operator++(int) ； //后置++
Int &operator--() ； //前置--
Int operator--(int) ； //后置--
Int operator-() ； //负号运算符
friend ostream & operator<<(ostream &out, Int& a) ； //输出运算符号
friend istream & operator >> (istream &in, Int& a) ； //输入运算符号
};
1.前置与后置++ 前置–和后置–
首先明确的是咱们c和c++ 的前置++和后置++ 都是重载的++ 那他们的重载怎么写呢？
Int& Int::operator++() { //前置++
this->data++;
return *this;
}
Int Int::operator++(int) { //后置++
Int tmp(*this);
this->data++;
return tmp;
}
Int& Int::operator--() { //前置--
this->data--;
return *this;
}
Int Int::operator--(int) { //后置--
Int temp(*this);
this->data--;
return temp;
}
Int& Int::operator++() //前置++
Int Int::operator++(int) //后置++
细心的朋友已经发现了 关键在于后置的重载++ 首先返回的是Int而不是 对象的引用， 然后在最后面（int）加了int参数 。 第一个问题好解决，因为我后置++函数返回的是tmp这个临时对象，在函数结束后被释放了，所以当然不能传引用啦， 对于第二个问题，这个是c++的规定。好吧我也很无语。只要在重载操作符的参数中加上一个int型参数，记住你改成double 都会错的。
前置–和后置–原理与前面相同，代码相似，不予复述。
2类型转换函数
转化运算符， 就是把类的对象转化成其他（基本类型，或其他类型）
Int::operator int() { //转换运算符
return data;
}函数形式里不能有返回值，不能有参数，只能返回要转换的数据类型。 这里int是我要转化的类型所以我括号前是写int 返回的也是int 类型。
用于处理这样的问题
int c = 0;
Int c1(2);
c = c1; //这时 c1调用类型转换函数 对象c1返回了int 赋给变量c3负号重载
Int Int::operator-() { //负号运算符
Int tmp;
tmp.data = -data;
return tmp;
}函数形式里，不能有参数，返回对象(不能是引用原因和后置++相同)。
记住要用一个临时的tmp来储存变负的对象属性值，返回tmp
下面是错误的写法：
Int Int::operator-() { //负号运算符
data = -data;
}重载-号的意思不是直接改变对象的符号，是返回一个符号相反的对象，举个例子，-5不是说把5改成负数，是得到5的相反数，准确说，负号有两个重载，取反操作符和减号操作符，这个是前者
4输入输出重载
ostream & operator<<(ostream &out, Int& a) { //输出运算符号
out << a.data;
return out;
}
istream & operator >> (istream &in, Int& a) { //输入运算符号
in >> a.data;
return in;
}
提几个小问题吧， 首先所有参数都是引用不是对象（尤其是输入函数不传引用，输入函数不改变值） 然后要记得 istream是用在输入中 不要用反， 不要加作用域运算符。
7大运算符：（算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符）与其优先级关系
一，运算符(7种算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符)
优先级：
(1) 个别运算符:
优先级最高 ** 幂运算
优先级最低 = 赋值运算符
() 括号可以提升运算优先级
(2) 整体 一元运算符 > 二元运算符
一元运算符: 同一时间,只操作一个值 - ~
二元运算符: 同一时间,操作两个值 + - * / ...
(3) 同一层级
逻辑: () > not > and > or
算数: 乘除 > 加减
位运算符: ( << >> ) > & > ^ > |
(4) 其他运算符
算数运算符 > 位运算符 > 比较运算符 > 身份运算符> 成员运算符 > 逻辑运算符
赋值运算符是最后算完进行赋值,做收尾工作的.
"""
res = 5+5 << 6//3 is 40 and True
print(res)
"""
res = 10 << 2 is 40 and True
res = 40 is 40 and True
res = True and True
res = True
"""
# 加上括号包起来,让别人能看懂代码;
res = (5+5) << (6//3) is 40 and True
（1）算术运算符 + - * / // % **
var2 = 4
# +
res = var1 + var2
print(res)
# -
res = var1 - var2
print(res)
# *
res = var1 * var2
print(res)
# / 除法 (结果为小数)
res = var1 / var2
res = 10 / 5
print(res)
# // 地板除 (返回整数)
res = 10 // 5
res = 11 // 4
print(res)
# 如果被除数或者除数是一个小数,结果加上.0
res = 11.0 // 4
print(res)
# % 取余
res = 11 % 4
res = -11 % 4 # -3 + 4 = 1
res = 11 % -4 # 3 + (-4) = -1
res = -11 % -4 # -3(如果被除数和除数都是负数,在正常得到的结果前面填上负号即可.)
print(res)
res = -17 % 7 # -3 + 7 = 4
res = 17 % -7 # 3 + (-7) = -4
res = -17 % -7 #-3
print(res)
# ** 幂运算
res = 3 ** 2
res = 3 ** 4
print(res)
（2）比较运算符> < >= <= == !=
比较运算符只会差生两种结果: True 真的 ,False 假的
var1 = 100
var2 = 100
res = var1 > var2
res = var1 < var2
res = var1 >= var2
res = var1 <= var2
print(res)
# 注意点
res = var1 == var2
print(res)
（3）赋值运算符
= += -= *= /= //= %= **=
# = 从右向左,将右侧的值赋值给左侧变量
var1 = 9
var2 = 2
# +=
"""var1 = var1 + var2"""
# var1 += var2
# print(var1)
# -=
"""var1 = var1 - var2"""
# var1 -= var2
# print(var1)
# *=
"""var1 = var1 * var2"""
# var1 *= var2
# print(var1)
# /=
"""var1 = var1 / var2"""
# var1 /= var2
# print(var1)
# //=
"""var1 = var1 // var2"""
# var1 //= var2
# print(var1)
# %=
"""var1 = var1 % var2"""
# var1 %= var2
# print(var1)
# **=
"""var1 = var1 ** var2"""
var1 **= var2
print(var1)
(4)成员运算符：in 和 not in （针对于容器类型数据）
strvar = "雷霆嘎巴,无情哈拉少"
res = "雷" in strvar
res = "文" not in strvar
res = "无情" in strvar
res = "霆哈少" in strvar
res = '','' not in strvar
print(res)
# list tuple set
lst = ["余锐","高学峰","治理追","温子月","草神光"]
res = "高学峰" in lst
print(res)
tup = ("余锐","高学峰","治理追","温子月","草神光")
res = "李博伦" not in tup
print(res)
setvar = {"金角大王","银角大王","神秘男孩"}
res = "神秘男孩" in setvar
print(res)
# dict
""" in 和 not in 在字典中只判断键,不判断值 """
dic = {"yr":"英俊帅气","bx":"抠脚大汉","mcp":"高大威猛"}
res = "英俊帅气" in dic # False
res = "yr" in dic
res = "mcp" not in dic
print(res)
(5)身份运算符： is和 is not（检测两个数据在内存当中是否是同一个值）
""" 字符串必须是一个连续的片段 """
strvar = "雷霆嘎巴,无情哈拉少"
res = "雷" in strvar
res = "文" not in strvar
res = "无情" in strvar
res = "霆哈少" in strvar
res = '','' not in strvar
print(res)
# list tuple set
lst = ["余锐","高学峰","治理追","温子月","草神光"]
res = "高学峰" in lst
print(res)
tup = ("余锐","高学峰","治理追","温子月","草神光")
res = "李博伦" not in tup
print(res)
setvar = {"金角大王","银角大王","神秘男孩"}
res = "神秘男孩" in setvar
print(res)
# dict
""" in 和 not in 在字典中只判断键,不判断值 """
dic = {"yr":"英俊帅气","bx":"抠脚大汉","mcp":"高大威猛"}
res = "英俊帅气" in dic # False
res = "yr" in dic
res = "mcp" not in dic
print(res)
(6)逻辑运算符: and or not
# and 逻辑与
"""全真则真,一假则假"""
res = True and True # True
res = True and False # False
res = False and True # False
res = False and False # False
print(res)
# or 逻辑或
"""全假则假,一真则真"""
res = True or True # True
res = True or False # True
res = False or True # True
res = False or False # False
print(res)
# not 逻辑非
"""真变假,假变真"""
res = not True
res = not False
print(res)
# 逻辑短路: 如果出现了短路效果,后面的代码不执行
"""
短路:
(1) True or 表达式
(2) False and 表达式
"""
"""
True or print("紫月真胖呀")
True or True => True
True or False => True
False and print("紫月真猛呀")
False and False => False
False and True => False
"""
"""
bool 类型为假的十种情况
0 0.0 0j False '''' [] () {} set() None
先用大脑算一下布尔值真假,是否出现短路情况
如果出现了直接返回当前值,没出现,继续向右执行;
"""
res = 5 or 6
res = 0 or 6
res = 0 and 9
print(res)
逻辑运算符的优先级
() > not > and > or
eg:
res = 5 or 6 and 7 # 5 or 7 => 5
res = (5 or 6) and 7 # 5 and 7 => 7
res = not(5 or 6) and 7 # not 5 and 7 => False and 7 =>False
print(res)
res = 1>2 or 3<4 and 5>10 or 11<12 and 13>15 or 100<1000 and 1<2
# res = False or True and False or True and False or True and True
# res = False or False or False or True
# res = False or False or True
# res = False or True
# res = True
print(res)
(7)位运算符 & | ^ << >> ~
# 按位与 &
var1 = 19
var2 = 15
print(var1 & var2)
"""
19的二进制
0000 ... 10011
15的二进制
0000 ... 01111
0000 ... 10011
0000 ... 01111
0000 ... 00011 => 3
"""
# 按位或 |
var1 = 19
var2 = 15
print(var1 | var2)
"""
19的二进制
0000 ... 10011
15的二进制
0000 ... 01111
0000 ... 10011
0000 ... 01111
0000 ... 11111 => 31
"""
# 按位异或 ^ 两个值不一样,返回真,否则返回假
"""
1 0 => 1
1 1 => 0
0 0 => 0
0 1 => 1
"""
var1 = 19
var2 = 15
print(var1 ^ var2)
"""
19的二进制
0000 ... 10011
15的二进制
0000 ... 01111
0000 ... 10011
0000 ... 01111
0000 ... 11100 => 28
"""
# << 左移
""" 左移相当于做乘法 : 5 * 2的n次幂 """
res = 5 << 1 # 10
res = 5 << 2 # 20
res = 5 << 3 # 40
print(res)
"""
0000 ... 101
0000 ... 1010 移动一位 10
0000 10100 移动二位 20
"""
# >> 右移
""" 右移相当于做除法 : 5 // 2的n次幂 """
res = 5 >> 1 # 2
res = 5 >> 2 # 1
res = 5 >> 3 # 0
print(res)
"""
0000 ... 101
0000 ... 010 移动一位 2
0000 ... 001 移动二位 1
0000 ... 000 移动三位 0
"""
# ~ 按位非 (针对于补码进行操作,按位取反,包括符号位)
"""公式: -(n+1)"""
var1 = ~19
print(var1)
"""
~ 按位非每一位都取反,包括符号位,求反码每一位除了符号位,都取反.
原码:0000 ... 10011
反码:0000 ... 10011
补码:0000 ... 10011
补码: 0000 ... 10011
按位非: 1111 ... 01100
给你补码求原码:
补码: 1111 ... 01100
反码: 1000 ... 10011
原码: 1000 ... 10100 => -20
"""
var1 = ~(-22)
print(var1)
"""
原码: 1000 ... 10011
反码: 1111 ... 01100
补码: 1111 ... 01101
补码: 1111 ... 01101
按位非: 0000 ... 10010
给你补码求原码:
正数 : 补码 = 反码 = 原码
原码: 0000 ... 10010 => 18
"""
C#小白(基础篇)2 （值类型、字符串类型、算数运算符、赋值运算符、关系运算符 等）
2.1 C#中的基本数据类型
C#中变量的数据类型分为：值类型、引用类型、指针类型。
C#中值类型分为以下：
整型：
byte、int 、short 、long
byte的范围 0-255 1字节
short的范围 -32768 ---32767 2字节
int的范围 -2147483648 -- 2147483647 4字节
long的范围 -910^18 --- 910^18 8字节
浮点型：
float -3.4x 10^38 ~ + 3.4 x 10^38 4个字节单精度 有精度损耗 0.0F 精确到小数点后大约7位 double (+/-)5.0 x 10-324 ~ (+/-)1.7 x 10308 8个字节双精度 有精度损耗 0.0D 精确到小数点后大约15~16位
十进制：
decimal(精确) ±1.0 × 10^-28 到 ±7.9 × 10^28 16个字节 无损耗 0.0M 有效位数28位
布尔类型：
bool （true、false）
字符类型：
char 只能包含一个字符 ，‘\0’表示空字符
可空类型（只能是值类型可空 如：int？表示可空int）：
Nullable<T> 基础值类型正常范围内的值，再加上一个 null 值。
枚举（值类型）：
enum 一组命名整型常量，用 enum 关键字声明的
结构体：
struct 值类型数据结构
// 整型
int a = 1;
long longNum = 12345;
byte b1 = 256; //超范围,错误
// 浮点类型
// 不确定类型的时候可以使用var（自匹配）声明变量，他可以根据值来推导变量的类型
var money = 2.3; // 当有小数的时候默认是double类型
float f1 = 3.45f;// 如果想要声明单精度类型，需要在小数后面加f或者F
double d2 = 23.56D;// double 不带后缀也可带：D或d
decimal de1 = 2.3m;// decimal 带后缀 M m
Console.WriteLine(sizeof(decimal)); // 查看decimal类型分配的内存
// 可空类型：注意,C#中的可空类型只能是值类型
// Nullable<T> int? float? double? Nullable<int>
// int c = null;//不可运行 引用类型 null
int? c = null;//可以运行
// bool类型，值为true或者false
bool bl = false;
// char类型
char a = ''a'';2.2 字符串类型
字符串类型： 由一个或多个字符构成的一组字符，string类型是System.String类的别名。它是从object类型派生的。string类型的值可以通过两种形式进行分配：引号和@引号。
注意：C#中字符串类型是引用类型。
如：string ss=”liming” 或 ss=@“liming”
@将转义字符（\）当作普通字符对待
@字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。
string ss = "\r\nliming";
ss = @"\r\nliming2";
Console.WriteLine(ss);
// ss="" 或string.empty 会分别空间 长度0 null 不会分配空间
string ss2 = "", ss3 = string.Empty, ss4 = null;
Console.ReadLine();转义字符：
// 转义符指的就是一个''''+一个特殊的字符，组成了一个具有特殊意义的字符。
\n:表示换行
":表示一个英文半角的双引号
\t:表示一个tab键的空格
\b:表示一个退格键，放到字符串的两边没有效果。
\r\n:windows操作系统不认识\n,只认识\r\n
\:表示一个\2.3 算数运算符
算术运算符：+ - * / %(取余数 取模)
算术表达式：由算术运算符连接起来的式子，如:1+1 a-b(变量ab前面已声明并赋初值)
演示： 某学生三门课成绩为，语文:90 数学:80 英语:67，编程求总分和平均分.
优先级: 先乘除、后加减、有括号先算括号里的、相同级别的从左至右运算 int a=((1+5)+3)*2
小括号可以无限制的套用，但一定要成对出现。
注意：这边的+ - 也可以表示正负运算符
2.4 赋值运算符
++ 自加1 有前加和后加
-- 自减1 有前减和后减
+= -= *= /= %=
对于像++ -- 这样的只需要一个操作数就能进行运算的运算符，我们叫做一元运算符
对于+-*/%=都需要两个操作数才能进行运算的这些运算符，我们叫做二元运算符
PS：一元运算符++/--比二元的+-优先级高2.5 关系运算符
> <
== !=
>= <=int a = 10;
int b =10;
Console.WriteLine(a!=b);2.6 逻辑运算符 &&(逻辑与) ||(逻辑或) !(逻辑非)
- 表达式1&&表达式2
| 表达式1 | 表达式2 | 表达式1&&表达式2 |
|---|---|---|
| True | True | True |
| False | True | False |
| True | False | False |
| False | False | false |
- 表达式1||表达式2
| 表达式1 | 表达式2 | 表达式1 ll 表达式2 |
|---|---|---|
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | false |
- !表达式
| 表达式 | !表达式 |
|---|---|
| True | False |
| False | true |
逻辑运算符的短路效果
C#中的逻辑运算符具有短路效果。这意味着当表达式中的一个操作数已经确定了表达式的值时，就不再计算表达式的其他部分。
例如，考虑以下代码：
int x = 10;
int y = 5;
if (x > 5 && y < 10)
{
Console.WriteLine("哈哈哈哈哈");
} 在这个代码中，如果x不大于5，则表达式(x > 5 && y < 10)的值将是false，无需计算y < 10。这是因为在逻辑与运算符中，如果左操作数为false，则整个表达式的结果将为false。这个过程被称为“短路”，因为表达式在遇到第一个false值时就“短路”了。 同样地，对于逻辑或运算符，如果左操作数为true，则整个表达式的结果将是true，无需计算右操作数。这种情况下也会发生短路。 短路效果可以在编写C#代码时提高性能，因为不必计算表达式的所有部分，从而节省了计算资源。
2.7 位运算符
^、& 和 | 运算符是位运算符，用于对二进制数进行按位操作。这些运算符可以对每个二进制位进行逻辑运算，执行异或、按位与和按位或等操作。
- ^ 运算符：异或运算符。当两个二进制位不同时，结果为 1，否则结果为 0。例如，二进制数 1010 ^ 0110 的结果为 1100。
- & 运算符：按位与运算符。当两个二进制位都为 1 时，结果为 1，否则结果为 0。例如，二进制数 1010 & 0110 的结果为 0010。
- | 运算符：按位或运算符。当两个二进制位至少有一个为 1 时，结果为 1，否则结果为 0。例如，二进制数 1010 | 0110 的结果为 1110。
~ 运算符是按位取反运算符，用于将一个二进制数的每个位取反，即将 0 变为 1，将 1 变为 0。它的作用相当于将整数的二进制位进行取反操作。
int a = 10; // 二进制数为 0000 1010 int b = ~a; // b 的值为 -11（二进制数为 1111 0101）
这些运算符通常用于处理底层的位操作，例如处理网络协议、图形处理、加密和解密等。在 C# 中，可以使用它们来设置、清除或测试二进制位。例如，可以使用 & 运算符来测试一个字节中的某个位是否为 1，使用 | 运算符来将某个位设置为 1，使用 ^ 运算符来切换某个位的值等。
2.8 左移和右移运算符
左移和右移运算符是位运算符，也称为移位运算符。它们可以对二进制数进行按位移位操作。下面分别介绍一下这两个运算符的作用：
<<运算符：左移运算符。将一个二进制数向左移动指定的位数，相当于在其末尾添加指定数量的零。例如，二进制数 1010 左移 2 位的结果为 101000。>>运算符：右移运算符。将一个二进制数向右移动指定的位数，相当于将其末尾的指定数量的位数删除。例如，二进制数 1010 右移 2 位的结果为 10。int a = 10; // 二进制数为 1010 int b = a << 2; // b 的值为 40，二进制数为 101000 int c = a >> 1; // c 的值为 5，二进制数为 101
2.9 运算符的优先级
C++编程基础一 22-组合赋值运算符和关系运算符
1 // 22-组合赋值运算符和关系运算符.cpp: 定义控制台应用程序的入口点。
2 //
3
4 #include "stdafx.h"
5 #include <iostream>
6 #include <climits>
7 #include <array>
8 #include <string>
9 using namespace std;
10
11 int main()
12 {
13 // + - * /
14 //+= -= *= /= %= 组合赋值运算符
15 int a = 23,b = 29;
16 a += b; //a=a+b;
17 cout << a << endl;
18 a -= b;
19 cout << a << endl;
20 a*=b;
21 cout << a << endl;
22 a /= b;
23 cout << a << endl;
24 a %= b;
25 cout << a << endl;
26
27 //> >= < <= == != 关系运算符
28 bool res = 34 > 89;
29 cout << res << endl;
30 int e = 100, f= 90;
31 cout << (e > f) << endl;
32
33 //字符串比较
34 char str1[] = "uimodel";
35 char str2[] = "uimode1";
36 cout << (str1 == str2)<<endl; //数组本身就是指针，在不同的地址中，默认比较的是地址，所以值不相等，0是false。
37 //如果判断字符串（指针）地址中的数据是否相同呢？
38 strcmp(str1, str2); //比较的就是字符串地址中的值，0相等 非零 不等
39 cout << strcmp(str1, str2) << endl; //如果是比较C语言风格字符串，就需要使用strcmp这的函数进行比较。
40
41 //C++风格的字符串直接比较就行
42 string str3 = "uimodel1";
43 string str4 = "uimodel2";
44 cout << (str3 == str4) << endl; //false，输出结果是0。
45
46 int t;
47 cin >> t;
48 return 0;
49 }
今天关于JS基础-运算符-函数和js基本运算符的介绍到此结束，谢谢您的阅读，有关# c++运算符重载之 前置++， 后置++， 负号运算符， 类型转换函数， 以及输入输出运算符、7大运算符：（算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符）与其优先级关系、C#小白(基础篇)2 （值类型、字符串类型、算数运算符、赋值运算符、关系运算符 等）、C++编程基础一 22-组合赋值运算符和关系运算符等更多相关知识的信息可以在本站进行查询。
本文标签：
