函数重载是指函数命名相同的函数,但需要满足以下两个条件之一
注意:address类型 与uint160 类型相同,若重载函数参数是两个类型则会报错
pragma solidity ^0.4.0;
//函数的重载
//1 函数的名字相同 2函数的 参数(类型 数量)不同 3.返回的值类型不同不能被重载
//注意uint160 与address
contract chongzai{
function fun(uint num) view public returns(uint){
}
function fun(uint8 num) view public returns(uint){
}
uint public a = 1;
function test1(uint num){
a=100;
}
function test1(uint8 num)
{
a=200;
}
function test()
{
test1(288);
}
}
函数入参有两种方式
pragma solidity ^0.4.0;
contract funcParam{
uint public num;
string public name;
function setParam(uint _num,string _name) view public{
num = _num;
name = _name;
}
function test()
{
setParam(10,"waston");
}
function test2(){
setParam({_name:"万事通",_num:100});
}
}
pragma solidity ^0.4.0;
contract funReturn{
function returnTest() view public returns(uint mul)
{
uint a = 10;
return a;
}
function returnTest2() view public returns(uint mul)
{
mul=100;
}
function returnTest3() view public returns(uint mul)
{
mul=100;
uint a = 10;
return a;
}
function returnTest4(uint a,uint b) view public returns(uint add,uint mul)
{
add = a+b;
mul=a*b;
}
function returnTest5(uint a,uint b) view public returns(uint add,uint mul)
{
return (a+b,a*b);
}
function returnTest7(uint a,uint b) view public returns(uint add,uint mul)
{
return (10,20);
}
function returnTest8(uint a,uint b) view public returns(uint a1,uint a2)
{
return (b,a);
}
}
pragma solidity ^0.4.0;
contract modifireTest{
address public owner;
uint public num=0;
//把合约的部署着地址存储再owner变量中
constructor (){
owner = msg.sender;
}
//定义modifire
modifier onlyOwner{
//判断
require(msg.sender==owner);
_; //动态添加
}
//附加上了modifire 先执行了 require(msg.sender==owner); 判断了我们合约的调用者是否等于合约的拥有者 如果成立则会执行下面的语句
//否则就会回滚报错
function changeIt(uint _num) onlyOwner{
num = _num;
}
}
pragma solidity ^0.4.0;
contract mappingTest{
//账户ID
mapping(address =>uint) idMapping;
mapping(uint => string) nameMapping;
uint public sum= 0;
//用户只能注册一次
modifier control{
require(idMapping[msg.sender]==0);
_;
}
function register(string name) control
{
//获取到当前合约的调用者
address account = msg.sender;
sum++;
//将合约的调用者的地址与注册总量id联系在一起
idMapping[account]=sum;
//将用户id与用户注册的名字绑定在一起
nameMapping[sum] =name;
}
//通过地址获取到id
function getIdByAddress(address are) view public returns(uint)
{
return idMapping[are];
}
//通过id获取到name
function getNameById(uint id) view public returns(string)
{
return nameMapping[id];
}
}
pragma solidity ^0.4.0;
contract modifierTest2{
uint public level = 9;
string public name = "waston";
uint public DNA;
//函数的modifire 可以有参数
modifier contrlLevel(uint needlevel){
require(level>needlevel);
_;
}
//使用modifire 增加代码的重用性 和扩展性
function changeName() contrlLevel(2){
name="万事通";
}
function changeDna() contrlLevel(10){
DNA=999;
}
}
pragma solidity ^0.4.0;
//多重modifire
contract mulModifire{
uint public a = 0;
modifier mod1{
a = 1;
_;
a=2;
}
modifier mod2{
a=3;
_;
a=4;
}
//modifire 的执行顺序a=1 a=100 a=2
//函数中的替代了modifire中的_;
function test1() mod1{
a=100;
}
//执行顺序 a=1 a=3 a=100 a=4 a=2
function test() mod1 mod2{
a=100;
}
}
pragma solidity ^0.4.0;
contract grandFather{
uint public gudong=200;
function zhongdi() public returns (string)
{
return "zhongdi";
}
}
contract father is grandFather{
uint public money =10000;
function dahan() public returns(string){
return "dahan";
}
}
//合约能够被连续的继承
//son这个合约继承了father这个合约
contract son is father{
function getMoney() returns (uint){
//继承了父亲money这个属性
return money;
}
//继承了父亲dahan 这个函数 行为
function test(){
dahan();
}
//继承了爷爷种地这个函数 行为 连续继承
function test2(){
zhongdi();
}
function getGudong() returns(uint){
return gudong;
}
}
pragma solidity ^0.4.0;
//1.如果属性不加上任何的修饰符 是可以被继承的
//2.加上了public属性后也是可以被继承的
//3 internal属性仍然是可以被继承的
//4 external编译报错 没有修饰符
//5 private 编译报错 因为private代表只有父类有这个属性不能被继承
// internal修饰的函数只能够在合约的内部或者继承的合约的内部使用 但是不能够在合约的外部使用
// external修饰的函函数不能够在内部调用 也不能在继承的合约内部调佣
contract father {
uint money=10000;
// uint public money=10000;
// uint external money=10000;
// uint private money = 10000;
function dahan() external returns (string)
{
return "dahan";
}
//间接的在内部调用只能使用this指针
function dahanTest() public view {
this.dahan();
}
}
//external修饰的函数调用的第二种方式在另一个合约内创建或引用合约的“地址”来使用
contract externalTest{
father f = new father();
function externalTestIt() returns(string)
{
return f.dahan();
}
}
contract son is father{
// function getMoney() public view returns (uint)
// {
// return money;
// }
// function test() public view returns (string){
// return dahan();
// }
}
1 private不能够被继承 也不能在外部被调用 可以在内部被调用(所有的修饰符都这个)
2 internal 不能在外部被调用 可以被继承
3 external不能够在内部被调用 只能够在外部调用 可以被继承 如果强行调用 通过“地址。”
4 public 权限最大 可以在外部内部调用可以被继承
5 pure 不会读取全局变量 更不会修改全局变量 一个固定的输入 就会有一个固定的输出
6 constant 在函数中 和view相同 ,在全局变量中 致用户bytes1-bytes32 uint int string 代表数据不能被修改
7 view 只读取全局变量的值 不能修改他 不消耗gas
8 payable转账的时候必须要加的关键字
9 命名参数 {value:2,name:'wastoner'}
10 函数可以有多个返回值