Solidity基础

方法和匿名方法：

funcion name(<parameter types>){public|private|internal|external}[constant][payable][<return types>)]{}

payable代表是可以接受以太币的
方法有如下几种：
external
可以被其他合约调用，也可以使用内部直接调用，如果要调用的话，要用this.f()来进行调用
public
既可以被其他合约调用，也可以被内部直接调用
internal
只能在合约和其他子类合约中使用
private
只能在自己的合约内使用，子类中也不能使用'

pragma solidity ^0.4.;
//定义两个合约
contract C1{
uint public data=;
//下面定义了两个函数
function test(string _s) external returns(bytes32){
//返回的是32位字节类型
return keccak256(_s)//加密函数
}
function test2() public returns(uint){
//定义一个函数，后面是返回什么的类型,这里是不需要传参数进去的
return ;
}

}

contract C2{
//合约2来调用合约1的方法

bytes32 public b32;
uint public u;//定义变量
uint public kdata;//接收c1中的data

C1 c1=new C1();
function test() returns (bytes32){
b32=c1.test("a)//调用c1里面的test方法
return b32
}

function test2(){
b=c1.test2()
return b//return就好了
}

一个合约可以有一个匿名函数，此函数不能有参数，也不能有任何返回值，当我们企图去之执行一个合约上没有的函数的时候，那么合约就会执行这个匿名函数

此外，当合约在只收到以太币的时候，也会调用到这个匿名函数，而且一般情况下只会消耗很少的gas，所以当你接收到以太币的时候，想要操作一些的话，可以尽可能的把你要的操作写到匿名函数里面，因为这样的成本非常低

匿名函数例子：

//匿名函数
pragma solidity ^0.4.;

contract C1{
uint public data;

event e(address from ,uint _u );
function () payable {
data+=
e(msg.sender,data)

}
contract CallC1{
event e(bool _b);
function CallC1() payable{

}

function calltest(address add) returns (bool) {
bool b=add.call(bytes4(keccak256("setmoney")))//add.call调用匿名函数
e(b);
return b
}
}
}
}

new方法：(new)

一个合约是可以通过new关键字来创建另一个合约的

pragma solidity ^0.4.;

//定义一个合约D
contract D{
uint public x;//定义无符号的整数
uint public amount;

function D(uint _a)payable{//D合约里面有两个方法，payable，以太币
x=_a;
amount=msg.value;//接收到了以太币，并且把这个以太币赋值给这个amount，可以得到以太币的数量
}
}

//定义合约E
contract E{
event e(uint x,uint amount);//定义一个事件出来
D d=new D()//D合约传递参数4,创建一个d对象出来，下面直接是取出d的值出来，想到与是给D合约发送以太币
function E(uint _u)payable{//payable是可以支付以太币的情况
e(d.x(),d.amount())//获取到D合约里面的两个值出来
D d1=new D(_u)//通过new方法创建d1合约
e(d1.x().d1.amount())//在打印出d后面参数的值出来

}

function createD(uint _x,uint _amount) {
D d2=(new D).value(_amount)(_x)//当成以太币的数量发送给D合约，相当于是D合约里面msg.value
e(d2.x(),d2.amount())//得到后面的两个值出来，打印出来

}
}

继承：(is)

例子：

pragma solidity ^0.4.;

contract F{
uint internal u=;
function test() returns (uint){
//定义一个函数，返回什么类型的uint
return ;

}

}

//定义一个合约F1
contract F1{
uint public fu;
function F1(uint _u){
fu=_u//赋值操作,fu被赋值_u操作

}
}

//下面子类直接继承父类，is就好了,继承父类F，F1，可以直接去里面的值
contract IsDemo is F,F1(){
uint public c1;//在赋值之前都是已经定义好的
uint public c2;
uint public c3;

function c() {
c1=F.u;
c2=F.test();
c3=F1.fu;
}
}

枚举：(enum)

pragma solidity ^0.4.;

contract Purchase {
    enum State { Created, Locked, Inactive } // 枚举
}

结构：(struct)

结构：structs
pragma solidity ^0.4.;

contract Ballot {
    struct Voter { // 结构
        uint weight;//无符号int类型
        bool voted;//布尔类型
        address delegate;//申明地址，20个字节长度
        uint vote;//无符号整数类型
    }
}

Mappings:映射

delete：初始化原来的值，并不是删除掉

event(string _s,uint _u)//定义事件
uint public x=100//定义一个无符号的数出来
uint[] public xArray=[uint(1),3,5,2,3]//定义一个数组
delete x是把x初始化了，并不是删除掉了,把x变成默认的值,最原始的值

pragma solidity ^0.4.;
contract DeleteDemo {
    uint public data = ;
    uint[] public dataArray = [uint(),,];
    event e(string _str,uint _u);
    event eArr(string _str,uint[] _u);

    function doDelete(){
        uint x = data;
        e("x",x);
        delete x;
        e("after x",x);

        e("data",data);
        delete data;
        e("after data",data);

        uint[] y = dataArray;
        eArr("y",y);
        delete dataArray;
        eArr("after y",y);
    }
}

modifier：修改器

//修改器，有些时候只有合约的创建者才可以执行
//修改器可以用来改变方法的行为，比如在方法正式执行之前，检查方法是否满足条件，如果满足条件，则执行方法，不满足则可以抛出异常

//解释一下 ，这个执行合约的过程，就是说当执行的owner不是设定的原来的时候，就会抛出异常，当时原来的时候，就会执行相对应的方法

pragma solidity ^0.4.;

//注明一下，在这个合约里面定义了两个变量，一个是owner,一个是u，所以可以看到
contract modifyDemo{
address public owner;//声明一个地址账号
uint public u;

function modifyDemo() {
owner=msg.sender//owner为当前消息得发送者,合约的部署者
}

modifier onlyOwner{//注意modifier就是修改器，后面就跟着名称，没有括号得我
//修改器
if (msg.sender!=owner){
throw;//如果当前消息得发送者不等于owner的时候，就抛出异常
}else{
_;//固定写法
}

function set(uint _u) onlyOwner{
u=_u;//符合的时候才会执行下面的方法,在合约页面的u就会被赋值_u，就是传进去的参数_u
}
}
}

selfdestory：自毁

//自毁,当执行之后发现右边不存在这个地址了，已经是销毁这个合约的状态了
pragma  solidity  ^0.4.;

contract   selfdestoryDemo{
    uint  internal  u=;
    function  test()  returns(uint){
        return  ;
    }

    function    selfdestoryDemo()  payable{
        //当执行这个合约的时候，可以向这个合约发送一些以太币
    }
    function  kill(address  add){
        selfdestory(add)
    }
}