02 基础篇 —引用类型

2 引用类型

不定长字节数组（bytes）

-动态字节数组

-引用类型(表明可以使用 storage 来修饰，进行引用传递，指针的效果) -支持 下标索引 -支持 length 、 push 方法(push会帮助分配空间的) -可以修改 -以十六进制格式赋值: 'h' -> 0x68 -> 104 -格外注意：对于bytes，如果不使用下标访问，那么可以不用先申请空间， 直接赋值即可，或者 直接push

代码：

pragma solidity ^0.4.24 ;
​
contract Test{
//动态字节数组，使用new关键字，分配空间
bytes public name=new bytes(32);
bytes public name1;
function setLength(uint _length)public {
    name.length=_length;
}
​
function getLength(bytes _name)public pure returns(uint){
    return _name.length;
}
   function setName(bytes _name)public {
       name=_name;
       
   } 
   function changeName(bytes1 _name)public{
       name[0]=_name;
   }
      /*
    function changeName1(bytes1 _name)public{
        //为未分配空间，访问下表下标错误
        name1[0]=_name;
    }
    */
function pushTest()public{
    name1.push("a");
}
function setInside()public{
    name="hello";
    name1="hello world";
}

 

 

字符串（string）

-动态尺寸的UTF-8编码字符串，是特殊的可变字节数组 -引用类型 -不支持下标索引 -不支持length、push方法 -可以修改(需通过bytes转换)

-使用下标索引的话，转成bytes类型

代码：

pragma solidity ^0.4.24;
contract String{
    //引⽤用类型;不支持下标索引;不支持length、push⽅方法;可以修改(需通过bytes转换)
    //下表x索引，length都转换成不用bytes来操作
    string public name="steven";
    function nameBytes()constant returns(bytes){
        return bytes(name);
    }
    function nameLength()constant returns(uint){
       //return name.lengh; //z不支持直接使用
       return bytes(name).length;
    }
    function changeName()public{
    name="mark";
 // name[1}="l";不支持直接索引
 bytes(name)[0]="l";
​
}
   function changeLength()public{
       bytes(name).length=10;
   }
     

 

 

数据位置（Data location）

复杂类型，不同于之前 值类型 ，占的空间更大，超过256字节，因为拷贝它们占用更多的空间，如数组(arrays) 和 数据结构(struct) ，他们在Solidity中有一个额外的属性，即数据的存储位置： memory 和 storage 。

​ - 内存（memory）

数据不是永久存在的，存放在内存中，越过作用域后无法访问，等待被回收； 被memory修饰的变量是直接拷贝，即与上述的值类型传递方式相同。

-存储 （storage）

数据永久保存在。 被storage修饰的变量是引用传递，相当于只传地址，新旧两个变量指向同一片内存空间，效率较高，两个变量有关联，修改一个，另外一个同样被修改； 只有引用类型的变量才可以显示的声明为 storage 。

• 状态变量量

状态变量总是stroage类型的，无法更改；

• 局部变量量

默认是storage类型（仅限数据结构或数组，string），但是可以声明为memory类型。

-对于非值的数据类型，比如数组和结构体，赋值的语法比较复杂：

.赋值给一个状态变量总是创建一个完全无关的拷贝；

.赋值给一个局部变量，仅对基本类型，如那些32字节以内的（静态类型（static types）），创建一份完全无关的拷贝；

.如果是数据结构或数组，（包括bytes和string）类型，由状态变量赋值为一个局部变量，局部变量只是持有原始状态变量的一个引用。对于这个局部变量再次赋值，并不会修改这个状态变量，只是修改了引用（局部变量指向了别人）；但是修改这个本地引用变量（局部变量）的成员值，会改变状态变量的值（修改了所引用的状态变量值）localTest()的测试。

代码：

 

pragma solidity ^0.4.24;
​
contract test2{
   //memory:存放在内存中，不是永久存在，超越于作用域后，等待被回收；志值传递
    //storage:数据永久保存，引用传递传递，c效率高
    //状态变量变量总是storage类型；局部变量是storage（仅限数据结构或数组，string），但是可以memory
string public name= 'lily';
uint256 public num = 10;
​
function call1() public {
    setName1(name);
}
//对于引用数据类型，作为函数参数时 默认是memory类型（值传递）
function setName1(string src) private {
//function setName1(string memory src) private {
    num = 100; //num变为100
    bytes(src)[0] = "L";//name还是小写
}
function call2() public {
    setName2(name);
}
    
//如果想引用传递，需要显示指明storage
function setName2(string storage src) private {
        num = 1000;//num为1000
        bytes(src)[0] = "L";//name变成大写
    }
    
//如果局部变量是string，数组，结构体类型数据，默认是storage类型    
 function localTest () public {
    string memory tmp = name;
    bytes(tmp)[0] = "L";//name变大写
} 
​

 

转换（byte1/bytes/string）

pragma solidity ^0.4.24;
contract Transformation{
    //（byte1/bytes/string)相互转换
    
     bytes10 b10 = 0x68656c6c6f776f726c64;     //helloworld
    //bytes bs10 = b10; //⽆无法直接转换
    
  
    bytes public bs10 = new bytes(b10.length);
    
    //1. 固定字节数组转动态字节数组；需要逐一赋值
    function fixedBytesToBytes() public{
        for (uint i = 0; i< b10.length; i++){
            bs10[i] = b10[i];
        }
    }
    //2.string转动态字节数组
    string  greeting = "helloworld";
    bytes public b1;
    function StringToBytes() public {
        b1 = bytes(greeting);
    }
    //3. 动态字节数组转string
    string public str3;
    function BytesToString() public {
        fixedBytesToBytes();
        str3 = string(bs10);
    }
     function FiexBytesToString(){
     //固定字节数组和string无法转换
        //string tmp = string(b10);
    }
    
}

 

数组

-内置数组：string(不定长)、bytes(不定长)、byte1,byte2...(定长)；

-自定义数组：

类型T，长度K的数组定义为T[K]，例如：uint [5] numbers, byte [10] names; 内容可变； 长度不可变，不支持push； 支持length方法。

-不定长数组：

定义格式为T [ ]，例例如：string[ ] names, byte[ ] citys； 内容可以修改； 可以改变长度(仅限storage类型) 支持 length 、 push 方法； memory类型的不定长数组不支持修改长度；

pragma solidity ^0.4.24;
contract C {
    /*
    定长数组
    */
     uint[10] value = [1,2,3,4,5];
     uint public sum;
     
    function getSum()public returns(uint ){
       sum=0;
        for (uint i = 0; i < value.length; i++){
            sum += value[i];
            
        } 
        return sum ;
    }
    function changeValue(){
        value[0] = 2; //内容可修改
        //value.length = 100; //报错，长度不可修改
    }    
    
    //test2:
    //helloworld : 0x68656c6c6f776f726c64
    bytes10 helloworldFixed = 0x68656c6c6f776f726c64;
    byte [10] helloworldDynamic = [byte(0x68), 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64];
    bytes helloworld;
    
    function changeByte() public {
        //helloworldFixed[0] = 0x69; //error
        helloworldDynamic[0] = 0x69; //ok
    }
    
  function getString () public constant returns (string) {
    for (var i = 0; i < helloworldDynamic.length; i++) {
     helloworld.push(helloworldDynamic[i]);//不定长字节数组，没有开辟空间，可以直接赋值或者push 
        }
        
        return string(helloworld);
    }
​

 

结构体

pragma solidity ^0.4.24;
contract StructType{
     //定义结构之后无分号，与枚举⼀致
    struct Student{
        string name;
        uint age;
        uint score;
        string sex;
    }
    Student []public Students;//定义结构体数组
    //看两种赋值方式
    Student public stu1=Student("steven",18,99,"m");
    Student public stu2=Student({name:"mark",age:19,score:90,sex:"w"});
    function assign()public{
        Students.push(stu1);
        Students.push(stu2);
        stu1.name="lily";
    
    }
}

 

字典/映射/哈希（mapping）

-键key的类型允许除映射外的所有类型，如数组，合约，枚举，结构体，值的类型无限制； -无法判断一个mapping中是否包含某个key，因为它认为每一个都存在，不存在的返回0或false； -映射可以被视作为一个哈希表，在映射表中，不存储键的数据，仅存储它的 keccak256 哈希值，用来查找值时使用； -映射类型，仅能用来定义状态变量，或者是在内部函数中作为storage类型的引用。 -不支持length -key不支持string 类型​

pragma solidity ^0.4.24;
​
contract test{
    //id->name
    mapping(uint=>string)id_name;
    constructor ()public{
        //构造函数
        id_name[0x01]="steven";
        id_name[0x02]="lily";
        id_name[0x03]="mark";
}
function getNameById(uint id)public view returns(string){
    string memory name=id_name[id];
    return name;
    }
}

 

引用类型之间的比较