solidity基础_2

最新推荐文章于 2024-07-14 13:23:23 发布

一只乌龟7

最新推荐文章于 2024-07-14 13:23:23 发布

阅读量117

点赞数 2

文章标签：区块链

本文链接：https://blog.csdn.net/Shuzi_master7/article/details/140398825

版权

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract Payable {
    // address + payable can pay ETH
    address payable public owner;

    constructor(){
        owner = payable(msg.sender);
    }
    // function + payable can receive ETH
    function deposit() external payable{

    }

    function getBalance() external view returns (uint){
        return address(this).balance;
    }
}
//Un_

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract CallTestContract {
    (address , parameters)
    //Constract + ( address ).function( )
    function func_1(address _test,uint _x) external {
        TestConTract(_test).setX(_x);
    }

    //Constract address, 
    //address.function()
    /* equals to
    function func_1(TestConTract address _test,uint _x) external {
        _test.setX(_x);
    }
    */

    function func_2(address _test) external view returns (uint){
        uint x = TestConTract(_test).getX();
        return x;//have or not dousen;t matter
    }
    
    function func_3(address _test,uint _x) external payable {
        TestConTract(_test).setXandReceiveEther{value:msg.value}(_x);
    }//if you want to pass value {value:msg.value}
    // send Ether along with the function call. 

    function func_4(address _test) external view returns (uint x,uint value){
        (uint x,uint value) = TestConTract(_test).getXandValue();
        return (x,value);//have or not dousen;t matter
    }
}

contract TestConTract {
    uint public x;
    uint public value = 123;

    function setX(uint _x) external {
        x = _x;
    }

    function getX() external view returns (uint) {
        return x;
    }

    function setXandReceiveEther(uint _x) external payable {
        x = _x;
        value = msg.value;//the value changed
    }

    function getXandValue() external view returns (uint,uint){
        return (x,value);
    }

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract Imuutable {
    //can't be changed reduce gas
    address public immutable owner;

    constructor(){// set up auto
        owner = msg.sender;
    }

    uint public x;
    function foo() external{
        require(msg.sender == owner);
        x += 1;
        
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/*
calling parent functions
- direct
- super

    E
   / \
  F   G
   \ /
    H

 */

contract E {
    //A memo to record the emit Log("")
    event Log(string message);

    function foo() public virtual {//virtual means can be changed in contract son
        emit Log("E.foo");
    }
    
    function bar() public virtual {
        emit Log("E.bar");
    }
}

contract F is E{
    function foo() public virtual override {//overrride means overlap
        emit Log("F.foo");
        E.foo();//directily use parent's function
    }
    function bar() public virtual override{
        emit Log("F.bar");
        super.bar();//find the father auto
    }
}

contract G is E{
    function foo() public virtual override {
        emit Log("G.foo");
        E.foo();
    }
    function bar() public virtual override{
        emit Log("G.bar");
        super.bar();//find the father auto
    }
}

contract H is F, G {
    function foo() public override(F,G) {// 2 together
        emit Log("H.foo");
        F.foo();

    }
    function bar() public virtual override(F,G) {
        emit Log("H.bar"); // G F E(once)
        super.bar();//both F,G 's .bar() will be excuted
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract S {
    string public name;
    
    constructor(string memory _name) {
        name = _name;
    }
}

contract T {
    string public text;
    //constructor is the things when you deploy should give
    constructor(string memory _text) {
        text = _text;
    }
}

//You have alreay know what the input is
contract U is S("s"),T("t") {

}

//You don't know what the input will be
contract V is S,T {
    constructor(string memory _nam,string memory _tex) S(_nam) T(_tex){
        
    }
}

contract VV is S("s"),T {
    constructor(string memory _tex) T(_tex){
        
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract A {

    //virtual means you can rewrite the function
    function foo() public pure virtual returns (string memory){
        return "A";
    }

    function bar() public pure virtual returns (string memory){
        return "A";
    }

    function baz() public pure virtual returns (string memory){
        return "A";
    }
}

contract B is A {// A is father

    //override means you can cover the father's function
    function foo() public pure override returns (string memory){
        return "B";
    }
    function bar() public pure virtual override  returns (string memory){
        return "B";
    }
}

contract C is B {// B is father

    //override means you can cover the father's function
    function bar() public pure override  returns (string memory){
        return "C";
    }
}

//Inter_Counter.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract Counter {

    uint public count ;

    function inc() external {
        count += 1;
    }
    function dec() external {
        count -= 1;
    }
}


//Interface.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

//interface in order to give a fucntion in other files into here
interface ICounter {// Interface name start with I

    function count() external view returns (uint);

    function inc() external;

}

contract CallInterface{
    
    uint public count;

    function examples(address _counter) external {
        ICounter(_counter).inc();//pass the address  remember
        count = ICounter(_counter).count();
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract Account {

    address public owner;

    constructor(address _owner) payable {
        owner = _owner;
    }
}

contract AccountFactory {

    Account[] public accounts;

    function createAccount(address _owner) external payable {
        Account account = new Account{value: msg.value}(_owner);//传入主币
        accounts.push(account);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

/*
      X
    / |
   /  |
  Y   |
    \ |
      Z

order :X Y Z
*/
contract X {

    function foo() public pure virtual returns (string memory){
        return "X";
    }
    function bar() public pure virtual returns (string memory){
        return "X";
    }
    function x() public pure returns (string memory){
        return "X";
    }
}

contract Y is X {// this contract Y also have function x()
    function foo() public pure virtual override returns (string memory){
        return "Y";
    }
    function bar() public pure virtual override returns (string memory){
        return "Y";
    }
    function y() public pure returns (string memory){
        return "Y";
    }
}

contract Z is X,Y {
    function foo() public pure override(X,Y) returns (string memory){
        return "Z";
    }
    function bar() public pure virtual override(X,Y) returns (string memory){
        return "Z";
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract Fallback {
    event Log(string func,address sender,uint value,bytes data);
    //if have data it can just feedback
    fallback() external payable {
        emit Log("feedback",msg.sender,msg.value,msg.data);
    }
    //receive can's have msg.data
    receive() external payable {
        emit Log("receive",msg.sender,msg.value,"");
    }
    
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
//39 发送EDH  40
contract SendEther {

    constructor() payable {}

    receive() external payable{}
    
    function semdViaTransfer(address payable _to) external payable {
        _to.transfer(123);
    }//no return

    function sendViaSend(address payable _to) external payable {
        bool sent = _to.send(123);
        require (sent,"send failed");
    }//return bool
    
    function sendViaCall(address payable _to) external payable {
        (bool success, ) = _to.call{value:123}("");
        require(success,"call failed");
    }//consume all gas return bool,data
    
}

contract EthReceiver {

    event Log(uint amount , uint gas);

    receive() external payable {
        emit Log(msg.value,gasleft());//the left of gas
    }

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract TestDelegateCall {
    uint public num;//被委托
    address public sender;
    uint public value;

    function setVars(uint _num) external payable {
        num = _num;
        sender = msg.sender;
        value = msg.value;
    }
}

contract DelegateCall {//委托
    uint public num;//这里被改了
    address public sender;
    uint public value;
    //传入被委托人的地址
    function setVars(address _test, uint _num) external payable {
        (bool success, bytes memory data) = _test.delegatecall(//
            abi.encodeWithSelector(TestDelegateCall(_test).setVars.selector, _num)//
        );//被委托的可以修改委托的值
        require(success, "Delegate call failed");
    }
}