1.算术操作符

+  -  *  /  %

· 使用方法：
(1)%操作符的操作数必须为整数，其余几个操作符可以作用于整数也可以作用于浮点数。
(2)/操作符如果两个操作数都是整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
(3)%模除运算是取整之后的余数，只能操作整数，但对于负数来讲算出来的结果仍为对应的正数的模。

2.位移操作符

<<   左移操作符
>>   右移操作符

· 使用方法

(1) <<    左移操作符(高位丢掉，低位补0):

       将一个数的二进制编码向左移动，高位溢出的舍弃，低位补零

eg:将1左移1位

#include<stdio.h>
int main()
{
	int a = 1;
	printf("%d\n", a << 1);
	return 0;
}

(2) >> 右移操作符:

a.逻辑移位：左边补零，右边丢掉
b.算数运算符：左边补符号位，右边丢弃

eg1:将1右移一位

#include<stdio.h>
int main()
{
	int a = 1;
	printf("%d\n", a >> 1);
	return 0;
}

eg2:将-1右移一位

#include<stdio.h>
int main()
{
	int a = -1;
	printf("%d\n", a >> 1);
	return 0;
}

注： 位移运算符不要移动负数位，这个是未定义的
error eg:

printf("%d\n",num >> -1); //error

3.位操作符

注： 它们的操作数必须是整数

&   //按位与   同1为1，有0为0
|   //按位或   同0为0，有1为1
^   //按位异或 相同为0，相异为1

eg1:不创建临时变量（第三个变量），实现两个数的交换

#include<stdio.h>
int main()
{
	int a = 22,b = 88;
	a = a ^ b;
	b = a ^ b;   //a ^ b ^ b = a 
	a = a ^ b;   //a ^ b ^ a = b
	printf("a=%d b=%d\n", a, b);
	return 0;
}

eg2:求一个整数储存在内存中的二进制中1的个数

方法一：使用按位与判断是否为1

#include<stdio.h>
int CountBitNum(unsigned int x)
{
	int count = 0;
	for (int i = 1; i <= 32; i++)
	{
		if ((x & 1) == 1)
	{
		count += 1;
	}
		x >>= 1;
	}
	return count;
}
int main()
{
	printf("%d\n", CountBitNum(0xFFFFFFFF));
	printf("%d\n", CountBitNum(1));
	printf("%d\n", CountBitNum(123));
	return 0;
}

方法2：使用%判断是否为1

#include<stdio.h>
int CountBitNum(unsigned int x)
{
	int count = 0;     //计数
	for (int i = 0; i < 32; ++i)   //控制循环的次数
	{
		if (x % 2 == 1)
		{
			count += 1;
		}
		x >>= 1;      //右移一位再赋值给x继续循环
	}
	return count;
}
int main()
{
	printf("%d\n", CountBitNum(0xFFFFFFFF));
	printf("%d\n", CountBitNum(1));
	printf("%d\n", CountBitNum(123));
	return 0;
}

1. 主要导包

//协程包
	implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.1"
	//主要导入viewModelScope，lifecycleScope作用域，在View界面操作协程能保证界面安全
    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.3.1'
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.1"
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.3.1"
    implementation "androidx.lifecycle:lifecycle-extensions:2.2.0"
   	//工具包
    implementation "com.blankj:utilcodex:1.29.0"

2. map 转换操作符

map操作符可以看成Rxjava中的map操作符

//创建一个流，每隔一秒发送一个Int数据
    private fun simple(): Flow<Int> = flow {
        for (i in 1..3) {
            delay(1000)
            LogUtils.d("Emitting $i")
            emit(i)
        }
    }
    
    //viewModel中调用，将Int转成String
  viewModelScope.launch {
    simple()
      .map { "response $it" }
      .collect {//数据接收
        LogUtils.d("result $it")
      }
  }

3. filter过滤操作符

过滤掉自己想要的数据

 private fun simple(): Flow<Int> = flow {
        for (i in 1..3) {
            delay(1000)
            LogUtils.d("Emitting $i")
            emit(i)
        }
    }

 //viewModel中调用filter操作符
    fun flowFilter() {
        viewModelScope.launch {
            simple()
                .filter { it != 2 }//过滤掉不为2的数据
                .collect {
                    LogUtils.d("result $it")
                }
        }
    }

结果如下：

 D/Collect: result 1
 D/Collect: result 3

4. take限长操作符

限长操作符,过滤型操作符，与Rxjava中的take相似,只输出输入数字的前面元素，比如take值是2,则只输出前面两个数

 private fun simple(): Flow<Int> = flow {
        for (i in 1..5) {
            delay(1000)
            LogUtils.d("Emitting $i")
            emit(i)
        }
    }

//take操作符
      fun flowTake() {
        viewModelScope.launch {
            simple()
                .take(2)//只获取前面两个数据
                .collect {
                    LogUtils.d("result $it")
                }
        }
    }

 D/Collect: result 1
 D/Collect: result 2

5. drop丢弃操作符

 private fun simple(): Flow<Int> = flow {
        for (i in 1..3) {
            delay(1000)
            LogUtils.d("Emitting $i")
            emit(i)
        }
    }
    
    fun flowDrop() {
        viewModelScope.launch {
            simple()
                .drop(2)//丢到前面两个数据
                .collect() {
                    LogUtils.d("result $it")
                }
        }
    }

D/Collect: result 3

6. flowOn操作符

flowOn 函数，该函数用于更改流发射的上下文，即作用域。简单的来说就是切换线程。flowOn之前的函数线程在flowOn指定的线程作用域，flowOn之后的函数在launch的线程作用域。

    
     private fun flowOn() {
    
     //launch：流在主线程启动，flowOn之后的函数collect在主线程中
     //viewModelScope默认作用域就是主线程，这里可以不用切
        viewModelScope.launch(Dispatchers.Main) {
            flow {
                for (i in 1..3) {
                    delay(1000)
                    LogUtils.d("Thread is ${Thread.currentThread().name} Emitting $i")
                    emit(i)
                }
            }.flowOn(Dispatchers.Default)// //flowOn切换到默认作用域，flow{}中的方法执行在默认线程中，子线程中
                .collect {
                    LogUtils.d("Thread is ${Thread.currentThread().name} collect $it")
                }
        }
    }
    

 Thread is DefaultDispatcher-worker-1 Emitting 1
 Thread is main collect 1
 Thread is DefaultDispatcher-worker-1 Emitting 2
 Thread is main collect 2
 Thread is DefaultDispatcher-worker-1 Emitting 3
 Thread is main collect 3

7. onStart操作符

流执行开始之前调用

 private fun flowStart() {
        viewModelScope.launch(Dispatchers.Main) {
            flow {
                for (i in 1..3) {
                    delay(1000)
                    LogUtils.d("Thread is ${Thread.currentThread().name} Emitting $i")
                    emit(i)
                }
            }.flowOn(Dispatchers.Default)
                .onStart { //flow流执行开始之前
                    
                }.collect {
                    LogUtils.d("Thread is ${Thread.currentThread().name} collect $it")
                }
        }
    }

8. onCompletion完成操作符

流执行完成后调用

private fun flowCompletion() {
        viewModelScope.launch(Dispatchers.Main) {
            flow {
                for (i in 1..3) {
                    delay(1000)
                    LogUtils.d("Thread is ${Thread.currentThread().name} Emitting $i")
                    emit(i)
                }
            }.flowOn(Dispatchers.Default)
                .onCompletion { //flow流执行开始之前

                }.collect {
                    LogUtils.d("Thread is ${Thread.currentThread().name} collect $it")
                }
        }
    }

9. catch异常收集操作符

fun flowCatch() {
        viewModelScope.launch(Dispatchers.Main) {
            flow {
                for (i in 1..3) {
                    delay(1000)
                    if (i == 2) {
                        throw RuntimeException("Error")//数据为2时候报异常
                    }
                    emit(i)
                }
            }.flowOn(Dispatchers.Default)
                .catch { error ->
                    LogUtils.d("Thread is ${Thread.currentThread().name} error $error")
                }.collect {
                    LogUtils.d("Thread is ${Thread.currentThread().name} collect $it")
                }
        }
    }

 D/Collect: Thread is main collect 1
 D/FlowViewModel: Thread is main error java.lang.RuntimeException: Error

10. buffer缓冲操作符

从收集流所花费的时间来看，将流的不同部分运行在不同的协程中将会很有帮助，特别是当涉及到长时间运行的异步操作时。例如，考虑一种情况， 一个 simpleBuffer 流的发射很慢，它每花费 100 毫秒才产生一个元素；而收集器也非常慢， 需要花费 300 毫秒来处理元素。

收发速度不一致时。

//发送数据过快，处理数据过慢
private fun simpleBuffer(): Flow<Int> = flow {
        for (i in 1..3) {
            delay(100)
            LogUtils.d(" Emitting $i")
            emit(i)
        }
    }

     fun flowBuffer(){
        viewModelScope.launch(Dispatchers.Main) {
            simpleBuffer()
                .collect {
                delay(300)
                LogUtils.d(" collect $it")
            }
        }
    }

不加buffer()操作符，执行时间大约在1113ms，添加buffer操作后,执行时间为910ms

   fun flowBuffer(){
        viewModelScope.launch(Dispatchers.Main) {
            simpleBuffer()
                .buffer().collect {
                delay(300)
                LogUtils.d(" collect $it")
            }
        }
    }

  //加载buffer操作符的情况 
   11:20:22.615 13265-13265/com.hjq.viewbinding D/FlowViewModel:  Emitting 1
   11:20:22.717 13265-13265/com.hjq.viewbinding D/FlowViewModel:  Emitting 2
   11:20:22.819 13265-13265/com.hjq.viewbinding D/FlowViewModel:  Emitting 3
   11:20:22.919 13265-13265/com.hjq.viewbinding D/Collect:  collect 1
   11:20:23.222 13265-13265/com.hjq.viewbinding D/Collect:  collect 2
   11:20:23.527 13265-13265/com.hjq.viewbinding D/Collect:  collect 3

11. conflate 合并操作符

当流代表部分操作结果或操作状态更新时，可能没有必要处理每个值，而是只处理最新的那个。在本示例中，当收集器处理它们太慢的时候， conflate 操作符可以用于跳过中间值。

 fun flowConflate() {
        viewModelScope.launch {
            flow {
                for (i in 1..3) {
                    delay(100)
                    LogUtils.d(" Emitting $i")
                    emit(i)
                }
            }.conflate().collect {
                delay(300)
                LogUtils.d(" collect $it")
            }
        }
    }

   //接收时，2数据丢了
   D/FlowViewModel:  Emitting 1
    D/FlowViewModel:  Emitting 2
    D/FlowViewModel:  Emitting 3
    D/Collect:  collect 1
    D/Collect:  collect 3

参考

协程中文网

一、赋值操作符

作用在于更新被赋值数据对象的值，数据对象主要是指信号和变量。VHDL赋值操作符也有信号赋值与变量赋值的区别，分别是：

• ”<="是信号赋值操作符，可以对标量型的信号类型对象或是矢量型信号类型对象整体赋值。
• ”<=“是变量赋值操作符，可以对变量、常量、属性（generic）和信号初始值的赋值或子程序对变量进行赋值。
• ”>=“是矢量型的数据对象的部分进行赋值。

以上赋值举例如下：

**--属性赋值操作**
generic(data_bus:integer:=8);

**--常量赋值操作**
constant address_bus:integer range 1 to 7:=7;

**--信号初始化赋值操作**
signal datasum:std_logic_vector(7 downto 0):="00000000";

**--变量初始化赋值操作**
variable temp:integer range 0 to 63:=0;
variable seg:std_logic_vector(7 downto 0);

**--信号赋值操作**
datasum<="11000011";

**--变量赋值操作**
temp:=23;

**--信号部分赋值操作**
signal datasum:std_logic_vector(7downto 0);
datasum<=(7=>'0',6=>'1',others=>='0');

**--变量部分赋值操作**
variable datasum:std_logic_vector(7 downto 0);
datatemp:=(7 =>'0',6=>'1'.others=>'0');

二、逻辑操作符

VHDL支持7种逻辑操作符的运算，这些运算操作符所支持的常用数据类型有bit、bit_vector、std_logic、std_logic_vector等。

• not (对操作数按位取非操作，对应硬件的”非门“。
• and（对操作数按位取与操作，对应硬件的”与门“。
• or（对操作数按位取或操作，对应硬件的”或门“。
• nand（对操作数按位取与非操作，对应硬件的”与非门“。
• nor（对操作数按位取或非操作，对应硬件的”或非门“。
• xor（对操作数按位取异或操作，对应硬件的”异或门“。
• nxor（对操作数按位取同或操作，对应硬件的”同或门“。

连续逻辑操作符
当语句中出现连续多个逻辑操作符时，为了提高VHDL程序可读性与正确性，建议用括号加以分隔，如下：

dout<=not a and b xor c;--此语句有歧义
dout<=(not a) and (b xor c);--加上括号分隔更加清晰

三、算术操作符

VHDL算术操作符属于算法级的操作，只能操作相应的数据类型，而且有些是不可综合的。常用算术操作符主要有以下8种：

• “+”（对操作数取和）
• “-”（对操作数取差或对单个操作数取负）
• “*”（对操作数取积）
• “/”（对操作数取商）
• “* * " （对操作数作指数运算）
• “abs”（对操作数取绝对值运算）
• “mod”（对操作数取模运算）
• "rem“ （对操作数取余运算）

可以应用算术操作符的数据类型有integer、signed、unsigned和real。其中，real类型是不可综合的。如果VHDL程序引用ieee库的std_logic_signed或是std_logic_unsigned，则std_logic_vector类型的数据对象也可以应用算术操作符。由于算术操作符是算法级别的，可综合性不同则综合器就不同，一般有以下规则：

1. “+”、“-” 和 “*” 操作符可综合
2. “/”、“mod”和 “rem”一般不可综合，但如果操作数为2的整数幂时可综合。
3. “* * “一般只支持左操作数是2的整数幂的情况。
4. ”abs"一般不支持。

四、关系操作符

关系操作符运算结果都是布尔类型，要么为真（true)要么为假（false），对相同类型数据的对象进行数据大小比较。

• ”=“（相等操作符，比较两个数是否相等）
• ”/=“（不相等操作符，比较两个数是否不相等）
• ”<“（小于操作符，比较左操作数是否比右操作数小）
• ”>”（大于操作符）
• “<=”（小于等于操作符）
• ">=“（大于等于操作符）

使用注意问题：

• 在进行两个操作数的关系操作时，两个操作数的数据类型必须一致或是定义了相关的重载函数。
• ”=“、和 ”/=“ 使用所有的数据类型。
• ”<“、”>“、”<=“ 和 ”>=“适用的数据类型有整型、实型、位矢量及数组类型。
• ”<“ 操作数与信号赋值操作符一样，判断意义时，要根据上下文来理解。

五、移位操作符

移位操作符是对矢量数据对象进行移位操作。

• “sll”（逻辑左移操作符，最右边空出的位用"0"填充）
• “srl”（逻辑右移操作符，最左边空出的位用"0"填充）
• “sla”（算术左移操作符，最右边空出的位用原来最右边的值填充）
• “sra”（算术右移操作符，最左边空出的位用原来最左边的值填充）
• “rol”（循环左移操作符，最右边空出的位用原来最左边的值填充）
• “ror” （循环右移操作符，最左边空出的位用原来最右边的值填充）

位移操作符的使用格式如下：
操作数 移位操作符 进行移位的位数
假设 data=“11001010"举例如下：

data sll 1       --操作后 data="10010100"
data srl 1       --操作后 data="01100101"
data sla 1       --操作后 data="10010100"
data sra 1       --操作后 data="11100101"
data rol 1       --操作后 data="10010101"
data ror 1       --操作后 data="01100101"
使用移位操作符的操作数据类型必须是bit、boolean的数组或是std_logic_vector或是integer数据类型。

六、连接操作符

连续操作符（”&“）用不同的位来产生一个位数据更多的矢量。连续操作符可用于两个位的连接，也可以用于两个矢量的连接，如下：

signal ba,bb:std_logic;
signal da,db:std_logic_vector(1 downto 0);
signal data:std_logic_vector(3 downto 0);
da<=ba& bb;
db<=ba&'1';
data<=da&db;
data<=ba&'1'&da;

七、操作符的优先级

操作符优先级一般指的是同一语句中的优先级，当然括号也可以改变语句中操作的先后顺序。

八、操作符的重载

对于预定义操作符所作用操作数的数据类型必须一致。有时为了方便不同让数据类型的数据对象进行操作，就需要对操作符重新定义，这就是重载。

function "+"(1:std_logic;r:integer) return integer is
variable sum:integer:=0;
begin
if 1='1' then
sum:=r;
end if;
return sum;
end;
--有上面对”+“的重载函数的定义，就可进行下面的操作
variable temp:std_logic;
variable data:integer;
variable sum:integer;
sum:=temp+data;--两个不同类型的数据对就可以进行相加操作