精华内容
下载资源
问答
  • #include#include#includeusingnamespacestd;/////////////////////////////////////////////////////////功能:二进制取反////输入:constunsignedchar*src二进制数据//intlength待转换的二进制数据长度////输...

    #include 

    #include 

    #include 

    using namespace std;

    /

    //

    //功能:二进制取反

    //

    //输入:const unsigned char *src  二进制数据

    //      int length                待转换的二进制数据长度

    //

    //输出:unsigned char *dst        取反后的二进制数据

    //

    //返回:0    success

    //

    //

    int convert(unsigned char *dst, const unsigned char *src, int length)

    {

    int i;

    for (i = 0; i 

    {

    dst[i] = src[i] ^ 0xFF;

    }

    return 0;

    }

    //

    //

    //功能:十六进制转为十进制

    //

    //输入:const unsigned char *hex         待转换的十六进制数据

    //      int length                       十六进制数据长度

    //

    //输出:

    //

    //返回:int  rslt                        转换后的十进制数据

    //

    //思路:十六进制每个字符位所表示的十进制数的范围是0 ~255,进制为256

    //      左移8位(<<8)等价乘以256

    //

    /

    unsigned long HextoDec(const unsigned char *hex, int length)

    {

    int i;

    unsigned long rslt = 0;

    for (i = 0; i 

    {

    rslt += (unsigned long)(hex[i]) <

    }

    return rslt;

    }

    /

    //

    //功能:十进制转十六进制

    //

    //输入:int dec                     待转换的十进制数据

    //      int length                  转换后的十六进制数据长度

    //

    //输出:unsigned char *hex          转换后的十六进制数据

    //

    //返回:0    success

    //

    //思路:原理同十六进制转十进制

    //

    int DectoHex(int dec, unsigned char *hex, int length)

    {

    int i;

    for (i = length - 1; i >= 0; i--)

    {

    hex[i] = (dec % 256) & 0xFF;

    dec /= 256;

    }

    return 0;

    }

    /

    //

    //功能:求权

    //

    //输入:int base                    进制基数

    //      int times                   权级数

    //

    //输出:

    //

    //返回:unsigned long               当前数据位的权

    //

    //

    unsigned long power(int base, int times)

    {

    int i;

    unsigned long rslt = 1;

    for (i = 0; i 

    rslt *= base;

    return rslt;

    }

    /

    //

    //功能:BCD转10进制

    //

    //输入:const unsigned char *bcd     待转换的BCD码

    //      int length                   BCD码数据长度

    //

    //输出:

    //

    //返回:unsigned long               当前数据位的权

    //

    //思路:压缩BCD码一个字符所表示的十进制数据范围为0 ~ 99,进制为100

    //      先求每个字符所表示的十进制值,然后乘以权

    //

    unsigned long  BCDtoDec(const unsigned char *bcd, int length)

    {

    int i, tmp;

    unsigned long dec = 0;

    for (i = 0; i 

    {

    tmp = ((bcd[i] >> 4) & 0x0F) * 10 + (bcd[i] & 0x0F);

    dec += tmp * power(100, length - 1 - i);

    }

    return dec;

    }

    /

    //

    //功能:十进制转BCD码

    //

    //输入:int Dec                      待转换的十进制数据

    //      int length                   BCD码数据长度

    //

    //输出:unsigned char *Bcd           转换后的BCD码

    //

    //返回:0  success

    //

    //思路:原理同BCD码转十进制

    //

    //

    int DectoBCD(int Dec, unsigned char *Bcd, int length)

    {

    int i;

    int temp;

    for (i = length - 1; i >= 0; i--)

    {

    temp = Dec % 100;

    Bcd[i] = ((temp / 10) <

    Dec /= 100;

    }

    return 0;

    }

    //main函数

    int main(int argc, char** argv)

    {

    //BCD码转十进制

    unsigned char BCD[3] = { 0x00, 0x53, 0x20 };

    int dec_bcd = BCDtoDec(BCD, 3);

    cout <

    //十进制转BCD码

    unsigned char tmp_bff[3] = "";

    DectoBCD(dec_bcd, tmp_bff, 3);

    for (int i = 0; i 

    {

    //cout <

    printf("tmp_bff[%d] = 0x%02X\n", i, tmp_bff[i]);

    }

    cout <

    //十六进制转十进制

    unsigned char Hex[3] = { 0x00, 0x53, 0x20 };

    int dec_hex = HextoDec(Hex, 3);

    cout <

    //十进制转十六进制

    unsigned char hex_bff[3] = "";

    DectoHex(dec_hex, hex_bff, 3);

    for (int i = 0; i 

    {

    printf("hex_bff[%d] = 0x%02X\n", i, hex_bff[i]);

    }

    system("pause");

    return 0;

    }

    展开全文
  • 二进制BCD码

    2017-04-29 18:47:00
    应用: 用fpga实现对数码管显示,以前通常的方法是进行整除取余进行运算,但是fpga并不擅长乘法除法运算,所以...因此在数码管显示中,也就是把256各位分出来,就可以用bcd码来表示,下面说一种二进制转换bcd码的...

       应用:

        用fpga实现对数码管显示,以前通常的方法是进行整除和取余进行运算,但是fpga并不擅长乘法除法运算,所以可以用BCD码来转换。

        BCD码:通俗的可以理解为用四位二进制数表示一位十进制数字。例如,256就可以用bcd码表示为:0010_1001_0110

        因此在数码管显示中,也就是把256各位分出来,就可以用bcd码来表示,下面说一种二进制转换bcd码的方法。

        加3移位法:

        bcd码中只有0~9十进制数,但是在四位二进制中是16进制进1,因此在移位过程中要对二进制进行判断,当在移位之后的状态Qn+1大于9,要对Qn加6才可以。例如1000移位大于9加6为0001_0110,对应bcd码中的16。

         我们也可以在移位之前进行判断,如果移位之前的Qn数据大于4,说明Qn+1会溢出,所以可以+3再进行移位,例如1000大于4,加3为1011然后再进行移位0001_0110,16和刚才结果是一样的。

        简单的说,判断的目的是防止下一次移位,发生数据溢出的情况

        思路:  

        代码可以总结为三个部分:移位,加二进制数,判断(最后一次不需要判断)

        例如15  ---  1111

                (1)移位    0000_0000         加    0000_0001        判断    0000_0001

                (2)移位    0000_0010         加    0000_0011        判断    0000_0011

                (3)移位    0000_0110         加    0000_0111        判断    0000_1010         

                (4)移位    0001_0100         加    0001_0101    

     

    /*********************************
     功能:实现对6位十进制数以内的bcd码转换
     time: 2017/4/29
     vision:1.0
    *********************************/
    
    `define        data_in_num        19
    `define        data_bcd_num    23
    module        pro_bcd(
                clk,
                rst_n,
                data_in,
                data_bcd
    );
    input                            clk;
    input                            rst_n;
    input        [`data_in_num :0]    data_in;
    output        [`data_bcd_num:0]    data_bcd;        
    
    
    reg            [`data_bcd_num:0]        data_bcd_r;
    reg            [1:0]                state;
    reg            [5:0]                shift_cnt;    
    always @(posedge clk or negedge rst_n)
        if(!rst_n)begin    
            data_bcd_r <= 0;
            state <= 0;
            shift_cnt <= 0;
        end
        else
            case(state)
                2'd0:begin
                    shift_cnt <= 0;
                    data_bcd_r <= 0;
                    state <= state + 1;
                end
                2'd1:begin //移位
                    if(shift_cnt < `data_in_num + 1)begin
                        data_bcd_r <= data_bcd_r<<1;
                        shift_cnt <= shift_cnt + 1;
                        state <= state + 1;
                    end
                    else
                        state <= 0;
                    end
                2'd2:begin //相加
                    data_bcd_r <= data_bcd_r + data_in[`data_in_num + 1 - shift_cnt];
                    state <= state + 1;
                end
                2'd3:begin //判断
                    if(data_bcd_r[3:0] > 4 ) //1
                        data_bcd_r <= data_bcd_r + 3;
                    if(data_bcd_r[7:4]>4)    //2
                        data_bcd_r[7:4] <= data_bcd_r[7:4] + 3;
                    if(data_bcd_r[11:8]>4)   //3
                        data_bcd_r[11:8] <= data_bcd_r[11:8] + 3;
                    if(data_bcd_r[15:12]>4)  //4
                        data_bcd_r[15:12] <= data_bcd_r[15:12] + 3;
                    if(data_bcd_r[19:16]>4)  //5
                        data_bcd_r[19:16] <= data_bcd_r[19:16] + 3;
                    if(data_bcd_r[`data_bcd_num:20]>4)  //6
                        data_bcd_r[`data_bcd_num:20] <= data_bcd_r[`data_bcd_num:20] + 3;
                    state <= 1;
                end
                
                default:state <= 0;
            endcase
    
    
    assign        data_bcd = (state == 3)&&(shift_cnt == `data_in_num + 1) ? data_bcd_r : data_bcd;
    
    
    endmodule

     

    转载于:https://www.cnblogs.com/bixiaopengblog/p/6785845.html

    展开全文
  • 在项目设计中,经常需要显示一些数值,比如温湿度,时间等等。在数字电路中数据都是用二进制的形式存储,要想显示就需要进行...但是这样未免会耗费太多资源,使用移位加3算法就可以实现二进制BCD码之间的转换。 ...

           在项目设计中,经常需要显示一些数值,比如温湿度,时间等等。在数字电路中数据都是用二进制的形式存储,要想显示就需要进行转换,对于一个两位的数值,对10取除可以得到其十位的数值,对10取余可以得到个位的数值。对于Verilog来说它的标准是支持除法和取余运算的,综合器也会有IP可以进行除法运算。但是这样未免会耗费太多资源,使用移位加3算法就可以实现二进制到BCD码之间的转换。

           BCD码(Binary-Coded Decimal‎)亦称二进码十进数或二-十进制代码。用4位二进制数来表示1位十进制数中的0~9这10个数码。

           移位加3算法简单来说就是,有多少位二进制说,就进行多少次移位,以八位的二进制为例,其数值最高可为三位十进制数,进行如下表左移,在移位的过程中,如果移位出的数值大于4,则将改为的数值加3后再进行移位。

    这里为什么大于四,BCD码是四位二进制数表示一个十进制数的一位,如果这以为大于4,比如5,4’b0101,下一次移位后变成了4’b1010,BCD码中是没有4’b1010的,所以要加6,向高位进位。这里就是移位后加6和移位前加3,两种方法修正,我这里选择了移位前加3。(4’b0011左移后也是4’b0110,移位前和移位后都是一样的对BCD码的位数进行修正)。

    为什么用左移的方法呢?这是因为二进制数和十进制数之间的位权的关系。所以二进数和十进制数之间的转化是乘以2,也就是左移一位。转换公式大概就是这个样子。

    公式编辑采用Markdown编辑器Typora完成,Typora支持LaTex语法,编写公式真是爽。

           代码实现起来不是很复杂,博主在网上搜索到有些代码使用纯组合逻辑实现的,用了一个for循环,我个人认为这种写法不是很好,所以自己用状态机写了一个。模块设计如下,tran_en是转换使能信号,可以使电平使能也可以是脉冲使能,作为脉冲使能使用的时候,需要在数据来临之后的一个时钟周期给出使能(我的模块是这样的特点),电平使能有效时,需要18个时钟周期完成转换,输入二进制位16bit,输出为四组千百十个位。转换完成后输出一个转换完成标志tran_done。

     

           内部的时序我采用了三段式状态机来完成。IDLE状态接收到使能信号,调到移位状态,经过16次移位。在shift_cnt为17时(这里是因为我状态机的原理所以shift_cnt会计数到17,但移位次数为16),数据转换完成。跳到DONE状态,输出转换完成标志。

     

           采用组合逻辑来实现,移位后的数据值的判断,大于4加3后再进行移位。最后将转换完成后的结果输出。

    代码如下:

      1 `timescale      1ns/1ps
      2 // *********************************************************************************
      3 // Project Name :       
      4 // Author       : NingHeChuan
      5 // Email        : ninghechuan@foxmail.com
      6 // Blogs        : http://www.cnblogs.com/ninghechuan/
      7 // File Name    : Bin_BCD.v
      8 // Module Name  :
      9 // Called By    :
     10 // Abstract     :
     11 //
     12 // CopyRight(c) 2018, NingHeChuan Studio.. 
     13 // All Rights Reserved
     14 //
     15 // *********************************************************************************
     16 // Modification History:
     17 // Date         By              Version                 Change Description
     18 // -----------------------------------------------------------------------
     19 // 2018/8/12    NingHeChuan       1.0                     Original
     20 //  
     21 // *********************************************************************************
     22 
     23 module Bin_BCD
     24 #(
     25     parameter       DATA_WIDTH  =   16,
     26     parameter       SHIFT_WIDTH =   5,
     27     parameter       SHIFT_DEPTH =   16
     28     
     29 )
     30 (
     31     input               clk,
     32     input               rst_n,
     33     input               tran_en,
     34     input       [DATA_WIDTH - 1:0]  data_in,
     35     output   reg        tran_done,
     36     output      [3:0]   thou_data,      //千位
     37     output        [3:0]    hund_data,      //百位
     38     output        [3:0]    tens_data,      //十位
     39     output        [3:0]    unit_data       //个位
     40 
     41 );
     42 //-------------------------------------------------------
     43 localparam  IDLE    =   3'b001;
     44 localparam   SHIFT   =   3'b010;
     45 localparam   DONE    =   3'b100;
     46 
     47 //-------------------------------------------------------
     48 reg     [2:0]   pre_state;
     49 reg     [2:0]   next_state;
     50 //
     51 reg     [SHIFT_DEPTH-1:0]   shift_cnt;
     52 //
     53 reg     [DATA_WIDTH:0]  data_reg;
     54 reg     [3:0]   thou_reg;
     55 reg        [3:0]    hund_reg;
     56 reg        [3:0]    tens_reg;
     57 reg        [3:0]    unit_reg; 
     58 reg     [3:0]   thou_out;
     59 reg        [3:0]    hund_out;
     60 reg        [3:0]    tens_out;
     61 reg        [3:0]    unit_out; 
     62 wire    [3:0]   thou_tmp;
     63 wire    [3:0]    hund_tmp;
     64 wire    [3:0]    tens_tmp;
     65 wire    [3:0]    unit_tmp;
     66 
     67 //-------------------------------------------------------
     68 //FSM step1
     69 always  @(posedge clk or negedge rst_n)begin
     70     if(rst_n == 1'b0)begin
     71         pre_state <= IDLE;
     72     end
     73     else begin
     74         pre_state <= next_state;
     75     end
     76 end
     77 
     78 //FSM step2
     79 always  @(*)begin
     80     case(pre_state)
     81     IDLE:begin
     82         if(tran_en == 1'b1)
     83             next_state = SHIFT;
     84         else 
     85             next_state = IDLE;
     86     end
     87     SHIFT:begin
     88         if(shift_cnt == SHIFT_DEPTH + 1)
     89             next_state = DONE;
     90         else 
     91             next_state = SHIFT;
     92     end
     93     DONE:begin
     94         next_state = IDLE;
     95     end
     96     default:next_state = IDLE;
     97     endcase
     98 end
     99 
    100 //FSM step3
    101 always  @(posedge clk or negedge rst_n)begin
    102     if(rst_n == 1'b0)begin
    103         thou_reg <= 4'b0; 
    104         hund_reg <= 4'b0; 
    105         tens_reg <= 4'b0; 
    106         unit_reg <= 4'b0; 
    107         tran_done <= 1'b0;
    108         shift_cnt <= 'd0; 
    109         data_reg <= 'd0;
    110     end
    111     else begin
    112         case(next_state)
    113         IDLE:begin
    114             thou_reg <= 4'b0; 
    115             hund_reg <= 4'b0; 
    116             tens_reg <= 4'b0; 
    117             unit_reg <= 4'b0; 
    118             tran_done <= 1'b0;
    119             shift_cnt <= 'd0; 
    120             data_reg <= data_in;
    121         end
    122         SHIFT:begin
    123             if(shift_cnt == SHIFT_DEPTH + 1)
    124                 shift_cnt <= 'd0;
    125             else begin
    126                 shift_cnt <= shift_cnt + 1'b1;
    127                 data_reg <= data_reg << 1;
    128                 unit_reg <= {unit_tmp[2:0], data_reg[16]};
    129                 tens_reg <= {tens_tmp[2:0], unit_tmp[3]};
    130                 hund_reg <= {hund_tmp[2:0], tens_tmp[3]};
    131                 thou_reg <= {thou_tmp[2:0], hund_tmp[3]};
    132             end
    133         end
    134         DONE:begin
    135             tran_done <= 1'b1;
    136         end
    137         default:begin
    138             thou_reg <= thou_reg; 
    139             hund_reg <= hund_reg; 
    140             tens_reg <= tens_reg; 
    141             unit_reg <= unit_reg; 
    142             tran_done <= tran_done;
    143             shift_cnt <= shift_cnt; 
    144         end
    145         endcase
    146     end
    147 end
    148 //-------------------------------------------------------
    149 always  @(posedge clk or negedge rst_n)begin
    150     if(rst_n == 1'b0)begin
    151         thou_out <= 'd0;
    152         hund_out <= 'd0;
    153         tens_out <= 'd0;
    154         unit_out <= 'd0; 
    155     end
    156     else if(tran_done == 1'b1)begin
    157         thou_out <= thou_reg;
    158         hund_out <= hund_reg;
    159         tens_out <= tens_reg;
    160         unit_out <= unit_reg;
    161     end
    162     else begin
    163         thou_out <= thou_out;
    164         hund_out <= hund_out;
    165         tens_out <= tens_out;
    166         unit_out <= unit_out;
    167     end
    168 end
    169 
    170 
    171 //-------------------------------------------------------
    172 assign  thou_tmp = (thou_reg > 4'd4)?  (thou_reg + 2'd3) : thou_reg;
    173 assign  hund_tmp = (hund_reg > 4'd4)?  (hund_reg + 2'd3) : hund_reg;
    174 assign  tens_tmp = (tens_reg > 4'd4)?  (tens_reg + 2'd3) : tens_reg; 
    175 assign  unit_tmp = (unit_reg > 4'd4)?  (unit_reg + 2'd3) : unit_reg; 
    176 
    177 assign thou_data = thou_out;
    178 assign hund_data = hund_out;
    179 assign tens_data = tens_out;
    180 assign unit_data = unit_out;
    181 
    182 
    183 endmodule 
    Bin_BCD

     

    转载请注明出处:NingHeChuan(宁河川)

    个人微信订阅号:开源FPGA

    如果你想及时收到个人撰写的博文推送,可以扫描左边二维码(或者长按识别二维码)关注个人微信订阅号

    知乎ID:NingHeChuan

    微博ID:NingHeChuan

    原文地址:https://www.cnblogs.com/ninghechuan/p/9464037.html

     

    转载于:https://www.cnblogs.com/ninghechuan/p/9464037.html

    展开全文
  • 转载:转载自:.../////////////////////////////////////////////////////////功能:二进制取反////输入:const unsigned char *src...

    转载:

    转载自:http://www.cppblog.com/tdweng/articles/139022.html

    #include

    #include

    #include

    using namespace std;

    /

    //

    //功能:二进制取反

    //

    //输入:const unsigned char *src 二进制数据

    // int length 待转换的二进制数据长度

    //

    //输出:unsigned char *dst 取反后的二进制数据

    //

    //返回:0 success

    //

    //

    int convert(unsigned char *dst, const unsigned char *src, int length)

    {

    int i;

    for (i = 0; i < length; i++)

    {

    dst[i] = src[i] ^ 0xFF;

    }

    return 0;

    }

    //

    //

    //功能:十六进制转为十进制

    //

    //输入:const unsigned char *hex 待转换的十六进制数据

    // int length 十六进制数据长度

    //

    //输出:

    //

    //返回:int rslt 转换后的十进制数据

    //

    //思路:十六进制每个字符位所表示的十进制数的范围是0 ~255,进制为256

    // 左移8位(<<8)等价乘以256

    //

    /

    unsigned long HextoDec(const unsigned char *hex, int length)

    {

    int i;

    unsigned long rslt = 0;

    for (i = 0; i < length; i++)

    {

    rslt += (unsigned long)(hex[i]) << (8 * (length - 1 - i));

    }

    return rslt;

    }

    /

    //

    //功能:十进制转十六进制

    //

    //输入:int dec 待转换的十进制数据

    // int length 转换后的十六进制数据长度

    //

    //输出:unsigned char *hex 转换后的十六进制数据

    //

    //返回:0 success

    //

    //思路:原理同十六进制转十进制

    //

    int DectoHex(int dec, unsigned char *hex, int length)

    {

    int i;

    for (i = length - 1; i >= 0; i--)

    {

    hex[i] = (dec % 256) & 0xFF;

    dec /= 256;

    }

    return 0;

    }

    /

    //

    //功能:求权

    //

    //输入:int base 进制基数

    // int times 权级数

    //

    //输出:

    //

    //返回:unsigned long 当前数据位的权

    //

    //

    unsigned long power(int base, int times)

    {

    int i;

    unsigned long rslt = 1;

    for (i = 0; i < times; i++)

    rslt *= base;

    return rslt;

    }

    /

    //

    //功能:BCD转10进制

    //

    //输入:const unsigned char *bcd 待转换的BCD码

    // int length BCD码数据长度

    //

    //输出:

    //

    //返回:unsigned long 当前数据位的权

    //

    //思路:压缩BCD码一个字符所表示的十进制数据范围为0 ~ 99,进制为100

    // 先求每个字符所表示的十进制值,然后乘以权

    //

    unsigned long BCDtoDec(const unsigned char *bcd, int length)

    {

    int i, tmp;

    unsigned long dec = 0;

    for (i = 0; i < length; i++)

    {

    tmp = ((bcd[i] >> 4) & 0x0F) * 10 + (bcd[i] & 0x0F);

    dec += tmp * power(100, length - 1 - i);

    }

    return dec;

    }

    /

    //

    //功能:十进制转BCD码

    //

    //输入:int Dec 待转换的十进制数据

    // int length BCD码数据长度

    //

    //输出:unsigned char *Bcd 转换后的BCD码

    //

    //返回:0 success

    //

    //思路:原理同BCD码转十进制

    //

    //

    int DectoBCD(int Dec, unsigned char *Bcd, int length)

    {

    int i;

    int temp;

    for (i = length - 1; i >= 0; i--)

    {

    temp = Dec % 100;

    Bcd[i] = ((temp / 10) << 4) + ((temp % 10) & 0x0F);

    Dec /= 100;

    }

    return 0;

    }

    //main函数

    int main(int argc, char** argv)

    {

    //BCD码转十进制

    unsigned char BCD[3] = { 0x00, 0x53, 0x20 };

    int dec_bcd = BCDtoDec(BCD, 3);

    cout << "dec_bcd : " << dec_bcd << endl;

    //十进制转BCD码

    unsigned char tmp_bff[3] = "";

    DectoBCD(dec_bcd, tmp_bff, 3);

    for (int i = 0; i < 3; ++i)

    {

    //cout << "tmp_buff[" << i << "]: " << tmp_bff[i] << endl;

    printf("tmp_bff[%d] = 0x%02X\n", i, tmp_bff[i]);

    }

    cout << endl << endl;

    //十六进制转十进制

    unsigned char Hex[3] = { 0x00, 0x53, 0x20 };

    int dec_hex = HextoDec(Hex, 3);

    cout << "dec_hex: " << dec_hex << endl;

    //十进制转十六进制

    unsigned char hex_bff[3] = "";

    DectoHex(dec_hex, hex_bff, 3);

    for (int i = 0; i < 3; ++i)

    {

    printf("hex_bff[%d] = 0x%02X\n", i, hex_bff[i]);

    }

    system("pause");

    return 0;

    }

    int PrintVal = 9;

    /*按整型输出,默认右对齐*/

    printf("%d\n",PrintVal);

    /*按整型输出,补齐4位的宽度,补齐位为空格,默认右对齐*/

    printf("%4d\n",PrintVal);

    /*按整形输出,补齐4位的宽度,补齐位为0,默认右对齐*/

    printf("%04d\n",PrintVal);

    /*按16进制输出,默认右对齐*/

    printf("%x\n",PrintVal);

    /*按16进制输出,补齐4位的宽度,补齐位为空格,默认右对齐*/

    printf("%4x\n",PrintVal);

    /*按照16进制输出,补齐4位的宽度,补齐位为0,默认右对齐*/

    printf("%04x\n",PrintVal);

    /*按8进制输出,默认右对齐*/

    printf("%o\n",PrintVal);

    /*按8进制输出,补齐4位的宽度,补齐位为空格,默认右对齐*/

    printf("%4o\n",PrintVal);

    /*按照8进制输出,补齐4位的宽度,补齐位为0,默认右对齐*/

    printf("%04o\n",PrintVal);

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

    版权声明:本文为CSDN博主「卡图卢斯」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。

    原文链接:https://blog.csdn.net/u014647208/article/details/53337315

    C++ 函数

    函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数,即主函数 main() ,所有简单的程序都可以定义其他额外的函数。

    您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的,但在逻辑上,划分通常是根据每个函数执行一个特定的任务来进行的。

    函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。

    C++ 标准库提供了大量的程序可以调用的内置函数。例如,函数 strcat() 用来连接两个字符串,函数 memcpy() 用来复制内存到另一个位置。

    函数还有很多叫法,比如方法、子例程或程序,等等。

    定义函数

    C++ 中的函数定义的一般形式如下:

    return_typefunction_name(parameterlist){bodyofthefunction}

    在 C++ 中,函数由一个函数头和一个函数主体组成。下面列出一个函数的所有组成部分:

    返回类型:一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值,在这种情况下,return_type 是关键字 void。

    函数名称:这是函数的实际名称。函数名和参数列表一起构成了函数签名。

    参数:参数就像是占位符。当函数被调用时,您向参数传递一个值,这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的,也就是说,函数可能不包含参数。

    函数主体:函数主体包含一组定义函数执行任务的语句。

    实例

    以下是 max() 函数的源代码。该函数有两个参数 num1 和 num2,会返回这两个数中较大的那个数:

    // 函数返回两个数中较大的那个数intmax(intnum1, intnum2){// 局部变量声明intresult; if(num1> num2)result= num1; elseresult= num2; returnresult; }

    函数声明

    函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

    函数声明包括以下几个部分:

    return_type function_name(parameter list );

    针对上面定义的函数 max(),以下是函数声明:

    intmax(intnum1,intnum2);

    在函数声明中,参数的名称并不重要,只有参数的类型是必需的,因此下面也是有效的声明:

    intmax(int,int);

    当您在一个源文件中定义函数且在另一个文件中调用函数时,函数声明是必需的。在这种情况下,您应该在调用函数的文件顶部声明函数。

    调用函数

    创建 C++ 函数时,会定义函数做什么,然后通过调用函数来完成已定义的任务。

    当程序调用函数时,程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务,当函数的返回语句被执行时,或到达函数的结束括号时,会把程序控制权交还给主程序。

    调用函数时,传递所需参数,如果函数返回一个值,则可以存储返回值。例如:

    实例

    #includeusingnamespacestd; // 函数声明intmax(intnum1, intnum2); intmain(){// 局部变量声明inta= 100; intb= 200; intret; // 调用函数来获取最大值ret= max(a, b); cout<< "Max value is : "<< ret<< endl; return0; }// 函数返回两个数中较大的那个数intmax(intnum1, intnum2){// 局部变量声明intresult; if(num1> num2)result= num1; elseresult= num2; returnresult; }

    把 max() 函数和 main() 函数放一块,编译源代码。当运行最后的可执行文件时,会产生下列结果:

    Maxvalue is:200

    函数参数

    如果函数要使用参数,则必须声明接受参数值的变量。这些变量称为函数的形式参数。

    形式参数就像函数内的其他局部变量,在进入函数时被创建,退出函数时被销毁。

    当调用函数时,有三种向函数传递参数的方式:

    调用类型描述

    该方法把参数的实际值赋值给函数的形式参数。在这种情况下,修改函数内的形式参数对实际参数没有影响。

    该方法把参数的地址赋值给形式参数。在函数内,该地址用于访问调用中要用到的实际参数。这意味着,修改形式参数会影响实际参数。

    该方法把参数的引用赋值给形式参数。在函数内,该引用用于访问调用中要用到的实际参数。这意味着,修改形式参数会影响实际参数。

    默认情况下,C++ 使用传值调用来传递参数。一般来说,这意味着函数内的代码不能改变用于调用函数的参数。之前提到的实例,调用 max() 函数时,使用了相同的方法。

    参数的默认值

    当您定义一个函数,您可以为参数列表中后边的每一个参数指定默认值。当调用函数时,如果实际参数的值留空,则使用这个默认值。

    这是通过在函数定义中使用赋值运算符来为参数赋值的。调用函数时,如果未传递参数的值,则会使用默认值,如果指定了值,则会忽略默认值,使用传递的值。请看下面的实例:

    实例

    #includeusingnamespacestd; intsum(inta, intb=20){intresult; result= a+ b; return(result); }intmain(){// 局部变量声明inta= 100; intb= 200; intresult; // 调用函数来添加值result= sum(a, b); cout<< "Total value is :"<< result<< endl; // 再次调用函数result= sum(a); cout<< "Total value is :"<< result<< endl; return0; }

    当上面的代码被编译和执行时,它会产生下列结果:

    Totalvalue is:300Totalvalue is:120

    Lambda 函数与表达式

    C++11 提供了对匿名函数的支持,称为 Lambda 函数(也叫 Lambda 表达式)。

    Lambda 表达式把函数看作对象。Lambda 表达式可以像对象一样使用,比如可以将它们赋给变量和作为参数传递,还可以像函数一样对其求值。

    Lambda 表达式本质上与函数声明非常类似。Lambda 表达式具体形式如下:

    [capture](parameters)->return-type{body}

    例如:

    [](intx,inty){returnx

    如果没有返回值可以表示为:

    [capture](parameters){body}

    例如:

    []{++global_x;}

    在一个更为复杂的例子中,返回类型可以被明确的指定如下:

    [](intx,inty)->int{intz =x +y;returnz +x;}

    本例中,一个临时的参数 z 被创建用来存储中间结果。如同一般的函数,z 的值不会保留到下一次该不具名函数再次被调用时。

    如果 lambda 函数没有传回值(例如 void),其返回类型可被完全忽略。

    在Lambda表达式内可以访问当前作用域的变量,这是Lambda表达式的闭包(Closure)行为。 与JavaScript闭包不同,C++变量传递有传值和传引用的区别。可以通过前面的[]来指定:

    []// 沒有定义任何变量。使用未定义变量会引发错误。[x,&y]// x以传值方式传入(默认),y以引用方式传入。[&]// 任何被使用到的外部变量都隐式地以引用方式加以引用。[=]// 任何被使用到的外部变量都隐式地以传值方式加以引用。[&,x]// x显式地以传值方式加以引用。其余变量以引用方式加以引用。[=,&z]// z显式地以引用方式加以引用。其余变量以传值方式加以引用。

    另外有一点需要注意。对于[=]或[&]的形式,lambda 表达式可以直接使用 this 指针。但是,对于[]的形式,如果要使用 this 指针,必须显式传入:

    [this](){this->someFunc();}();

    展开全文
  • C#下16进制和BCD码转换代码

    千次阅读 2013-09-13 15:09:45
    private static Byte[] ConvertFrom(string strTemp) { try { if (Convert.ToBoolean(strTemp.Length & 1))//数字的二进制码最后1位是1则为奇数 {
  • BCD码转换二进制和ASCII码

    万次阅读 2015-01-17 16:32:10
    BCD码转换二进制和ASCII码;用BCD码表示:十位上十进制数为 2 == BCD码表示为 0010;个位上十进制数9 === BCD码表示为 1001;所以总来说 十进制数 29 用BCD码表示为:0010 1001;转换过程:把BCD码 0010(十...
  • 首先得知道什么是BCD码,可以看下百度,基本定义...BCD码是用4位二进制数(各个位权重分别为:8421,所以叫8421码)来表示一位十进制数。这里一位十进制数要特别说明下,一位十进制数只能是 0~9之间一个数值。...
  • bcd_8421主要是将data_gen产生的二进制数据转化为bcd码,这样便于显示,其转换如下所示。 最后移位次数二进制的数据位数有关,例如图中输入的二进制码为8位,则最后移位次数也为8。 二、实现 波形图 ...
  • 首先给出二进制转换为十进制BCD码的几个步骤(以8bit二进制码为例): 1.将二进制码左移一位(或者乘2) 2.找到左移后的码所对应的个,十,百位。 3.判断在个位百位的码是否大于5,如果是则该段码加3。 ...
  • 使用LABVIEW 生成子VI 可以有效得将二进制数,转换成16进制数的BCD码。 常用于校验分析上。
  • 【设计要求】 设计一个4位的二进制格雷码转换电路 ...如果二进制码的第i位第i+1位相同则第i位格雷码为0,反之则为1.(0<= i <= n-1) 【BCD_TRANS.v】 timescale 1ns / 1ps ////////////////////////////////
  • 3、掌握单片机开发程序烧录方法流程 、实验内容 1、完成单片机开发相关必备软件安装 2、学习单片机开发板套件实验原理图 3、编写、下载及实现第一个单片机程序(点亮一个LED灯) 三、实验原理 单片机...
  • 进制转换和BCD码

    千次阅读 2018-11-01 11:45:56
    1.十—二进制的转换 (由十到二): 整数部分:用十进制数逐次除以2,每次的余数即为二进制的一位数字(从最低位数开始) 小数部分:用十进制小数部分逐次乘以2,每次所得乘积的整数即位二进制的一位数字(从...
  • BCD码二进制的转换

    千次阅读 2020-03-29 19:53:55
    重复12步8次(重复次数取决于需要表示数字的二进制形式最大位数,此处为8) 结束循环,则百位十位个位就是对应的BCD码 原理 4位二进制,大于等于16进位;4位BCD,大于等于10进位。两个相...
  • 格雷自然二进制码相邻数据之间可能存在多个bit变化,例如自然数78对应4bits自然二进制码分别“0111”、“1000输出从7变到8时,寄存器每一位都会发生变化,从而造成不稳定态,并且会使得数字电路产生很大...
  • 二进制BCD

    2016-08-31 22:48:00
    BCD码这种编码形式利用了四个位元来储存一个十进制的数码,使二进制和十进制之间的转换得以快捷的进行。这种编码技巧,最常用于会计系统的设计里,因为 会计制度经常需要对很长的数字串作准确的计算。相对于一般的...
  • 二进制bcd

    2015-04-02 22:11:00
    定义:BCD码这种编码形式利用了四个位元来储存一个十进制的数码,使二进制和十进制之间的转换得以快捷的进行。这种编码技巧,最常用于会计系统的设计里,因为会计制度经常需要对很长的数字串作准确的计算。相对于...
  • 本文主要介绍了如何利用左移原理去进行16位带符号数二进制转换BCD码,用Quartus II软件Modelsim软件进行编译仿真,最后再从Quartus II软件上下载到开发板上进行测试。
  • verilog快速将二进制转成BCD码

    千次阅读 2019-01-02 12:02:39
    转换BCD码的方式有很多,这个就要根据自己的需要做出选择。我想介绍的是一种高速转换的方式:利用简单的状态机一个自定义的函数来实现这个功能。 函数介绍:BCD码就是利用四个二进制位表示...
  • 介绍8421BCD码、ASCII码、二进制码原理以及相互之间的转换 计算机内毫无例外地都使用二进制数进行运算,但通常采用8进制和十六进制的形式读写。对于计算机技术专业人员,要理解这些数的含义是没问题,但对非专业...
  • 正如题目,用二进制编码的十进制代码,使二进制和十进制之间的转换得以快捷的进行。 加权-“8421” 加权-“2421” 无权-余三 无权-格雷(Gray也称循环) 十进制数 8421 5421 2421 ...
  • 广州大学学生实验报告开课学院及实验室:实验中心电子信息楼2013年11月4日学院机电年级、专业、班姓名学号实验课程名称微机原理实验成绩实验项目名称二进制到ASCII码转换指导教师一、实验目的二、实验原理(实验相关...
  • 定义:BCD码这种编码形式利用了四个位元来储存一个十进制的数码,使二进制和十进制之间的转换得以快捷的进行。这种编码技巧,最常用于会计系统的设计里,因为会计制度经常需要对很长的数字串作准确的计算。相对于...
  • BCD码这种编码形式利用了四个位元来储存一个十进制的数码,使二进制和十进制之间的转换得以快捷的进行。这种编码技巧最常用于会计系统的设计里,因为会计制度经常需要对很长的数字串作准确的计算。相对于一般的浮点....
  • 汇编把一个16位无符号二进制转换成为用8421BCD码表示5位十进制数。转换算法可以是:用二进制数除以10000,商为“万位”,再用余数除以1000,得到“千位”;依次用余数除以100、101,得到“百位”、“十位”...
  • BCD码与十进制转换

    2019-08-05 12:09:15
    用4位二进制数来表示1位十进制数中0~9这10个数码。BCD码可分为有权码无权码两类:有权BCD码有8421码、2421码、5421码,其中8421码是最常用的BCD码。无权BCD码有余3码,余3循环码等。 1.1 8421码 8421 BCD码是最...
  • BCD码与十进制数间转换

    万次阅读 多人点赞 2018-06-13 00:26:15
    用4位二进制数来表示1位十进制数中0~9这10个数码。BCD码可分为有权码无权码两类:有权BCD码有8421码、2421码、5421码,其中8421码是最常用;无权BCD码有余3码,余3循环码等。 1.1 8421码   8421 BCD码是...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 224
精华内容 89
关键字:

二进制和bcd码的转换