最基本的语句——赋值语句
 
【知识点】
 
赋值运算符；
复合的赋值运算符；
赋值表达式；
*赋值过程中的类型转换；
赋值表达式和赋值语句；
变量赋初值；
【内容】
 
在C程序中最常用的语句是：赋值语句和输入输出语句。
 
一、赋值运算符
 
赋值符号=就是赋值运算符，它的作用是将一个数据赋给一个变量。执行过程称为：赋值操作或赋值运算。
 
将一个常量赋给一个变量 
  
例如：int a = 23;//将常量23赋给变量a
将一个表达式的值赋给一个变量
 
二、复合的赋值运算符
 
在赋值符=前加上其他运算符，可以构成复合的运算符。有以下复合运算符：
 
+=
-=
*=
/=
%=
a += b;// a = a + b;
 
注意：若b是包含若干项的表达式，则相当于它有括号。(推荐：在b包含若干项表达式时，使用括号将b括起来)例如：
 
 
三、赋值表达式
 
定义：由赋值运算符将一个变量和一个表达式连接起来的式子称为“赋值表达式”。
 
形式：变量 赋值运算符(=) 表达式
 
作用：将一个表达式的值赋给一个变量。（计算、赋值功能）
 
概念：左值(left value,lvalue)、右值(right value,rvalue)
 
左值：
 
出现在赋值运算符的左侧；
其值可以改变；
注意：变量可以作为左值，算术表达式a+b不能作为左值，常量的值不能改变也不能作为左值。
 
右值：出现在赋值运算符的右侧。左值也可以出现在赋值运算符右侧，因此左值也可以作为右值。
 
*四、赋值过程中的类型转换
 
如果赋值运算符两侧的类型一致，则直接进行赋值。
 
如果赋值运算符两侧的类型不一致，但都是算术类型时，在赋值时要进行类型转换。类型转换是由系统自动进行的，转换的规则是：
 
将浮点型数据(包括单、双精度)赋给整型变量时，先对浮点数取整，即舍弃小数部分，然后赋予整型变量。
将整型数据赋给单、双精度变量时，数值不变，但以浮点数形式存储到变量中。
将一个double型数据赋给float变量时，先将双精度数转换为单精度，即只取6-7位有效数字，存储到float变量的4个字节中。注意：双精度数值的大小不能超出float型变量的数值范围。
将一个float型数据赋给double变量时，数值不变，在内存中以8个字节存储，有效位数扩展到15位。
字符型数据赋给整型变量时，将字符的ASCII码值赋给整型变量。
*将一个占字节多的整型数据赋给一个占字节少的整型变量或字符变量时，只将其低字节原封不动地送到被赋值的变量。例如：
 
本质：
 
整型数据之间的赋值，是按存储单元中的存储形式直接传送。
实型数据之间以及整型与实型之间的赋值，是先转换(类型)后赋值。
总结：
 
赋值运算符两侧类型不一致，系统先转换后赋值；
算术运算符两侧类型不一致，系统先转换后运算；
五、赋值表达式和赋值语句
 
六、变量赋初值
 
注意：如果对几个变量赋予同一个初值，应写成：
 
int a = 3, b = 3, c = 3;
 
不能写成：
 
int a = b = c = 3;
 
一般变量初始化不是在编译阶段完成的(只有在静态存储变量和外部变量的初始化是在编译阶段完成的)，而是在程序运行时执行本函数时赋予初值的，相当于执行一个赋值语句。
 

 
 
 在Verilog中有两种类型的赋值语句：阻塞赋值语句（“=”）和非阻塞赋值语句（“<=”）。正确地使用这两种赋值语句对于Verilog的设计和仿真非常重要。下面我们以例子说明阻塞和非阻塞赋值的区别。
 
 
 　　
 
         我们先来看几段代码及其对应的电路：
 
 
    

     HDL源代码
    
 
 
    

     对应的RTL电路
    
 
 
module Shifter1(
                Clk,
                D,
                Q3
                );
input Clk;
input [7:0] D;
output [7:0] Q3;
reg [7:0] Q3, Q2, Q1;

always @(posedge Clk)
begin
    Q1 = D;
    Q2 = Q1;
    Q3 = Q2;
end
endmodule
 
 
    

     
    
 
    

     ▲ 大家可以看到Q1、Q2被优化掉了
    
 
 
module Shifter2(
                Clk,
                D,
                Q3
                );
input Clk;
input [7:0] D;
output [7:0] Q3;
reg [7:0] Q3, Q2, Q1;

always @(posedge Clk)
begin
     Q1 <= D;
     Q2 <= Q1;
     Q3 <= Q2;
end
endmodule
 
 
    

     
    
 
 
module Shifter3(
                Clk,
                D,
                Q3
                );
input Clk;
input [7:0] D;
output [7:0] Q3;
reg [7:0] Q3, Q2, Q1;

always @(posedge Clk)
begin
     Q3 = Q2;
     Q2 = Q1;
     Q1 = D;
end
endmodule
 
 
    

     
    
 
 
module Shifter4(
                Clk,
                D,
                Q3
               );
input Clk;
input [7:0] D;
output [7:0] Q3;
reg [7:0] Q3, Q2, Q1;
always @(posedge Clk)
begin
    Q1 <= D;
    Q2 = Q1;
    Q3 = Q2;
end
endmodule
 
 
    

     
    
 
 
module Shifter5(
                Clk,
                D,
                Q3
                );
input Clk;
input [7:0] D;
output [7:0] Q3;
reg [7:0] Q3, Q2, Q1;

always @(posedge Clk)
begin
    Q1 <= D;
    Q2 <= Q1;
    Q3 = Q2;
end
endmodule
 
 
    

     
    
 
 
module Shifter6(
                Clk,
                D,
                Q3
                );
input Clk;
input [7:0] D;
output [7:0] Q3;
reg [7:0] Q3, Q2, Q1;
always @(posedge Clk)
begin
    Q1 <= D;
    Q2 = Q1;
    Q3 <= Q2;
end
endmodule                 
 
 
    

     
    
 
 
         从上面的例子中，我们可以看出，在阻塞赋值语句中，赋值的次序非常重要，而在非阻塞赋值语句中，赋值的次序并不重要。
 
 
  
 
 　　下面我们具体分析一下阻塞和非阻塞赋值的语义本质：
 
 
 　　阻塞：在本语句中“右式计算”和“左式更新”完全完成之后，才开始执行下一条语句；
 　　非阻塞：当前语句的执行不会阻塞下一语句的执行。
 
 
 　　先看阻塞赋值的情况：我们来看这段代码：
 
    always @(posedge Clk)
    begin
        Q1 = D;
        Q2 = Q1;
        Q3 = Q2;
    end
 
 　　always语句块对Clk的上升沿敏感，当发生Clk 0～1的跳变时，执行该always语句。
         在begin...end语句块中所有语句是顺序执行的，而且最关键的是，阻塞赋值是在本语句中“右式计算”和“左式更新”完全完成之后，才开始执行下一条语句的。
         在本例中，D的值赋给Q1以后，再执行Q2 = Q1；同样在Q2的值更新以后，才执行Q3 = Q2。这样，最终的计算结果就是Q3 = D。
         所有的语句执行完以后，该always语句等待Clk的上升沿，从而再一次触发begin...end语句。
 
 
 　　接下来，再看看非阻塞赋值的情况。
        所谓非阻塞赋值，顾名思义，就是指当前语句的执行不会阻塞下一语句的执行。
 
 always @(posedge Clk)
    begin
        Q1 <= D;
        Q2 <= Q1;
        Q3 <= Q2;
    end
 
 　　 首先执行Q1 <= D，产生一个更新事件，将D的当前值赋给Q1，但是这个赋值过程并没有立刻执行，而是在事件队列中处于等待状态。
         然后执行Q2 <= Q1，同样产生一个更新事件，将Q1的当前值（注意上一语句中将D值赋给Q1的过程并没有完成，Q1还是旧值）赋给Q2，这个赋值事件也将在事件队列中处于等待状态。
         再执行Q3 <= Q2，产生一个更新事件，将Q2的当前值赋给Q3，这个赋值事件也将在事件队列中等待执行。
         这时always语句块执行完成，开始对下一个Clk上升沿敏感。
 
 
 　　那么什么时候才执行那3个在事件队列中等待的事件呢？只有当当前仿真时间内的所有活跃事件和非活跃事件都执行完成后，才开始执行这些非阻塞赋值的更新事件。这样就相当于将D、Q1和Q2的值同时赋给了Q1、Q2和Q3。
 
 　　注：
             *仿真器首先按照仿真时间对事件进行排序，然后再在当前仿真时间里按照事件的优先级顺序进行排序。
 
 
 　　　  *活跃事件是优先级最高的事件。在活跃事件之间，它们的执行顺序是随机的。阻塞赋值（=）、连续赋值（assign）以及非阻塞赋值的右式计算等都属于活跃事件。
 
 
  
 
 
  
 
 　　下面通过一个典型案例，进一步说明阻塞赋值和非阻塞赋值的区别。
 
 
 　　这里有一个数组：Data[0]、Data[1]、Data[2]和Data[3]，它们都是4比特的数据。我们需要在它们当中找到一个最小的数据，同时将该数据的索引输出到LidMin中，这个算法有点类似于“冒泡排序”的过程，而且需要在一个时钟周期内完成。例如，如果这4个数据中 Data[2]最小，那么LidMin的值则为2。
 
   module Bubble_Up(
                    Rst_n,
                    Clk,
                    Data,
                    Lid_Min
                    );
    input Rst_n;
    input Clk;
    input [3:0] Data [0:3];
    output [1:0] Lid_Min;
    reg [1:0] Lid_Min; 
    always @(posedge Clk or negedge Rst_n)
    begin
        if (~Rst_n)
        begin
             Lid_Min <= 2'd0;
        end
        else
           begin
               if (Data[0] <= Data[Lid_Min])    //"<="表示小于等于
               begin
                   Lid_Min <= 2'd0;    //"<="表示非阻塞赋值
               end

               if (Data[1] <= Data[Lid_Min])
               begin
                   Lid_Min <= 2'd1;
               end
                        
                if (Data[2] <= Data[Lid_Min])
                begin
                    Lid_Min <= 2'd2;
                end

                if (Data[3] <= Data[Lid_Min])
                begin
                    Lid_Min <= 2'd3;
                end
            end
        end
    endmodule
 
 　　我们的原意是首先将Lid_Min设置为一个初始值（任意值都可以），然后将Data[0]~Data[3]与Data[Lid_Min]进行比较，每比较一个数，就将较小的索引暂存在Lid_Min中，然后再进行下一次比较。当4组数据比较完成之后，最小的数据索引就会保留在Lid_Min 中。
 
 　　我们在以上代码中使用了非阻塞赋值，结果发现，仿真波形根本不是我们所需要的功能，如图所示，图中的Data[0]~Data[3]分别为 11、3、10和12，Lid_Min的初始值为0。按道理来说，Lid_Min的计算结果应该为1，因为Data[1]最小，但仿真波形却为2。
 
 
 
 
  
 
 　　为什么会得出这样的结果呢？
 
 
 　　在时钟上升沿到来以后，且Rst_n信号无效时开始执行以下4个语句，假设这时候的Lid_Min是0，Data[0]~Data[3]分别为11、3、10和12：
 
               if (Data[0] <= Data[Lid_Min])    //"<="表示小于等于
               begin
                   Lid_Min <= 2'd0;    //"<="表示非阻塞赋值
               end

               if (Data[1] <= Data[Lid_Min])
               begin
                   Lid_Min <= 2'd1;
               end
                        
                if (Data[2] <= Data[Lid_Min])
                begin
                    Lid_Min <= 2'd2;
                end

                if (Data[3] <= Data[Lid_Min])
                begin
                    Lid_Min <= 2'd3;
                end
 
 　　第一句的if为真，因此执行Lid_Min <= 2’d0，而这时候，Lid_Min并没有立刻被赋值，而是调度到事件队列中等待执行，这是非阻塞赋值的特点。
 
 
 　　第二句的if为真，因此执行Lid_Min <= 2’d1，这是Lid_Min也没有立刻被赋值为1，而是调度到事件队列中等待执行。当前的Lid_Min还是0，没有发生任何变化。
 
 
 　　同样，第三句的if也为真，因此执行Lid_Min <= 2’d2，将更新事件调度到事件队列中等待执行。当前的Lid_Min还是0。
 
 
 　　而第四句的if为假，因此直接跳过Lid_Min <= 2’d3，这时跳出always语句，等待下一个时钟上升沿。
 
 
 　　在以上的always语句执行完成以后，仿真时间没有前进。这时存在于事件队列中当前仿真时间上的3个被调度的非阻塞更新事件开始执行，它们分别将Lid_Min更新为0、1和2。
 
 　　按照Verilog语言的规范，这3个更新事件属于同一仿真时间内的事件，它们之间的执行顺序随机，这就产生了不确定性。一般的仿真器在实现的时候是根据它们被调度的先后顺序执行的，事件队列就像一个存放事件的FIFO，它是分层事件队列的一部分，如图所示：
 
 
 
 
  
 
 　　这3个事件在同一仿真时间被一一执行，而真正起作用的时最后一个更新事件，因此在仿真的时候得到的最终结果时Lid_Min为2。
 
 
 　　然后我们想要得到的结果是，在每个if语句判断并执行完成以后，Lid_Min先暂存这个中间值，再进行下一次比较，也就是说在进行下一次比较之前，这个Lid_Min必须被更新，而这一点也正是阻塞赋值的特点，因此我们将代码作如下更改：
 
module Bubble_Up(
                    Rst_n,
                    Clk,
                    Data,
                    Lid_Min
                    );
    input Rst_n;
    input Clk;
    input [3:0] Data [0:3];
    output [1:0] Lid_Min;
    reg [1:0] Lid_Min; 
    always @(posedge Clk or negedge Rst_n)
    begin
        if (~Rst_n)
        begin
             Lid_Min <= 2'd0;
        end
        else
           begin
               if (Data[0] <= Data[Lid_Min])    //"<="表示小于等于
               begin
                   Lid_Min = 2'd0;    //"<="表示非阻塞赋值
               end

               if (Data[1] <= Data[Lid_Min])
               begin
                   Lid_Min = 2'd1;
               end
                        
                if (Data[2] <= Data[Lid_Min])
                begin
                    Lid_Min = 2'd2;
                end

                if (Data[3] <= Data[Lid_Min])
                begin
                    Lid_Min = 2'd3;
                end
            end
        end
    endmodule
 
 　　其仿真波形如图所示：
 
 
 
 
  
 
 　　在代码仿真过程中，第二句的if为真，执行Lid_Min = 2'd1，根据阻塞赋值的特点，Lid_Min被立刻赋值为1。在执行第三句if的时候，if (Data[2] <= Data[Lid_Min])为假，直接跳过Lid_Min = 2'd2不执行，同样也跳过Lid_Min = 2'd3不执行。Lid_Min被最终赋值为1，这正是我们想要的结果。
 
 
         另外，为了使代码看起来更简洁，我们使用for语句改写了代码：
 
     module Bubble_Up(
                     Rst_n,
                     Clk,
                     Data,
                     Lid_Min
                     );
      input Rst_n;
      input Clk;
      input [5:0] Data [0:3];
      output [1:0] Lid_Min;
      reg [1:0] Lid_Min; 
      integer i;
      always @(posedge Clk or negedge Rst_n)
      begin
          if (~Rst_n)
          begin
              Lid_Min = 2'd0;
          end
          else
          begin
              for (i = 2'd0; i <= 2'd3; i = i + 2'd1)
              begin
                  if (Data[i] <= Data[Lid_Min])
                  begin
                        Lid_Min = i;
                  end
              end
          end
       end
     endmodule
 
 　　这种写法与前面展开的写法完全等效，功能完全一致。今后大家在读代码时发现带有for语句的电路功能比较难理解，可以将这些语句展开，增强代码的可读性。
 
 

今天在讲课之余偶然发现java一个小问题，如下代码所示
 
public class Test {
    public static void main(String[] args) {
        Boolean flag = false;

        if(flag = true) {
            System.out.println("True");
        } else {
            System.out.println("false");
        }
    }
}
 
在main方法中，声明了一个局部Boolean变量，默认为false，然后在if语句中作了赋值操作。
 
刚开始想当然的以为此代码根本就不能编译通过，因为在if语句中如果要判断两个变量值是否相等应该使用== 
 但是当我编译以上代码之后竟然神奇的编译通过了，更神奇的是竟然打印出了True。
 
为什么会造成这个现象呢？？if语句中不是应该传入一个boolean类型变量吗？？ 
 
等等！
 
以上代码中的flag值不是本身就是boolean类型的吗，难道if语句是先执行赋值操作，然后将flag当做if的参数去做判断吗？？ 只有这一种解释了。 为了验证这一解释，我果断地将以上代码进行了修改，如下
 
public class Test {
    public static void main(String[] args) {
        //Boolean flag = false;
        int i = 1;

        if(i = 20) {
            System.out.println("True");
        } else {
            System.out.println("false");
        }
    }
}
 
我讲flag的boolean变量注释，然后将int类型变量的赋值语句放入if语句中，重新编译。
 
Bingo！！你猜怎么着？？此时果然无法编译通过！
 
具体错误如下所示 
 
 
间接验证了我的想法是正确的，Java果然到处都是坑啊~~~

【单选题】以下赋值语句中合法的是
【单选题】字符串:s= abcde',n=len(s)。索引字符串s字符'c',哪个语句是正确的?
【单选题】以下哪个方法能够根据','分隔字符串?
【单选题】len("I am a student!")的输出结果为( )
【单选题】执行下面代码后,程序运行的结果为:( )
【单选题】下列表达式的值为True的是()
【单选题】我们通过使用turtle.speed()为小海龟设置爬行的速度,当我们希望跳过小海龟的移动过程,直接得到程序绘制的图形时,speed()的参数值应该是( )
【单选题】航空运单有正本 份,副本若干份。
【单选题】下列哪个方法是用来控制画笔的尺寸的( )
【单选题】s="Python",t="world",s+=t,则s[2:8]的结果是( )
【单选题】恺撒密码是古罗马恺撒大帝用来对军事情报进行加密的算法,根据它的原理,将明文“python”进行加密后的密文是( )。
【单选题】math.ceil(2.6+math.floor(-3.5)) 的结果是
【判断题】控制周边眼的间距及装药量是光面爆破的一项主要指标。
【单选题】将下列程序运行后的出错部分进行修改后,程序的输出结果是 ( ) >>> s = “hi”; >>> print “hi”, 2*s
【单选题】Python 中布尔变量的值为( )。
【单选题】下列代码运行时不会产生错误的是( )。
【单选题】通常附加或不附加也不附减的等级货物用代号 ( )表示。
【单选题】当我们想为一个闭合的圆填充红色时,我们会使用语句turtle.begin_fill()和turtle.end_fill(),但当我们忘记使用turtle.end_fill()时,会出现什么现象( )。
【单选题】杂散电流也成什么?是在城轨交通直流牵引供电回流中产生的。
【单选题】下列语句没有错误的是( )。
【单选题】三视图对应 的投影 关系 叙述正确的 是: A 主、俯视图长相等且对正 B 主、左视图高相等可不平齐 C 俯 、左视图宽对齐 D 可以自由排列
【单选题】一波源以 y=0.04cos2.5 π t ( m ) 的形式作简谐振动,并以 100m / s 的速度在某种介质中传播。在波源起振 1.0s 时,距波源 20m 处质点初相 为
【多选题】直线的 投影 具有:
【单选题】超声波由涂在人体皮肤的蓖麻油传入人体,如果蓖麻油和脂肪的声阻抗分别为Z=1.36×10 6 kg/m 2 /s 和1.41×106kg/m 2 /s,则进入的声波强度是入射前强度的
【单选题】表达式 3 in {1, 2} 的值为()
【单选题】已知x=4,y=6,执行x,y=y,x之后,x和y的值分别是什么?
【判断题】我国目前采用光面爆破的特制小药卷直径是 32 mm
【单选题】Python 语言的特点有:()
【单选题】回文数判断。如果n的各位数字反向排列所得自然数与n相等,则n被称为回文数。从键盘输入一个5位数字,判断是否是回文数的条件是( )
【判断题】光面爆破时,周边眼应用炮泥封实,且封泥长度不得小于 300mm 。
【单选题】Python 的输入来源包括( )
【单选题】关于 Python语言,哪个说法是不正确的?
【单选题】"abc" 的长度是3,"老师好"的长度是多少?
【单选题】以下哪个是 Python不支持的数据类型?
【单选题】以下关于 Python版本的说法中,哪个是正确的?
【判断题】地面与隧道架空式悬挂都属于刚性接触悬挂。
【多选题】下列各项符合会计账簿登记规则的有:
【单选题】以下哪个数字是八进制
【单选题】名为“text.txt”的文件内有一句话:“中国是一个伟大的国家!”如果执行: >>>s=open("text.txt").readlines() >>>print(s) 输出结果是( )
【多选题】图样中注写圆或圆弧的直径尺寸时应在尺寸数字前加注符号 ,注写圆或圆弧的半径尺寸时应在尺寸数字前加注符号 。
【填空题】是一种悬挂在轨道上方或 沿轨道敷设的,和轨顶保持一定距离的 网。
【单选题】将下列程序运行后的出错部分进行修改后,程序的输出结果是 ( ) x = 1 de fun() global x x = 2 fun() print (x)
【单选题】已知s=”0123456789”,则( )表示”123”?
【多选题】接触网按结构可分为
【单选题】如果我们希望让小海龟的画笔方向朝向上方,应该执行以下哪一个方法?
【单选题】关于 PIL 库中的 Image 类功能的说法正确的是( )。
【单选题】执行下面代码后,如果用户输入的任意字母是“python”程序运行的结果为:( )
【单选题】平面图形的尺寸按作用分为:
【单选题】“ 世界那么大,我想去看看"[5:-4],输出
【单选题】质量为5×10 -3 kg的振子做简谐振动,其振动方程为x=6×10 -2 cos(5t+2π/3)m,则t=0时的动能和势能分别为