2009年6月 .NET技术大版内专家分月排行榜第二
2009年7月 .NET技术大版内专家分月排行榜第三
本帖子已过去太久远了，不再提供回复功能。查看: 210|回复: 10
静态变量是全局变量，不存在结构体的内存中，生命周期随程序。全局变量无论在哪里都可以共享
一直好愧疚
基本类型的变量如果是临时变量，只要定义了，就会分配内存空间，不管是否被赋值；如果是作为对象的属性出现，只要该对象不实例化，就不会分配内存空间。 一个完整的Java程序运行过程会涉及以下内存区域： 1、寄存器：JVM内部虚拟寄存器，存取速
妈咪妈咪哄
java静态变量它能被所有的类实例共享，对于类的所有对象 下面这句 可以存在多个静态变量实体。 既然是被共享的，大家都分享一个才叫共享 每个人都有，那叫独享……
它类的对象市,不生成static变量的副本,而是类的所有实例共享同一个static变量。对于静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加载类
常量只能使用在一个HTTP请求，即同一个进程。多个用户肯定是不行，每个用户的一个操作就是一个HTTP请求，一个进程。如果要多个用户使用同一个的话可以用缓存，也可以用写入文件、数据库之类记录起来，多个用户需要用到就去读龋
静态变量 静态变量是用static修饰的成员变量，也称为类变量。未用static修饰的成员变量称为实例变量。 实例变量必须通过对象访问，而静态变量可以通过对象访问，也可以通过类名直接访问。 例如：Math.PI 对该类的每一个具体对象而言，类变量是一
分配内存来存储而所谓静态指编译所分配内存会直存直程序退出内存才会释放空间也它类的对象市,不生成static变量的副本,而是类的所有实例共享同一个static变量。
这座城没故人
声明为static的对象为静态对象 静态对象在内存中保留着它的引用 也就是说内存中有一块区域就是专门用来存放静态方法和变量的 所以可以直接拿来用区块链以太坊系列课程
区块链平台以太坊基础入门:
区块链平台以太坊Solidity智能合约编程详解系列视频课程:
Solidity语言需要在编译的时候指定变量类型。Solidity 提供一些基本的变量类型。
bool：值可以是true或false
! (逻辑非)
&& (逻辑与, “and”)
|| (逻辑或, “or”)
!= (不等于)
int / uint：声明一个有符号和无符号的整形数字。关键字int8到int256,uint8到uint256（声明一个长度为8的倍数的整形数字），其中int/uint是int256/uint256的别名。
比较: &=, &, ==, !=, &=, & (返回 bool)
位运算: &, |, ^ (按位异或), ~ (按位取反)
算术运算 +, -,*, /, % (取余数), ** (乘方), && (左移), && (右移)
左移运算符 x && y 和 x * 2**y 是相等的，x && y 和 x / 2**y是相等的。
address：20个字节长度，是智能合约的基础。
&=, &, ==, !=, &= 和&
balance 和send
通过地址的balance 属性可以查询账户的余额，然后可以使用send来发生以太币
如果x是个合约账户，它的代码（如回调函数）会和send方法一起被执行。如果gas 不够，那么执行将会失败，
call, callcode 和delegatecall
另外，与合约交互不需要依然二进制应用程序，call方法可以传入任意多的任何类型的参数。这些参数会被填充到32个字节，然后被串联起来，除非第一个参数的长度恰好是4个字节，下面这个列子，第一个参数不会填充，允许在这里使用函数签名。
call函数返回一个布尔值，ture表示回调方法执行成功，false表示执行失败。
call, delegatecall 和callcode 都是底层函数，在不必要的情况下不要使用。
pragma solidity ^0.4.8;
contract Money_3{
function setMoney(){
total +=2;
function getMoney()returns (uint){
return (money);
contract callMoney_3{
uint public money_1;
//对应Money_3中的第一个uint的变量
function callSetMoney(address _e) returns(bool){
return _e.call(bytes4(keccak256(“setMoney()”)));
//Money_3中的money会发生改变，callMoney_3中的money不会变化
function callcodeSetMoney(address _e) returns(bool){
return _e.callcode(bytes4(keccak256(“setMoney()”))); //Money_3中的money不会改变，callMoney_3中的money会发生改变
function delegatecallSetMoney(address _e) returns(bool){
return _e.delegatecall(bytes4(keccak256(“setMoney()”))); //Money_3中的money不会改变，callMoney_3中的money会发生改变
数据存储的位置
每一个复杂类型的变量都有一个额外的注解，就是存储的位置，具体来说，就是指存储在内存中还是存储在磁盘上。默认情况下，都有一个默认的存储位置，但是也可以在变量前面添加storage 或 memory 关键字来指定存储的位置。默认情况下，函数的参数，包括返回的参数是存储在内存中的。本地变量和状态变量是存储在磁盘上的。
pragma solidity ^0.4.0;
contract C {
uint[] x; // x 存储在磁盘上
//memoryArray 存在内存中
function f(uint[] memoryArray) {
x = memoryArray; //把内存中的数组memoryArray复制到位于磁盘的x上
var y = x; // 分配一个指针指向x,y同样是存在磁盘上
y[7]; // 返回第8个元素
y.length = 2; // 通过y修改x的长度
delete x; //清除x数组，y也同时被清除
// The fol it would need to create a new temporary /
// unnamed array in storage, but storage is "statically" allocated:
// y = memoryA
// This does not work either, since it would "reset" the pointer, but there
// is no sensible location it could point to.
g(x); // calls g, handing over a reference to x
h(x); // calls h and creates an independent, temporary copy in memory
function g(uint[] storage storageArray) internal {}
function h(uint[] memoryArray) {}
固定长度的字节数组
bytes1, bytes2, bytes3, …, bytes32. byte 是 bytes1的别名.
比较: &=, &, ==, !=, &=, & (返回布尔型)
位运算: &, |, ^ (按位异或), ~ (按位取反)
索引访问: 如果x 是 bytesI类型的, 那么x[k] ，0 &= k & I
返回第 k 位字节.
.length返回数组的长度
contract fix_byte2_1 {
bytes2 public b2=”zx”;
bytes3 public b3=”abc”;
event fet(byte bt);
function fix_byte2_1(){
fet(b3[0]);
fet(b3[1]);
fet(b3[2]);
for(uint i = 0;i &b2. i++){
fet(b2[i]);
动态字节数组
动态长度的字节数组。
动态长度的UTF-8编码的字符串数组。
pragma solidity ^0.4.8;
contract darray{
bytes public b1 = new bytes(200);
bytes2 public b2 = “ab”;
string public str=”hello world !”;
uint public u1 = b1.
uint public u2 = b2.
Fixed Point Numbers
枚举是在Solidity中创建自定义数据类型的一种方式。枚举至少要包含一个成员。
contract test {
enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }
ActionChoices constant defaultChoice = ActionChoices.GoS
function setGoStraight() {
choice = ActionChoices.GoS
//返回值自定转化为uint8类型
function getChoice() returns (ActionChoices) {
function getDefaultChoice() returns (uint) {
return uint(defaultChoice);
//需要强制转换
创建内存数组
使用new关键字创建固定长度的数组。
pragma solidity ^0.4.8;
contract array_1{
function f(uint len){
uint[] memory a = new uint[](2);
b = new bytes(len);
//创建长度动态的字符数组
for(uint i=0;i&b.i++){
b[i] = byte(i);
contract array_2{
uint[3] public u3;
function f(){
g([uint(1),2,3]);
function g(uint[3] _data){
Solidity可以定义结构类型的变量，如下：
pragma solidity ^0.4.0;
contract structs_demo{
struct Funder{
mapping (uint =& Funder)
uint public numF
event e(address _addr,uint _u);
function newFunder(address _addr,uint _amount) returns(uint _funderID){
funders[numFunder] = Funder(_addr,_amount);
function setFunder(uint _u) payable{
Funder f = funders[_u];
f.amount +=msg.
e(f.addr,f.amount);
Mapping类型被定义成如mapping _KeyType =& _ValueType一样，KeyType 和ValueType 可以是任何类型，其中ValueType 甚至也可以是Mapping类型。
delete a，把a的值的设置为它类型的初始值，如整形，则a=0.
来自：http://solidity.readthedocs.io/en/develop/types.html
block.blockhash(uint blockNumber) returns (bytes32) ：给定区块的hash值，只有最新的256个区块有效。
block.coinbase (address)：当前区块矿工的地址。
block.difficulty (uint): 当前区块难度
block.gaslimit (uint): 当前区块gas限制
block.number (uint): 当前区块数量
block.timestamp (uint): 当前区块时间戳
msg.data (bytes): 完成的调用数据
msg.gas (uint): 剩余的gas
msg.sender (address): 消息的发送者
msg.value (uint): 和消息一起发生的以太币数量，单位wei
now (uint): 当前区块时间戳 (block.timestamp的别名)
tx.gasprice (uint): 交易的gas价格
tx.origin (address): 交易的发起者
keccak256(…) returns (bytes32):计算括号里的参数的Keccak-256哈希值
sha3(…) returns (bytes32): keccak256()的别名
sha256(…) returns (bytes32): 计算括号里的参数的SHA-256哈希值
ripemd160(…) returns (bytes20):计算括号里的参数的 RIPEMD-160 哈希值
ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s): 使用公钥从签名中恢复地址
addmod(uint x, uint y, uint k) returns (uint): 计算(x + y) % k
mulmod(uint x, uint y, uint k) returns (uint): 计算(x * y) % k
this (当前合约类型): 当前合约，显示转换成address
super: 当前合约父合约
selfdestruct(address recipient): 销毁当前合约，把钱发送到给定的地址
&address&.balance (uint256): 账户的金额，单位 wei
&address&.send(uint256 amount) returns (bool): 发送以太币（wei）到指定的地址
大多数流程语句和JavaScript或C语言一样，除了switch 和goto 。因此有if, else, while, for, break, continue, return, ? :，用法也和JavaScript 或C一样。
请注意，一个非布尔型的值是不会被转换成布尔型的，所以if (1) { … }在Solidity是不能使用的。
内部函数调用
当前合约的函数可以在内部被调用，也可以被递归，就像下面的这毫无意义的列子：
外部函数调用
表达式this.g(8); 和c.g(2)（g是当前合约的实例）也是一个有效的函数，但这次，他们称为外部函数，和一个消息一起调用，不是被直接的传进EVM。请注意在构造函数中不能使用this ，因为这时候合约还没被真正的创建出来。
其他合约的方法都必须在外部调用，当一个外部方法被调用时，它的参数会拷贝进内存。
当调用其他合约的方法时，以wei为单位的金额一起被发生，并可以指定gas：
这修饰符payable 必须用在info函数上，不然，我们在调用.value(10).gas(800)()的时候就不能发生以太币给它。
注意，表达式InfoFeed(addr)做了一个显示的转换，这是一开始我们就知道，在给定地址上的合约的类型就是InfoFeed，并且它没有执行构造函数。千万不要在一个你不知道类型的合约上调用一个方法。
我们也可以直接使用function setFeed(InfoFeed _feed) { feed = _ }，调用.value(10).gas(800)要小心，只传递value和gas的数量给这函数，并且要在后面加“()”才会被真的调用。
命名调用和匿名函数参数
函数可以通过名字来调用参数，参数的顺序可以任意。参数可以被放在{ }里面，如下面列子所示。方法会根据参数的名字来调用具体的参数。
省略函数参数名字
未使用的参数（特别是被返回的参数）可以被省略。这些参数仍然会出现在堆栈上,但它们无法被访问。
使用new创建新合约
可以使用 new 关键字来创建新合约。
如列子所示，新建合约的时候可以传递以太币，但是它不能限制gas的多少。如果创建失败，则会抛出异常。
重构赋值和返回多个值
Solidity内部允许数组类型，如一个不同类型对象的列表，它的大小在编译的时候一直不变。这些数组可以同时定义不同的值，并且把这些值赋给多个变量。
数组和结构
给没有值类型的，如数组和结构赋值是有点赋值的。给一个状态变量赋值总是会独立的创建一个副本。在另一方面，给本地变量赋值，只有基本类型的变量才会独立的创建一个副本，如，静态变量适合32位字节。如果数组或结构要被赋予一个状态变量对应一个本地变量，那么这本地变量保存了一个对原始状态变量的引用。对本地变量进行第二次赋值，不会改变状态变量，但会改变这引用。
作用域和声明
每一个变量都一个初始的默认值。如，bool型的默认值是false。uint 或int 的默认值是0。对于静态数组，从bytes1 到bytes32，每一个元素都会有一个和它的类型相关的初始值。最后，对于动态数组，bytes 和string，这默认值是个空数组或空的字符串。
在函数内部定义的变量将作用于整个函数内部，无论在哪声明。这是因为Solidity 内部继承了来自JavaScript的作用域规则。因此，下图所示的语法是错误的，将会在编译的时候抛出错误：Identifier already declared。
另外，如果一个变量被定义，那么这变量会在函数的最开始处被赋予这变量类型的默认值。如下，下面的代码的是合法，虽然写法比较槽糕。
在有一些情况下，会导致异常自动被抛出（见下面）。你可以使用throw 指令手动的抛出一个异常。异常的作用是当前执行的调用被停止并且恢复（如，所有的状态变化和余额的变动都会被撤销）。
现在还不能捕获异常。
在下面的例子中，我们使用throw指令来恢复一个以太币交易。
当前，有几种情况会使Solidity自动的抛出异常：
如果你访问一个数组，索引为负数，或不存在（x[i] ，其中i &= x.length 或i & 0）。
访问一个固定长度的bytesN ，索引为负数，或不存在（x[i] ，其中i &= x.length 或i & 0）。
通过一个消息来调用函数，并且没有正确的执行完（如，gas不足，或没有合适的函数，或本身可能抛出异常）。
如果你使用new 关键字创建合约，但这创建操作没有正确的执行完。
如果被除数是 0 （如：5 / 0 或 23 % 0）
针对一个没有代码的合约，调用外部函数方法。
如果你的合约通过一个没有payable 修改器的公共方法来接收以太币（包括构造方法和回调方法）。
如果你的合约通过一个公共的访问方法来接收以太币。
如果操作码有参数（始终来自栈顶），参数放在圆括号内。下面列表中，带有“-”标示的表示不会把一个数据压入栈顶，带“*”是专用的，其他没有标示的表示会把一个合适的数据压入栈顶。
下面，mem[a…b)表示从a开始一直到b,包含a,但不包含b。storage[p]表示存储的内容在索引p的位置上。
pushi 和jumpdest 不能被直接使用。
停止执行，全部返回(0,0)
x – y
sdiv(x, y)
x / y, 二进制补码的带符号的数字
x % y 二进制补码的带符号的数字
smod(x, y)
x % y, 二进制补码的带符号的数字
~x, every bit of x is negated
如果x&y，返回1，不然0
如果x&y，返回1，不然0
1 if x & y, 0 otherwise, for signed numbers in two’s complement
1 if x & y, 0 otherwise, for signed numbers in two’s complement
1 if x == y, 0 otherwise
1 if x == 0, 0 otherwise
bitwise and of x and y
bitwise or of x and y
bitwise xor of x and y
byte(n, x)
nth byte of x, where the most significant byte is the 0th byte
addmod(x, y, m)
(x + y) % m with arbitrary precision arithmetics
mulmod(x, y, m)
(x * y) % m with arbitrary precision arithmetics
signextend(i, x)
sign extend from (i*8+7)th bit counting from least significant
sha3(p, n)
keccak(mem[p…(p+n)))
jump(label)
jump to label / code position
jumpi(label, cond)
jump to label if cond is nonzero
current position in code
remove the element pushed by x
dup1 … dup16
copy ith stack slot to the top (counting from top)
swap1 … swap16
swap topmost and ith stack slot below it
mem[p..(p+32))
mstore(p, v)
mem[p..(p+32)) := v
mstore8(p, v)
mem[p] := v & 0xff – only modifies a single byte
storage[p]
sstore(p, v)
storage[p] := v
size of memory, i.e. largest accessed memory index
gas still available to execution
address of the current contract / execution context
balance(a)
wei balance at address a
call sender (excluding delegatecall)
wei sent together with the current call
calldataload(p)
calldata starting from position p (32 bytes)
calldatasize
size of calldata in bytes
calldatacopy(t, f, s)
copy s bytes from calldata at position f to mem at position t
size of the code of the current contract / execution context
codecopy(t, f, s)
copy s bytes from code at position f to mem at position t
extcodesize(a)
size of the code at address a
extcodecopy(a, t, f, s)
like codecopy(t, f, s) but take code at address a
create(v, p, s)
create new contract with code mem[p..(p+s)) and send v wei and return the new address
call(g, a, v, in, insize, out, outsize)
call contract at address a with input mem[in..(in+insize)) providing g gas and v wei and output area mem[out..(out+outsize)) returning 0 on error (eg. out of gas) and 1 on success
callcode(g, a, v, in, insize, out, outsize)
identical to call but only use the code from a and stay in the context of the current contract otherwise
delegatecall(g, a, in, insize, out, outsize)
identical to callcode but also keep caller and callvalue
return(p, s)
end execution, return data mem[p..(p+s))
selfdestruct(a)
end execution, destroy current contract and send funds to a
log0(p, s)
log without topics and data mem[p..(p+s))
log1(p, s, t1)
log with topic t1 and data mem[p..(p+s))
log2(p, s, t1, t2)
log with topics t1, t2 and data mem[p..(p+s))
log3(p, s, t1, t2, t3)
log with topics t1, t2, t3 and data mem[p..(p+s))
log4(p, s, t1, t2, t3, t4)
log with topics t1, t2, t3, t4 and data mem[p..(p+s))
transaction sender
gas price of the transaction
blockhash(b)
hash of block nr b – only for last 256 blocks excluding current
current mining beneficiary
timestamp of the current block in seconds since the epoch
current block number
difficulty
difficulty of the current block
block gas limit of the current block
访问外部变量和方法
Solidityd 的变量和其他标示可以使用它们自己的名字来访问。存储和内存变量会把他们的内存地址压入堆栈。注意，非结构和非数组的存储变量会在堆栈中占据2个位置，一个是内存地址，一个是占用内存的大小。
http://solidity.readthedocs.io/en/develop/control-structures.html#literals
合约在Solidity 中类似面向对象语言。每一个合约都包含了状态变量, 函数, 函数修饰符, 事件, 结构体，类型 和枚举类型.
状态变量会永远存储在合约里
pragma solidity ^0.4.0;
contract SimpleStorage {
uint storedData; // State variable
在合约中函数是一段可执行的代码单元
pragma solidity ^0.4.0;
contract SimpleAuction {
function bid() payable { // Function
函数修饰器
函数修饰器可以用一种声明的方式修改函数的语义。
pragma solidity ^0.4.0;
contract Purchase {
address public seller;
modifier onlySeller() { // Modifier
if (msg.sender != seller) throw;
function abort() onlySeller { // Modifier usage
通过虚拟机的日志功能，事件可以很方便的被调用
pragma solidity ^0.4.0;
contract SimpleAuction {
event HighestBidIncreased(address bidder, uint amount); // Event
function bid() payable {
HighestBidIncreased(msg.sender, msg.value); // Triggering event
结构体类型
一个自定义的类型，可以把几个变量组织到一起。
pragma solidity ^0.4.0;
contract Ballot {
struct Voter { // Struct
uint weight;
bool voted;
address delegate;
uint vote;
pragma solidity ^0.4.0;
contract Purchase {
enum State { Created, Locked, Inactive } // Enum
阿拉伯人 is Stephen Fry proof thanks to caching by