精华内容
下载资源
问答
  • 2022-04-23 12:23:16

    前言

    协程操作符的第二篇,请参考第一篇Kotlin 协程Flow主要操作符(一)

    1. collect接收操作符

    用于数据接收,此操作符没有返回对象,后面不可再添加操作符。

    
    fun flowCollect() {
    //流启动
            viewModelScope.launch {
                flow {
                    for (i in 1..3) {
                        LogUtils.d(" Emitting $i")
                        emit(i)
                        delay(1000)
                    }
                }.collect {
                    LogUtils.d(" collect $it")
                }//后面不可再接收其他操作符
            }
        }
    

    2. launchIn操作符

    流的启动主要有两种,一种是上面的作用域.launch启动一个流,用collect操作符接收数据;

    一种是launchIn操作符启动流,官方不建议用这种,可能出于数据安全考虑,一般建议在onResume方法调用后启动协程,因为怕数据接收了,但View还没创建出来。但链式调用真的很好用,用onEach操作符接收数据。

    
     flow {
                for (i in 1..3) {
                    LogUtils.d("Emitting $i")
                    emit(i)
                    delay(1000)
                }
            }.onCompletion {
                LogUtils.d("onCompletion ")
            }.launchIn(viewModelScope)//在ViewModel中,直接launchIn在ViewModelScope作用域
    

    3. onEach操作符

    返回一个流,该流在上游流的每个值向下游发出之前调用给定的操作。也可以用来接收数据,与上面collect不同的是此操作符返回流,我们后面还可接其他操作符。上面的launchIn操作符启动时,可用于接收数据。

     fun flowOnEach() {
            flow {
                for (i in 1..3) {
                    LogUtils.d("Emitting $i")
                    emit(i)
                    delay(1000)
                }
            }.onEach {
                LogUtils.d("onEach $it")
            }.onCompletion {
                LogUtils.d("onCompletion ")
            }.launchIn(viewModelScope)
        }
    
         D/FlowViewModel: Emitting 1
         D/FlowViewModel: onEach 1
         D/FlowViewModel: Emitting 2
         D/FlowViewModel: onEach 2
         D/FlowViewModel: Emitting 3
         D/FlowViewModel: onEach 3
         D/FlowViewModel: onCompletion
    

    4. 组合操作符

    4.1 zip操作符

    zip 操作符用于组合两个流中的相关值,与Rxjava中的zip操作符类似

     fun flowZip() {
            viewModelScope.launch {
                val nums = flowOf(1, 2, 3)
                val strs = flowOf("one", "two", "three")
                nums.zip(strs) { a, b -> "$a -> $b" }//两个流数据组合
                    .collect {
                        LogUtils.d("collect==$it")
                    }
            }
        }
    
        D/Collect: collect==1 -> one
        D/Collect: collect==2 -> two
        D/Collect: collect==3 -> three
    

    4.2 combine操作符

    当流表示一个变量或操作的最新值时,可能需要执行计算,这依赖于相应流的最新值,并且每当上游流产生值的时候都需要重新计算。这种相应的操作符家族称为 combine。
    例如,先前示例中的数字如果每 300 毫秒更新一次,但字符串每 400 毫秒更新一次, 然后使用 zip 操作符合并它们,但仍会产生相同的结果, 尽管每 400 毫秒打印一次结果

    private fun flowCombine() {
            viewModelScope.launch {
                val nums = flowOf(1, 2, 3).onEach { delay(300) }
                val strs = flowOf("one", "two", "three").onEach { delay(400) }
                val startTime = System.currentTimeMillis() // 记录开始的时间
                nums.combine(strs) { a, b -> "$a -> $b" }
                    .collect {
                        LogUtils.d("$it at ${System.currentTimeMillis() - startTime} ms from start")
                    }
            }
        }
    
     	D/Collect: 1 -> one at 418 ms from start
        D/Collect: 2 -> one at 627 ms from start
        D/Collect: 2 -> two at 827 ms from start
        D/Collect: 3 -> two at 931 ms from start
        D/Collect: 3 -> three at 1231 ms from start
    

    5. 展平流

    流表示异步接收的值序列,所以很容易遇到这样的情况: 每个值都会触发对另一个值序列的请求。比如说,我们可以拥有下面这样一个返回间隔 500 毫秒的两个字符串流的函数:

    fun requestFlow(i: Int): Flow<String> = flow {
        emit("$i: First")
        delay(500) // 等待 500 毫秒
        emit("$i: Second")
    }
    

    现在,如果我们有一个包含三个整数的流,并为每个整数调用 requestFlow,如下所示:

    (1..3).asFlow().map { requestFlow(it) }
    

    然后我们得到了一个包含流的流(Flow<Flow>),需要将其进行展平为单个流以进行下一步处理。集合与序列都拥有 flatten 与 flatMap 操作符来做这件事。然而,由于流具有异步的性质,因此需要不同的展平模式, 为此,存在一系列的流展平操作符。

    5.1 flatMapConcat连接模式

    它们是相应序列操作符最相近的类似物。它们在等待内部流完成之前开始收集下一个值。一个流数据完成后,再收集下一个流数据。

    private fun requestFlow(i: Int): Flow<String> = flow {
            emit("$i: First")
            delay(500) // 等待 500 毫秒
            emit("$i: Second")
        }
    
    
        private fun flowFlatMapConcat() {
            viewModelScope.launch() {
                val startTime = System.currentTimeMillis() // 记录开始时间
                (1..3).asFlow().onEach { delay(100) } // 每 100 毫秒发射一个数字
                    .flatMapConcat { requestFlow(it) }
                    .collect { value -> // 收集并打印
                        LogUtils.d("$value at ${System.currentTimeMillis() - startTime} ms from start")
                    }
            }
        }
    
        D/Collect: 1: First at 121 ms from start
        D/Collect: 1: Second at 624 ms from start
        D/Collect: 2: First at 728 ms from start
        D/Collect: 2: Second at 1230 ms from start
        D/Collect: 3: First at 1332 ms from start
        D/Collect: 3: Second at 1834 ms from start
    

    5.2 flatMapMerge并发模式

    另一种展平模式是并发收集所有传入的流,并将它们的值合并到一个单独的流,以便尽快的发射值。它由 flatMapMerge 与 flattenMerge 操作符实现。

    private fun requestFlow(i: Int): Flow<String> = flow {
            emit("$i: First")
            delay(500) // 等待 500 毫秒
            emit("$i: Second")
        }
    
    private fun flowFlatMapMerge() {
            viewModelScope.launch() {
                val startTime = System.currentTimeMillis() // 记录开始时间
                (1..3).asFlow().onEach { delay(100) } // 每 100 毫秒发射一个数字
                    .flatMapMerge { requestFlow(it) }
                    .collect { value -> // 收集并打印
                        LogUtils.d("$value at ${System.currentTimeMillis() - startTime} ms from start")
                    }
            }
        }
    
        D/Collect: 1: First at 104 ms from start
         D/Collect: 2: First at 205 ms from start
         D/Collect: 3: First at 308 ms from start
         D/Collect: 1: Second at 607 ms from start
         D/Collect: 2: Second at 708 ms from start
         D/Collect: 3: Second at 812 ms from start
    

    5.3 flatMapLatest

    与 collectLatest 操作符类似,处理最新值,也有相对应的“最新”展平模式,在发出新流后立即取消先前流的收集。 这由 flatMapLatest 操作符来实现。

    参考

    更多相关内容
  • 算术操作符2.位移操作符(1) <<    左移操作符(高位丢掉,低位补0):eg:将1左移1位(2) >> 右移操作符:eg:将1右移一位3.位操作符eg:不创建临时变量(第三个变量),实现两个数的交换 1.算术...

    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;
    }
    

    在这里插入图片描述

    展开全文
  • Kotlin 协程Flow主要操作符(一)

    千次阅读 2022-04-23 11:28:11
    Kotlin 协程Flow主要操作符(一)1. 主要导包2. map 转换操作符3. filter过滤操作符4. take限长操作符5. drop丢弃操作符6. flowOn操作符7. onStart操作符8. onCompletion完成操作符9. catch异常收集操作符10. buffer...

    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的操作符

    千次阅读 2021-05-28 10:31:29
    一、赋值操作符 作用在于更新被赋值数据对象的值,数据对象主要是指信号和变量。VHDL赋值操作符也有信号赋值与变量赋值的区别,分别是: ”<="是信号赋值操作符,可以对标量型的信号类型对象或是矢量型信号类型...

    一、赋值操作符

    作用在于更新被赋值数据对象的值,数据对象主要是指信号和变量。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;--两个不同类型的数据对就可以进行相加操作
    
    展开全文
  • C语言操作符详解前言:算术操作符移位操作符操作符赋值操作符单目操作符 前言: 本文是C语言操作符详解篇,可以帮助新手小白,快速了解c语言操作符的使用方法,每一个操作符都有列子和解释,做以参考学习。 算术...
  • C语言操作符总结

    千次阅读 多人点赞 2019-01-27 17:32:50
    目录 1.算术操作符 2.移位操作符 ...算术操作符,移位操作符,位操作符,赋值操作符,单目操作符,关系操作符,逻辑操作符,条件操作符,逗号表达式,下标引用、函数调用和结构成员。 接下来一一...
  • C语言之移位操作符、位操作符详解

    千次阅读 多人点赞 2021-11-23 15:28:24
    1、移位操作符 2、位操作符 1、移位操作符 分为左移操作符(>>)和右移操作符(<<)。 左移操作符: 移位规则:左边抛弃,右边补0。 什么意思呢,现在就让我来仔细讲解一番。 比如我们定义一个整型...
  • Groovy 操作符

    千次阅读 2019-01-22 21:42:22
    1. 算术操作符 1.1 普通算术操作符 1.2 一元操作符 1.3 赋值算术操作符 2. 关系运算符 3. 逻辑运算符 3.1 优先级 3.2 短路特性 4. 位运算操作符 5. 条件运算符 5.1 非运算符 5.2 三元运算符 5.3 ...
  • C语言基础之操作符详解

    千次阅读 多人点赞 2021-11-15 19:38:53
    C语言基础之操作符详解操作符的分类算术操作符移位操作符操作符逻辑操作符逗号表达式表达式求值隐式类型转换算术转换操作符的属性 xwg今天就带各位大佬来了解一波C语言的操作符操作符的分类 常见的操作符分别...
  • 1.二元和三元操作符 操作符始终写在前一行,以免分号的隐式插入产生预想不到的问题 var x=a?b:c; var y=a? longExpressionA:longExpressionB; var z=a? longExpressionC: longExpressionD; 2.&amp;&...
  • 1,Verilog逻辑操作符 逻辑操作符 功能 A与B的运算 C与D的运算 &amp;&amp; 逻辑与 A&amp;&amp;B= 0 C&amp;...
  • PostgreSQL自定义操作符

    千次阅读 2019-09-16 14:18:20
    PostgreSQL的create operator语法允许用户可以定义自己需要的操作符,利用这些自定义的操作符对需要使用的数据类型进行操作。而实际上完成这些操作的并不是操作符本身,而是通过调用函数来实现的。比如: bill=# \do+...
  • Rest参数与Spread操作符

    万次阅读 2019-05-11 15:07:11
    // H,e,l,l,o JavaScript 内部使用了遍历器来实现 Spread 操作符,因此使用 Spread 操作符展开对象与使用 for…of 遍历该对象是一致的。 所以,针对一个字符串,for…of 会逐位返回该字符串中的字符,…str 也同...
  • c++操作符重载

    千次阅读 2018-06-12 17:28:16
    一、运算符重载:1、定义:重载操作符是具有特殊函数名的函数,关键字operator后面接需要定义的 操作符符号。操作符重载也是一个函数,具有返回值和形参表。它的形参 数目与操作符的操作数目相同,使用运算符重载...
  • new 操作符具体干了什么

    千次阅读 2020-08-16 23:09:14
    在创建一个新的实例的时候,必须使用 new 操作符。而使用 new 操作符会经历以下 4 个步骤: 创建一个新对象 将构造函数的作用域赋值给新对象(this 指向新对象) 执行构造函数中的代码(给新对象添加熟悉) 返回新...
  • verilog | 附 操作符

    千次阅读 2020-06-20 22:40:23
    附:操作符 2020年2月26日 15:36 -算数操作符: -双目:加减乘除、求幂、取模。均同C。 如果操作数的任一位为x,那么运算结果全部为x。即操作数值不确定,结果肯定不确定。 -单目:正负(单目+-优先级...
  • Verilog与SystemVerilog——运算操作符

    万次阅读 多人点赞 2020-05-24 21:18:23
    文章目录一、算术操作符(+ - * / % **)二、相等操作符(==  ! =   ===  ! ==  ==?  !=?)三、逻辑操作符(&& || !)四、按位操作符(~ & | ^  ^~或 ~^)五、缩减操作符(& ~...
  • 什么是操作符重载

    千次阅读 2017-10-11 09:13:05
    一、什么是操作符重载 操作符重载可以分为两部分:“操作符”和“重载”。说到重载想必都不陌生了吧,这是一种编译时多态,重载实际上可以分为函数重载和操作符重载。运算符重载和函数重载的不同之处在于操作符重载...
  • System Verilog 流操作符

    千次阅读 2019-09-02 20:45:31
    在SV中,流操作符>>和<<用在赋值表达式的右边,后面带表达式、结构或数组。流操作符用于把气候的数据打包成一个比特流。操作符>>把数据从左至右变成流,而<<则把数据从右至左变成流。你也...
  • 本文介绍了 Dart 展开操作符以及展开操作符语义分析、控制流集合(Control Flow Collections)
  • 一、操作符重载 1.什么是操作符重载 就是把一些操作符通过关键字operator,组装成一个函数,关键字operator后面接需要重载的操作符符号 2.为什么需要重载操作符? (1)简单、方便,比起封装一个函数,使用...
  • 前端面试常见手写题:手写new操作符;前置知识:Object.create();new 操作符作用;手写 new 操作符
  • vue项目使用可选链操作符编译报错问题 const a = b?.c?.d 报错如下: Support for the experimental syntax ‘optionalChaining’ isn’t currently enabled 解决方案: 需要安装babel依赖@babel/plugin-proposal-...
  • 集合类型的操作符(共10个)

    千次阅读 多人点赞 2020-11-27 20:03:37
    注意:本次所有的举例均为s={1,2,3,4,5},t={4,5,6,7} 1.S - T 或 S.difference(T): 返回一个新集合,包括在集合S中但不在集合T中的元素 eg:2.S -= T或S.difference_update(T): 更新集合S,包括在集合S,包括在集合S中...
  • Verilog操作符

    千次阅读 2018-11-19 09:12:33
    操作符优先级表 Verilog中的大小(size)与符号 Verilog根据表达式中变量的长度对表达式的值自动地进行调整; Verilog自动截断或扩展赋值语句中右边的值以适应左边变量的长度; 当一个负数赋值给无符号变量如reg时,...
  • [SV]SystemVerilog操作符应用总结

    千次阅读 2020-07-08 20:17:04
    SystemVerilog操作符应用总结 一、位拼接操作符 位拼接是由一个或多个表达式产生的bit位连接在一起的结果。位拼接应该使用大括号'{}'表示,其中的表达式用逗号分隔。不允许在连接中使用未调整大小的常数。这是...
  • RxJava操作符汇总

    千次阅读 2018-05-21 16:35:29
    1、创建操作符 :创建被观察者(Observable)对象&amp;amp;amp;amp;amp;amp;amp;发送事件 2、转换操作符:变换被观察者(Observable)发送的事件。将Observable发送的数据按照一定的规则做一些变换,然后再将...
  • C++操作符

    千次阅读 2018-08-11 21:26:00
    C++操作符 一.操作符函数  在C++中,编译器把运算符当做函数来处理,可以重载,通过重定义操作符函数,可以自定义远算法则。 二.单目操作符有这些:  相反数:- 自变:++,-- 取地址:& 解...
  • JavaScript操作符

    千次阅读 2018-08-11 22:05:03
    操作符用于数据值,操作符包括算术操作符(如加好和减号)、位操作符、关系操作符和相等操作符等。JavaScript的操作符适用于很多值,例如字符串、数字值、布尔值,甚至对象。在应用于对象时,相应的操作符会调用对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,913,788
精华内容 765,515
关键字:

操作符