solidity基础(3)

9. solidity的自定义结构体深入详解
   结构体，solidity中的自定义类型，我们可以使用关键字struct来进行自定义，结构体内可以包含字符串，整型等基本数据类型，以及数组，映射，结构体等复杂类型。数组，映射，结构体也支持自定义的结构体：

    pragma solidity ^0.4.18;
    contract SmpleStruct {
      struct student {
        string name;
        int num;
        //student a; error
        student[] students;
        mapping(string => string)index;
      }
   
      struct Class {
        string className;
        //学生列表
        student[] students;
        mapping(string => string)index;
      }
    }
   

   1. 结构体定义的限制
      不能在结构体中定义一个自己作为类型，这样限制原因是，自定义类型的大小不允许是无限的，但是我们仍然能在类型内用数组，映射来引用当前定义的类型

   2. 初始化
      在初始化时，需要忽略映射类型

      1. 直接初始化
         如果声明的结构体类型为A,可以使用A(变量1，变量2，...)的方式来完成初始化，用法和go语言中的struct类似
      2. 命名初始化
         还可以使用类似JavaScript的命名参数初始化额方式，通过传入参数名和对应值的对象，这样做的好处在于可以好处在于可以不按定义的顺序传入值
      3. 结构体中映射的初始化
         由于映射是一种特殊的数据结构
         参考资料
         只能在storage变量中使用,这里的storage为状态变量，如果尝试对memory的映射赋值，则会报错
         [图片上传失败...(image-7f3e2-1540205314127)]

   3. 结构体的可见性
      当前只支持internal的，后续不排除开发这个限制
      参考资料

      • 继承中使用
        结构体由于不对外可见的，所以只可以在当前合约或继承的子合约中使用，但包含定义结构体的函数均需声明为internal的

   4. 跨合约的临时解决方案
      手动的将要返回的结构体拆解为基本类型进行返回

        pragma solidity ^0.4.18;
        contract TestA {
          struct A {string para1;int para2}
          function call(B b) internal {
            A memory a = A("test",1);
            b.g(a.para1,a.para2);
          }
        }
      
        contract TestB {
          function g(string s,int i) public {
            //要实现的内容
          }
        }
      

10. solidity的映射类型深入详解
    映射是一种引用类型，存储键值对，提供根据键查找值，与其他语言的字典，map等类似，但也有非常大的不同，尤其它在区块链中独特的储存模型

    1. 只能是状态变量
       由于在映射中键的数量是任意的，导致映射的大小也是变长的。映射只能声明为storage的状态变量 ，或被赋值给一个storage的对象引用：

       pragma solidity ^0.4.18;
       contract Test {
         mapping(uint =>uint) stateVar;
         function fTest() public returns(uint) {
           //mapping(uint => uint) memory memVar;
           //TypeError:只能为数组或结构体类型指定内存
           //mapping(uint =>uint) b;
           //TypeError:未被初始化，映射只能分配给状态变量
           mapping(uint =>uint) b = stateVar;
           //可以被赋值为storage的引用
         }
       }
       

    2. 支持的类型
       映射类型的键支持除映射，变长数组，合约，枚举，结构体以外的任意类型。值则允许任意类型，甚至是映射

    3. setter方法
       对于映射类型，也能标记为public，以让solidity自动生成访问器

       pragma solidity ^0.4.18;
       contract Test{
         mapping(uint => uint) public a;
         mapping(uint => mapping(uint => string)) b;
         //需要注意的是public不能不写，不然不会自动生成访问器
         function set() {
           a[1] = 1;
           b[1][1] = "aaa";
         }
       }
       

    4. 映射的储存模型
       由于状态变量是储存在区块链上的，所以储存空间需要预先分配，但映射的储存值是可以动态增改的，那么最终是如何支持的呢？
       关于状态的储存模型中提到，实际储存时是以哈希键值对的方式。其中哈希是由键值和映射的储存槽位序号拼接后计算的哈希值(映射只占一个槽位序号)，也就是说值是存到由keccak256(k . p)计算的哈希串里，这里的k表示的是映射要查找的键，p表示映射在整个合约中相对序号位置
       这里没有看明白，所以附上原文链接，如果想看的可以看一下原文链接

    5. 与其他语言映射的不同
       由于映射的储存模型决定了，映射实际不存在一个映射的键大小，没有一个键集合的概念，但是可以通过扩展默认映射来实现这样的功能
       官方提供的映射扩展示例

11. solidity的delete深入详解
    solidity中有个特殊的操作符delete用于释放空间，因为区块链作为一个公用资源，为避免大家滥用，且鼓励主动对空间的回收，释放空间将会返还一些gas
delete关键字的作用是对某个类型值a赋予初始值。比如如果删除整数delete a等同于a = 0

    1. 删除基本类型
       • 对于基本类型，如
         ：bool,uint,address,bytes,string，使用delete会设置成对应的初始值，bool类型是false，变长字节数组是0x0，string则是空串

    • 删除枚举
      删除枚举类型时，会将其值重置为序号为0的值

        pragma solidity ^0.4.18;
        contract DeleteEnum {
          eum Lignt{red,green,yellow}
          Light light;
          function f() returns(Light) {
            light = Light.green;//此时light=1
            delete light;//此时light=0
            return light;
          }
        }
      

    • 删除函数
      函数不可以删除，会报错

    2. 删除复杂类型

       • 删除结构体
         删除一个结构体，会将其中的所有成员一一置为初值

       • 删除映射
         映射是一个特殊的存在，由于映射的键并不总是能有效遍历(数据结构没有提供接口，也并不总是需要关心所有键是什么)，所存的键的数量往往是非常大的，所以我们并不能删除一个映射，但是我们可以指定键来删除映射中的某一项

           mapping(address => uint) map;
           map[msg.sender] = 100;
           delete map[msg.sender];
         

       • 删除结构体中的映射
         
         如果删除一个结构体时，其中含有映射类型，会跳过映射类型

    3. 删除数组
    • 删除整个数组
      对于定长数组，删除时，是将数组内所有元素置为初值，而对于变长数组时，则是将长度置为0
    • 删除数组的一个元素
      我们也可以删除数组的一个元素，这里需要注意的是，删除一个元素并不会改变数组长度，即和删除其他类型一样，都是赋类型的零值,并不会移动元素

    4. gas使用的考虑

       • gas相关
         上文中，我们了解到，删除时会忽略映射，以及数组的某个元素被删除后，并不会自动整理数组。这些看起来很不符合常理，其实是基于对gas限制的考虑。因为如果映射或数组非常大的情况下，删除或维护它们将变得非常消耗gas
         不过，清理空间，可以获得gas的返还，但无特别意义的数组的整理和删除，只会消耗更多gas，需要在业务实现上进行权衡

       • 清理的最佳实践
         由于本身并未提供对映射这样的大对象的清理，所有储存并遍历它们来清理，显得特别消耗gas，一种实践就是能复用就复用，一般不主动清理，下面是一个数组的插入实现，比如增加一个计数器，直接忽略已使用过的位置：

         uint numElements = 0;
         uint[] arrary;
         function insert(uint value) {
           if(numElements == arrary.length) {
             arrary.length += 1;
           }
           //需要注意的是，solidity中也有前自增和后自增的区别
           arrary[numElements++] = value;
         }
         
         function clear() {
           numElements = 0;
         }
         

       上面的例子中，我们在数组新增时，直接忽略已使用过的槽位。而在代码内，我们使用numElements来代替arrary.length，以获取当前数组所在的位置。
       如果这种大对象是在某个事件发生时，一次性使用，然后需要回收。一个更更有效的方式是，在发生某个事件时，创建一个新合约，在新合约完成逻辑，完成后，让合约suicide。清理合约占用空间返还的gas就退还给了调用者，来节省主动遍历消除的额外gas。

    5. 删除的注意事项
       删除的本质是对一个变量置其类型的零值,所以我们删除storage的引用时会报错

       pragma solidity ^0.4.18;
       contract Test {
         struct S{}
         S s;
         function fTest() {
           S storage storageVar = s;
           //delete storageVar;
           //Error:一元运算符不能应用于删除储存指针
           delete s;
         }
       }
       

    删除storageVar会报错

    6. 参考资料
       delte语法介绍
       
       

12. solidity中的基本类型转换

    1. 隐式转换
       如果一个运算符能支持不同类型，编译器会隐式的尝试将一个操作数的类型，转为另一个操作数的类型，赋值同理。
       一般来说，值类型间的互换只要不丢失信息，语义可通则可转换，如：

       pragma solidity ^0.4.18;
       contract Test {
         function conversion() public returns(uint16) {
           uint8 a = 1;
           //隐式转换
           uint16 b = a;
           return b;
         }
       }
       

    另外，无符号整数可以被转换为同样，或更大的字节类型，由于address是20字节大小，所以它与int160大小是一样的，所以也可以转换的

    2. 显示转换
       编译器不会将语法上不可转换的类型进行隐式转换,此时需要强转，如：int8 a =1;uint16 b =uint16(a);
    3. 类型推断:var
       如：var i = 0;，通过类型推断，i的实际类型为uint8,而且后续不会改变，即在第一次类型推断之后，该变量的类型就已经确定了
    4. 一些常见的转换方案

       • uint转为bytes
         将一个uint转换为bytes，可以使用assembly

         function toBytes(uint256 x) public returns(bytes b) {
           b = new bytes(32);
           assembly{mstore(add(b,32),x)}
         }
         

       我试了一下，貌似只能转换为32位的，可能不对，望见谅

       • string转为bytes
         string可以显示的转为bytes，但如果要转为bytes32,可能只能使用assembly,字符串转为bytes

         pragma solidity ^0.4.18;
         contract stringTobytes{
           function sTb1(string memory source) returns(bytes result) {
             return bytes(source);
           }
           //要记住，字符串是UTF8，所以在将它们转换为字节后，每个字节不一定是字符
           function sTb2(string memory source) returns(bytes32 result) {
             assembly{
               result := mload(add(source,32))
             }
           }
         }
         

13. solidity变量的声明及作用域
    solidity中的作用域规则同于Javascript
    题外话【补遗】：
    值类型:储存值的变量；引用类型：储存地址的变量，通俗来说：“值类型是现金，引用类型是存折”。链接

    1. 声明及默认值
       变量声明后均有一个初值，是对应类型的“零态”，即对应的类型的字节表示的全0，使用中需要特别小心的是这与其他语言的默认值如null或undefined有所不同，因为有时0也是一种业务值

    2. 引用类型的初始化
       对于值类型，声明变量后，即赋值为默认值，可正常使用。而对于引用类型是否仍需同其它语言一样进行显式初始化，进行内存分配，才能进一步使用呢，我们来分别看一下。

       1. 动态数组
          对于数组，声明后，仍需分配内存后访问，下面的代码会报越界错误

           pragma solidity ^0.4.18;
           contract inital{
               function f() returns(byte,uint8){
               bytes memory bs;
               uint[] memory arr;
               return (bs[0],arr[0]);
             }
           }
          

       需要主动分配内存，进行初始化

         pragma solidity ^0.4.18;
         contract Arraryinitalok {
           function f() returns(bytes1,uint8) {
             bytes memory bs = new bytes(1);
             uint8[] memory arr = new uint8[](1);
             return (bs[0],arr[0]);
           }
         }
       

       上述代码通过new关键字进行了内存分配，现在即可正常访问第一个数组元素了

       2. 映射
          映射的声明后，不用显式初始化即可使用，只是里面不会有任何值，[回顾]：映射只能是状态变量或者是storage对象的引用
       3. 枚举
          枚举类型不用显示初始化，默认值将为0，即顺位第一值，枚举也只能是状态变量
       4. 结构体
          结构体声明后，不用显式初始化即可使用。当没有显式初始化时，其成员值均为默认值。
       5. delete操作符，具体可以看上文

    3. 作用域
       变量无论在函数内什么位置定义，其作用域均为整个函数，而非大多数据语言常见的块级作用域
       下面的例子会报错,重复定义

         pragma solidity ^0.4.18;
         contract scopeErr {
           function f() {
             {uint8 a = 0;}
             //{uint8 a = 1;}
           }
         }
       

    我们来看一个稍微隐蔽点的例子

        pragma solidity ^0.4.18;
        contract Test {
          function fTest() returns(uint8) {
            for(var i=0;i<10;i++) {
              //do sth
            }
            return i;
          }
        }
    

    学过其他语言的，会认为这样是会报错的，但是在solidity中，无论变量在函数中任意位置定义，整个函数都是可以访问的，所以i变量虽然是在for循环中被定义，但它的的作用域仍是整个函数，所以在函数内的任何位置均可以访问到这个变量
    我们来看一个更加极端的例子

        pragma solidity ^0.4.18;
        contract Test {
          function f() returns(uint8){
            if (false) {
              uint8 a =10;
            }
            return a;
          }
        }
    

    上述的代码中，虽然变量的声明看似没有执行到，但是由于变量作用域是整个函数，且由于第一部分讲到，任何变量声明后均有其默认值。故上例中将返回默认值0
    
    

14. solidity的getter访问器
    对于所有public的状态变量(回顾:只有struct是强制internal)，solidity语言编译器，提供了自动为状态变量(定义在函数外部)生成对应的getter访问器的特性，暂不支持setter(因为不能很好控制访问权限的改值函数，不一定实用)
    状态变量所创建的访问器函数，与变量同名。以internal访问时，按状态变量的方式使用，若以external的方式访问时，则需要通过访问器函数

    pragma solidty ^0.4.18;
    contract Test{
      uint public data = 10;
      function f() returns(uint,uint) {
        //分别以internal，external的方式访问
        return (data,this.data())
      }
    }
    
    contract test {
      //注意外部合约调用时，必须要先初始创建合约，不然不能访问
      Test t = new Test();
      function f() returns(address,uint) {
        return (t,t.data());
      }
    }
    

    上面的例子中，编译器会自动生成data()函数，在合约内我们可以直接以internal的方式访问data状态变量，但是在合约外我们只能用data()的方式来访问，因为访问器函数的可见性是external

    1. 枚举
       枚举的访问器与基本类型类似，均是生成与状态变量同名的函数

       pragma solidity ^0.4.18;
       contract Test {
         enum Color{red,green,yellow}
         Color public color = Color.green;
         function f() returns(Color,Color) {
           return (color,this.color());
         }
       }
       

    2. 数组
       前面的访问器函数，是一个与状态变量同名的无参函数。那么访问器一定是无参的吗，其实不然，对于数组，我们必须提供序号来使用访问器，下面我们来看一个数组的访问器示例：

       pragma solidity ^0.4.18;
       contract ArraryGetter{
         uint[] public arr = new uint[](1);
         function f() returns(uint,uint) {
           return (arr[0],this.arr(0));
         }
       }
       

    我们可以发现，对于数组访问器的使用，需要增加序号值作为参数，如果不传序号值，会报错

    3. 映射
       对于映射类型，它的访问器也是有参数的，参数为映射定义的键类型。我们来看一下映射的访问器示例：

       pragma solidity ^0.4.18;
       contract MappingGetter {
         mapping(uint => uint) public data;
         function f() returns(uint,uint) {
           data[25] = 100;
           return (data[25],this.data(25));
         }
       }
       

    
    回顾，映射类型只能定义为状态变量或storage变量的引用，映射也是可变长的

    4. 结构体
       结构体的访问器也是同名的函数，访问器返回结果是结构体中的每个变量

       pragma solidity ^0.4.18;
       contract Test{
         struct S {
           uint a;
           string b;
           bytes32 c;
         }
         S public s = S(10,"hello",hex"1234");
         function f() returns (uint,bytes32) {
           var(a,b,c) = this.s();
           return (a,c);
         }
       }
       

    通过上例，我们可以看出，结构体的访问器分别返回了s中的a,b,c三个变量值，但由于solidity不支持通过external的访问变长内容，故上面的代码，通过f()不能返回b的值，会报错，但是通过Remix，则可以访问到结构体中的所有变量值

    5. 一个复杂的例子
       下面是一个集合结构体，数组，映射的一个复杂例子，但访问器访问方式遵循前述的规则：

       pragma solidity ^0.4.18;
       contract Complex {
         struct Data {
           uint a;
           bytes3 b;
           mapping(uint => uint) map;
         }
         mapping(uint => mapping(bool =>Data[])) public data;
         Data[] internal arr;
         function f() returns(uint,bytes3) {
           //初始化时跳过mapping类型
           Data memory d = Data(1,0x123);
           arr.push(d);
           data[0][true] = arr;
           return this.data(0,true,0);
         }
       }
       

    上面代码中，data状态变量的访问器，有三个参数。第一个参数是第一层映射的键uint,第二个参数是映射内嵌映射的键类型bool，由于两层映射最终映射到的是数组。故而，第三个参数是数组的序号值，访问器返回的类型是结构体类型Data，所以上述代码将返回1,0x000123
    需要注意的是，访问器返回结果结构体内的映射map，由于访问器没有较好的方式来提供访问，所以直接被忽略