ethereum(以太坊)(六)--整型(int)

/*
uint8 uint16 ...uint256
int8  int16 int24 ..int256

uint => uint256
int  =>  int256

int8 有符号 +1 ,-3
uint 无符号 1,2

int8 8(位)
1 111 1111 ~ 0 111 1111
- (1+2+4+8+16+32+64) ~ + (1+2+4+8+16+32+64)
-127 ~ 127  255(127*2+0)

uint8
0000 0000 ~ 1111 1111 (0~255)
*/

pragma solidity ^0.4.0;
contract Ballot {

    int8 _a;

    function set(int8 a){
        _a = a;
    }

    function get() constant returns(int8){
        return _a;
    }
}

pragma solidity ^0.4.0;
contract Ballot {

    function test1() constant returns(uint){
        uint8 a = 100;
        var b = a ;
        return b;
    }

    function test2() constant returns(uint){
        uint a;

        //var == uint8
        /*
        when i <= 255, i++ than i = 256,
        but max of uint8 is 255,so i cannot continue
        */
        for (uint i=0;i<=255;i++){
            a = i;
        }
        return a;
    }
}

pragma solidity ^0.4.0;
contract Ballot {
    uint8 a = 3;
    uint8 b = 7;
    //&, | ,^(异或),~(非)

    function yu() constant returns(uint){
        return a & b;
        //0000 0011
        //0000 0111
        //0000 0011 = 3  全1出1
    }

    function huo() constant returns(uint){
        return a | b;
        //0000 0011
        //0000 0111
        //0000 0111 = 7  有1出1
    }

    function yihuo() constant returns(uint){
        return a ^ b;
        //0000 0011
        //0000 0111
        //0000 0100 = 4 相同出0
    }

    function fei() constant returns(uint){
        return ~a;
        //0000 0011
        //1111 1100 = 255-3
    }
}

pragma solidity ^0.4.0;
contract Ballot {
    uint8 a = 7;
    uint8 b = 3;

    function add() constant returns(uint){
        return a + b;
    }
    function sub() constant returns(uint){
        return a - b;
    }
    function mul() constant returns(uint){
        return a * b;
    }
    function div() constant returns(uint){
        return a / b;
        //除(取整) 2
    }
    function mm() constant returns(uint){
        return a % b;
        //取余 1
    }
}

pragma solidity ^0.4.0;
contract Ballot {
    uint8 a = 3;
    //0000 0011

    function qiumi(uint8 b) constant returns(uint){
        return a ** b;
    }
    function leftShit(uint8 b) constant returns(uint){
        return a << b;
        //0000 0011 b=2 ->0000 1100 = 12
    }
    function rightShit(uint8 b) constant returns(uint){
        return a >> b;
        //0000 0011 b=2 ->0000 0000 = 0
    }
}

原文地址:https://www.cnblogs.com/eilinge/p/9957331.html

时间: 2024-10-07 19:52:13

ethereum(以太坊)(六)--整型(int)的相关文章

[C]基本数据类型:整型(int)用法详解

1.整型int C语言提供了很多整数类型(整型),这些整型的区别在于它们的取值范围的大小,以及是否可以为负.int是整型之一,一般被称为整型.以后,在不产生歧义的情况下,我们把整数类型和int都称为整型. int代表有符号整数,也就是说,用int声明的变量可以是正数,可以是负数,也可以是零,但是只能是整数.标准规定int的最小取值范围是-32767到32767.int的取值范围因机器而异,但是一定要大于或者等于-32767到32767.一般来说,int占用一个字的内存空间.因此,字长为16位(B

数据类型之整型(int)

Python中的整型用int表示.python2中: 在32位机器上,整数的位数为32位,取值范围为-2^31-2^31-1,即-2147483648-2147483647 在64位系统上,整数的位数为64位,取值范围为-2^63-2^63-1,即-9223372036854775808-9223372036854775807 超出长度之后就会变为long类型.python3中: 只有int没有long,所有数字都是int类型. 注意:在python2中使用除法时,只能保留整数位,如果想要保留小

mysql数据类型——整型INT(m)

1.整形分为四种 tinyint smallint mediumint int bigint 注意: 右侧的取值范围是在未加unsigned关键字的情况下,如果加了unsigned,则最大值翻倍,如tinyint unsigned的取值范围为(0~256). 项目出错案例: 在做根据身份获取城市的时候 发现大于127的region_id 就都取127得127( 东方市),一直找不到原因,原来是插入region_id的字段类型定义问题 定义为: tinyint(4) 最大127 若加上unsign

整型int和长整型long

python 一切事物都是对象,对象基于类创建 类:(列表)功能集合 查看对象相关成员:var,type,dir 参考文档 http://www.cnblogs.com/wupeiqi/articles/5115190.html 一.整数 int int(x=0) -> int or long int(x, base=10) -> int or long def bit_length(self): 返回表示该数字的时候占用的最少位数 int.bit_length(*) eg:int.bit_l

Delphi float浮点值转换整型int 方法

Uses Math; var ff:Extended; begin ff:=5.16; ShowMessage(IntToStr(Trunc(aa))); //截取整数,小数不要 ShowMessage(IntToStr(Floor(aa))); //往小取整 ShowMessage(IntToStr(Ceil(aa))); //往大取整 ShowMessage(IntToStr(Round(aa))); //四舍五入取整 end; 其他 Delphi数学函数 参考:https://www.cn

ethereum(以太坊)(五)--Bool

pragma solidity ^0.4.0; contract Bool{ uint num1 = 100; uint num2 = 200; bool _c = true; // && == function yuf() constant returns(bool){ return num1 == num2 && _c; //false } // || != function huof() constant returns(bool){ return num1 != n

ethereum(以太坊)(九)--global(全局函数)

pragma solidity ^0.4.0; contract modifierTest{ bytes32 public blockhash; address public coinbase; uint public difficulty; uint public gaslimit; uint public blockNum; uint public timestamp; bytes public calldata1; uint public gas; address public sende

ethereum(以太坊)(十)--字节数组

pragma solidity ^0.4.0; contract byte1{ /* 固定大小字节数组(Fixed-size byte arrays) 固定大小字节数组可以通过bytes1,bytes2...bytes32声明,byte=byte1 bytes1 只能存储1个字节,也就是二进制的8位内容 //一个字节=8位2进制/一个字母/符号/(1/3汉字) bytes2 只能存储2个字节,也就是二进制的8*2位内容 bytes32 只能存储32个字节,也就是二进制的8*32=256位内容 十

ethereum(以太坊)(基础)--容易忽略的坑(一)

pragma solidity ^0.4.0; contract base{ address public _owner=msg.sender; uint _a; string internal _b ; uint private _c; //uint external _d;ParserError: Expected identifier but got 'external' function base() { _a =10; //uint _d public;Expected ';' but