Solidity基础

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

}

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就好了
}

//匿名函数
pragma solidity ^0.4.0;

contract C1{
uint public data;

event e(address from ,uint _u );
function () payable {
data+=1
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
}
}
}
}

pragma solidity ^0.4.0;

//定义一个合约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(4)//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())//得到后面的两个值出来，打印出来

}
}

pragma solidity ^0.4.0;

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

}

}

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

}
}


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

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

pragma solidity ^0.4.0;

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

结构：structs
pragma solidity ^0.4.0;

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

pragma solidity ^0.4.0;
contract DeleteDemo {
    uint public data = 100;
    uint[] public dataArray = [uint(1),2,3];
    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);
    }
}

pragma solidity ^0.4.0;

//注明一下，在这个合约里面定义了两个变量，一个是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
}
}
}

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

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

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