wire型，意为连线型，一般用于组合逻辑（CL）之中。verilog HDL模块中的输入输出信号类型默认时自动定义为wire型。
reg型，意为寄存器型，既可以用组合逻辑实现，亦可用于时序逻辑中，即用触发器（filp-flop）实现。 
wire型和reg型在verilog HDL语法中的区别在于，wire型数据通常用assign语句赋值，reg型数据必须被放在过程语句中（如initial、always）中，通过过程赋值语句赋值。
同样一个组合电路，不光可以用wire型数据来写，实际上也可以用reg型数据写：

 
(1) wire写法

wire cl_a;
assign cl_a = a ？A : B;

(2) reg写法

reg cl_a;
always@(a
 or A or B)
begin
if(a)
cl_a = A;
else
cl_a = B;
end

（3）reg写法2

reg cl_a;
always@(a
 or A or B)
begin
cl_a = a? A : B;
end

需要注意的是，reg型在用于组合逻辑时，always（parameter）中的参数为组合逻辑的参数；reg型参数在always中赋值采用阻塞赋值。
下面举出reg型数据使用触发器实现的例子：

reg f_a;
always@(posedge
 clk)
begin
f_a <= a ? A : B;
end

对应该电路实现为：

 
reg型在用触发器实现时，always(parameter) 中的参数通常为时钟边沿，这是由触发器的性质决定的，reg型参数在always中复制采用非阻塞赋值。

参考：https://blog.csdn.net/u013025203/article/details/53410715

有关多路选择器的一篇参考：http://www.elecfans.com/d/668818.html

wire与reg类型的区别：

wire型数据常用来表示以assign关键字指定的组合逻辑信号。模块的输入输出端口类型都默认为wire型。默认初始值是z。

reg型表示的寄存器类型。always模块内被赋值的信号，必须定义为reg型，代表触发器。

默认初始值是x。

reg 类型不一定是寄存器变量，例如组合逻辑中reg类型变量。

reg相当于存储单元，wire相当于物理连线。

Verilog 中变量的物理数据分为线型和寄存器型。这两种类型的变量在定义时要设置位宽，缺省为1位。变量的每一位可以是0，1，X，Z。其中x代表一个未被预置初始状态的变量或者是由于由两个或多个驱动装置试图将之设定为不同的值而引起的冲突型线型变量。z代表高阻状态或浮空量。

线型数据包括wire,wand,wor等几种类型在被一个以上激励源驱动时，不同的线型数据有各自决定其最终值的分辨办法。

两者的区别是：寄存器型数据保持最后一次的赋值，而线型数据需要持续的驱动

 

输入端口可以由net/reg驱动，但输入端口只能是net，如a = b & c，输入端口a 只能是net型，但其驱动b，c可以是net/reg型；输出端口可以使net/reg类型，输出端口只能驱动net，如a = b & c，模块的输出端口b,c可以是net/reg型，但它们驱动的a必须是net型；若输出端口在过程块（always/initial）中赋值则为reg型，若在过程块外赋值则为net型。用关键词inout声明一个双向端口, inout端口不能声明为寄存器类型，只能是net类型。

 

wire表示直通，即只要输入有变化，输出马上无条件地反映；reg表示一定要有触发，输出才会反映输入。

不指定就默认为1位wire类型。专门指定出wire类型，可能是多位或为使程序易读。wire只能被assign连续赋值，reg只能在initial和always中赋值。wire使用在连续赋值语句中，而reg使用在过程赋值语句中。

在连续赋值语句中，表达式右侧的计算结果可以立即更新表达式的左侧。在理解上，相当于一个逻辑之后直接连了一条线，这个逻辑对应于表达式的右侧，而这条线就对应于wire。在过程赋值语句中，表达式右侧的计算结果在某种条件的触发下放到一个变量当中，而这个变量可以声明成reg类型的。根据触发条件的不同，过程赋值语句可以建模不同的硬件结构：如果这个条件是时钟的上升沿或下降沿，那么这个硬件模型就是一个触发器；如果这个条件是某一信号的高电平或低电平，那么这个硬件模型就是一个锁存器；如果这个条件是赋值语句右侧任意操作数的变化，那么这个硬件模型就是一个组合逻辑。

wire型的变量综合出来一般是一根导线；

reg变量在always块中有两种情况：    always后的敏感表中是（a or b or c）形式的，也就是不带时钟边沿的，综合出来还是组合逻辑   always后的敏感表中是（posedge clk）形式的，也就是带边沿的，综合出来一般是时序逻辑，会包含触发器（Flip－Flop）

在设计中，输入信号一般来说你是不知道上一级是寄存器输出还是组合逻辑输出，那么对于本级来说就是一根导线，也就是wire型。而输出信号则由你自己来决定是寄存器输出还是组合逻辑输出，wire型、reg型都可以。但一般的，整个设计的外部输出（即最顶层模块的输出），要求是寄存器输出，较稳定、扇出能力也较好。

 

Notes:七七八八的也看不太懂，总之wire赋值用assign，reg在always内使用。

————————————————————————————————————————————————

1、从仿真角度来说，HDL语言面对的是编译器，相当于使用软件思路，此时：

    wire对应于连续赋值，如assign；

    reg对应于过程赋值，如always，initial；

 

2、从综合角度，HDL语言面对的是综合器，相当于从电路角度来思考，此时：

     wire型变量综合出来一般情况下是一根导线。

     reg变量在always中有两种情况：

         （1）always @（a or b or c）形式的，即不带时钟边沿的，综合出来还是组合逻辑；

         （2）always @（posedge clk）形式的，即带有边沿的，综合出来一般是时序逻辑，会包含触发器（Flip-Flop）

 

3、设计中，输入信号一般来说不能判断出上一级是寄存器输出还是组合逻辑输出，对于本级来说，就当成一根导线，即wire型。而输出信号则由自己来决定是reg还是组合逻辑输出，wire和reg型都可以。但一般的，整个设计的外部输出（即最顶层模块的输出），要求是reg输出，这比较稳定、扇出能力好。

 

4、Verilog中何时要定义成wire型？

    情况一：assign语句

       例如：

               reg   a,b;

               wire  out;

               ......

              assign   out = a & b;

      如果把out定义成reg型，对不起，编译器报错！

   情况二：元件实例化时必须用wire型

         例如：

          wire   dout;

         ram   u_ram

       (

        ....

       .out(dout);

       )

      wire为无逻辑连线，wire本身不带逻辑性，所以输入什么就的输出什么。所以如果用always语句对wire变量赋值，对不起，编译器报错。

      那么你可能会问，  assign    c = a & b;   不是对wire的赋值吗？

      并非如此，综合时是将  a & b综合成 a、b经过一个与门，而c是连接到与门输出线，真正综合出来的是与门&，不是c。

 

5、何时用reg、何时用wire？

     大体来说，reg和wire类似于C、C++的变量，但若此变量要放在begin...end之内，则该变量只能是reg型；在begin...end之外，则用wire型；

     使用wire型时，必须搭配assign；reg型可以不用。

     input、output、inout预设值都是wire型。

     在Verilog中使用reg型，并不表示综合出来就是暂存器register：在组合电路中使用reg，组合后只是net；在时序电路中使用reg，合成后才是以Flip-Flop形式表示的register触发器。

 

6、reg和wire的区别：

     reg型数据保持最后一次的赋值，而wire型数据需要持续的驱动。wire用在连续赋值语句assign中；reg用于always过程赋值语句中。

    在连续赋值语句assign中，表达式右侧的计算结果可以立即更新到表达式的左侧，可以理解为逻辑之后直接连接了一条线，这个逻辑对应于表达式的右侧，这条线对应于wire；

     在过程赋值语句中，表达式右侧的计算结果在某种条件的触发下放到一个变量当中，这个变量可以声明成reg型，根据触发条件的不同，过程语句可以建模不同的硬件结构：

    （1）如果这个条件是时钟上升沿或下降沿，那硬件模型就是一个触发器，只有是指定了always@（posedge or negedge）才是触发器。

    （2）如果这个条件是某一信号的高低电平，那这个硬件模型就是一个锁存器。

    （3）如果这个条件是赋值语句右侧任意操作数的变化，那这个硬件模型就是一个组合逻辑。

 

7、过程赋值语句always@和连续赋值语句assign的区别：

    （1）wire型用于assign的赋值，always@块下的信号用reg型。这里的reg并不是真正的触发器，只有敏感列表内的为上升沿或下降沿触发时才综合为触发器。

    （2）另一个区别，举例：

          wire     a;

          reg      b;

         assign     a = 1'b0;

         always@(*)

                 b = 1'b0;

         上面例子仿真时a将会是0，但是b的状态是不确定的。因为Verilog规定，always@（*）中的*指的是该always块内的所有输入信号的变化为敏感列表，就是说只有当always@（*）块内输入信号发生变化，该块内描述的信号才会发生变化。

        像always@（*）  b= 1'b0; 中由于1‘b0是个常数，一直没有变化，由于b的足组合逻辑输出，所有复位时没有明确的值--即不确定状态，又因为always@（*）块内没有敏感信号变化，此时b信号一直保持不变，即不确定是啥，取决于b的初始状态。

标签：
wire与reg类型的区别：
wire型数据常用来表示以assign关键字指定的组合逻辑信号。模块的输入输出端口类型都默认为wire型。默认初始值是z。
reg型表示的寄存器类型。always模块内被赋值的信号，必须定义为reg型，代表触发器。
默认初始值是x。
reg 类型不一定是寄存器变量，例如组合逻辑中reg类型变量。
reg相当于存储单元，wire相当于物理连线。
Verilog 中变量的物理数据分为线型和寄存器型。这两种类型的变量在定义时要设置位宽，缺省为1位。变量的每一位可以是0，1，X，Z。其中x代表一个未被预置初始状态的变量或者是由于由两个或多个驱动装置试图将之设定为不同的值而引起的冲突型线型变量。z代表高阻状态或浮空量。
线型数据包括wire,wand,wor等几种类型在被一个以上激励源驱动时，不同的线型数据有各自决定其最终值的分辨办法。
两者的区别是：寄存器型数据保持最后一次的赋值，而线型数据需要持续的驱动
输入端口可以由net/reg驱动，但输入端口只能是net，如a = b & c，输入端口a 只能是net型，但其驱动b，c可以是net/reg型；输出端口可以使net/reg类型，输出端口只能驱动net，如a = b & c，模块的输出端口b,c可以是net/reg型，但它们驱动的a必须是net型；若输出端口在过程块(always/initial)中赋值则为reg型，若在过程块外赋值则为net型。用关键词inout声明一个双向端口, inout端口不能声明为寄存器类型，只能是net类型。
wire表示直通，即只要输入有变化，输出马上无条件地反映；reg表示一定要有触发，输出才会反映输入。
不指定就默认为1位wire类型。专门指定出wire类型，可能是多位或为使程序易读。wire只能被assign连续赋值，reg只能在initial和always中赋值。wire使用在连续赋值语句中，而reg使用在过程赋值语句中。
在连续赋值语句中，表达式右侧的计算结果可以立即更新表达式的左侧。在理解上，相当于一个逻辑之后直接连了一条线，这个逻辑对应于表达式的右侧，而这条线就对应于wire。在过程赋值语句中，表达式右侧的计算结果在某种条件的触发下放到一个变量当中，而这个变量可以声明成reg类型的。根据触发条件的不同，过程赋值语句可以建模不同的硬件结构：如果这个条件是时钟的上升沿或下降沿，那么这个硬件模型就是一个触发器；如果这个条件是某一信号的高电平或低电平，那么这个硬件模型就是一个锁存器；如果这个条件是赋值语句右侧任意操作数的变化，那么这个硬件模型就是一个组合逻辑。
wire型的变量综合出来一般是一根导线；
reg变量在always块中有两种情况：    always后的敏感表中是(a or b or c)形式的，也就是不带时钟边沿的，综合出来还是组合逻辑   always后的敏感表中是(posedge clk)形式的，也就是带边沿的，综合出来一般是时序逻辑，会包含触发器(Flip－Flop)
在设计中，输入信号一般来说你是不知道上一级是寄存器输出还是组合逻辑输出，那么对于本级来说就是一根导线，也就是wire型。而输出信号则由你自己来决定是寄存器输出还是组合逻辑输出，wire型、reg型都可以。但一般的，整个设计的外部输出(即最顶层模块的输出)，要求是寄存器输出，较稳定、扇出能力也较好。
Notes:七七八八的也看不太懂，总之wire赋值用assign，reg在always内使用。
————————————————————————————————————————————————
1、从仿真角度来说，HDL语言面对的是编译器，相当于使用软件思路，此时：
wire对应于连续赋值，如assign；
reg对应于过程赋值，如always，initial；
2、从综合角度，HDL语言面对的是综合器，相当于从电路角度来思考，此时：
wire型变量综合出来一般情况下是一根导线。
reg变量在always中有两种情况：
(1)always @(a or b or c)形式的，即不带时钟边沿的，综合出来还是组合逻辑；
(2)always @(posedge clk)形式的，即带有边沿的，综合出来一般是时序逻辑，会包含触发器(Flip-Flop)
3、设计中，输入信号一般来说不能判断出上一级是寄存器输出还是组合逻辑输出，对于本级来说，就当成一根导线，即wire型。而输出信号则由自己来决定是reg还是组合逻辑输出，wire和reg型都可以。但一般的，整个设计的外部输出(即最顶层模块的输出)，要求是reg输出，这比较稳定、扇出能力好。
4、Verilog中何时要定义成wire型？
情况一：assign语句
例如：
reg   a,b;
wire  out;
......
assign   out = a & b;
如果把out定义成reg型，对不起，编译器报错！
情况二：元件实例化时必须用wire型
例如：
wire   dout;
ram   u_ram
(
....
.out(dout);
)
wire为无逻辑连线，wire本身不带逻辑性，所以输入什么就的输出什么。所以如果用always语句对wire变量赋值，对不起，编译器报错。
那么你可能会问，  assign    c = a & b;   不是对wire的赋值吗？
并非如此，综合时是将  a & b综合成 a、b经过一个与门，而c是连接到与门输出线，真正综合出来的是与门&，不是c。
5、何时用reg、何时用wire？
大体来说，reg和wire类似于C、C++的变量，但若此变量要放在begin...end之内，则该变量只能是reg型；在begin...end之外，则用wire型；
使用wire型时，必须搭配assign；reg型可以不用。
input、output、inout预设值都是wire型。
在Verilog中使用reg型，并不表示综合出来就是暂存器register：在组合电路中使用reg，组合后只是net；在时序电路中使用reg，合成后才是以Flip-Flop形式表示的register触发器。
6、reg和wire的区别：
reg型数据保持最后一次的赋值，而wire型数据需要持续的驱动。wire用在连续赋值语句assign中；reg用于always过程赋值语句中。
在连续赋值语句assign中，表达式右侧的计算结果可以立即更新到表达式的左侧，可以理解为逻辑之后直接连接了一条线，这个逻辑对应于表达式的右侧，这条线对应于wire；
在过程赋值语句中，表达式右侧的计算结果在某种条件的触发下放到一个变量当中，这个变量可以声明成reg型，根据触发条件的不同，过程语句可以建模不同的硬件结构：
(1)如果这个条件是时钟上升沿或下降沿，那硬件模型就是一个触发器，只有是指定了always@(posedge or negedge)才是触发器。
(2)如果这个条件是某一信号的高低电平，那这个硬件模型就是一个锁存器。
(3)如果这个条件是赋值语句右侧任意操作数的变化，那这个硬件模型就是一个组合逻辑。
7、过程赋值语句always@和连续赋值语句assign的区别：
(1)wire型用于assign的赋值，always@块下的信号用reg型。这里的reg并不是真正的触发器，只有敏感列表内的为上升沿或下降沿触发时才综合为触发器。
(2)另一个区别，举例：
wire     a;
reg      b;
assign     a = 1'b0;
always@(*)
b = 1'b0;
上面例子仿真时a将会是0，但是b的状态是不确定的。因为Verilog规定，always@(*)中的*指的是该always块内的所有输入信号的变化为敏感列表，就是说只有当always@(*)块内输入信号发生变化，该块内描述的信号才会发生变化。
像always@(*)  b= 1'b0; 中由于1‘b0是个常数，一直没有变化，由于b的足组合逻辑输出，所有复位时没有明确的值--即不确定状态，又因为always@(*)块内没有敏感信号变化，此时b信号一直保持不变，即不确定是啥，取决于b的初始状态。
标签：
来源： https://blog.csdn.net/kebu12345678/article/details/85529791

wire表示直通，即输入有变化，输出马上无条件地反映（如与、非门的简单连接）。



reg表示一定要有触发，输出才会反映输入的状态。

reg相当于存储单元，wire相当于物理连线。reg表示一定要有触发，没有输入的时候可以保持原来的值，但不直接实际的硬件电路对应。

      两者的区别是：寄存器型数据保持最后一次的赋值，而线型数据需要持续的驱动。wire使用在连续赋值语句中，而reg使用在过程赋值语句（initial ，always）中。wire若无驱动器连接，其值为z，reg默认初始值为不定值 x 。

      在连续赋值语句中，表达式右侧的计算结果可以立即更新表达式的左侧。在理解上，相当于一个逻辑之后直接连了一条线，这个逻辑对应于表达式的右侧，而这条线就对应于wire。在过程赋值语句中，表达式右侧的计算结果在某种条件的触发下放到一个变量当中，而这个变量可以声明成reg类型的。根据触发条件的不同，过程赋值语句可以建模不同的硬件结构：如果这个条件是时钟的上升沿或下降沿，那么这个硬件模型就是一个触发器；如果这个条件是某一信号的高电平或低电平，那么这个硬件模型就是一个锁存器；如果这个条件是赋值语句右侧任意操作数的变化，那么这个硬件模型就是一个组合逻辑。

      对组合逻辑输出变量，可以直接用assign。即如果不指定为reg类型，那么就默认为1位wire类型，故无需指定1位wire类型的变量。当然专门指定出wire类型，可能是多位或为使程序易读。wire只能被assign连续赋值，reg只能在initial和always中赋值。

      输入端口可以由wire/reg驱动，但输入端口只能是wire；输出端口可以是wire/reg类型，输出端口只能驱动wire；若输出端口在过程块中赋值则为reg型，若在过程块外赋值则为net型（wire/tri）。用关键词inout声明一个双向端口, inout端口不能声明为reg类型，只能是wire类型。

      默认信号是wire类型，reg类型要申明。这里所说的默认是指输出信号申明成output时为wire。如果是模块内部信号，必须申明成wire或者reg.

      对于always语句而言，赋值要申明成reg，连续赋值assign的时候要用wire。

模块调用时 信号类型确定方法总结如下：

?信号可以分为端口信号和内部信号。出现在端口列表中的信号是端口信号，其它的信号为内部信号。

?对于端口信号，输入端口只能是net类型。输出端口可以是net类型，也可以是register类型。若输出端口在过程块中赋值则为register类型；若在过程块外赋值(包括实例化语句），则为net类型。

?内部信号类型与输出端口相同，可以是net或register类型。判断方法也与输出端口相同。若在过程块中赋值，则为register类型；若在过程块外赋值，则为net类型。

?若信号既需要在过程块中赋值，又需要在过程块外赋值。这种情况是有可能出现的，如决断信号。这时需要一个中间信号转换。

下面所列是常出的错误及相应的错误信息(error message)

?用过程语句给一个net类型的或忘记声明类型的信号赋值。

           信息：illegal …… assignment.

?将实例的输出连接到声明为register类型的信号上。

           信息：<name> has illegal output port specification.

?将模块的输入信号声明为register类型。

           信息：incompatible declaration, <signal name> ……