用於部署的以太令牌合同的總供應讀數爲零

Question

我試圖編輯此合同，我用以太坊的可靠平臺進行了數十次，並且它始終將總供應中的讀數視爲零。逸岸這裏是它在讀取變量：

1. 名範例令牌字符串
2. totalSupply 0 uint256
3. 小數3 UINT8
4. _totalSupply千萬uint256
5. 率350 uint256
6. 符號SAMP串

我做了不斷的回報總供給，我知道有一個錯誤，但無法弄清楚在哪裏。我需要幫助解決這個問題，因此總供應量讀取實際金額，並且在常規和測試網絡上都嘗試了15次。

代碼：

pragma solidity ^0.4.11; 

interface IERC20 { 
    function totalSupply() constant returns (uint256 totalSupply); 
    function balanceOf(address _owner) constant returns (uint256 balance); 
    function transfer(address _to, uint256 _value) returns (bool success); 
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 
    function approve (address _spender, uint256 _value) returns (bool success); 
    function allowance(address _owner, address _spender) constant returns (uint256 remaining); 
    event Transfer(address indexed _from, address indexed_to, uint256 _value); 
    event Approval(address indexed_owner, address indexed_spender, uint256 _value); 
} 
contract SampleToken is IERC20 { 

    using SafeMath for uint256; 
    uint public _totalSupply = 10000000; 

    string public constant symbol ="SAMP"; 
    string public constant name = "Sample Token"; 
    uint8 public constant decimals = 3; 

    //1 ether = 350 SAMP 
    uint256 public constant RATE = 350; 

    address public owner; 



    mapping(address => uint256) balances; 
    mapping(address => mapping(address => uint256)) allowed; 

    function() payable { 
     createTokens(); 
    } 

    function SampleToken() { 
     owner = msg.sender; 
    } 

    function createTokens() payable { 
     require(msg.value > 0); 

     uint256 tokens = msg.value.mul(RATE); 
     balances[msg.sender] = balances[msg.sender].add(tokens); 
     _totalSupply = _totalSupply.add(tokens); 

     owner.transfer(msg.value); 
    } 

    function totalSupply() constant returns (uint256 _totalSupply) { 
     return _totalSupply; 

    } 

    function balanceOf(address _owner) constant returns (uint256 balance) { 
     return balances[_owner]; 
    } 

    function transfer(address _to, uint256 _value) returns (bool success) { 
     require(
      balances[msg.sender] >= _value 
      && _value > 0 
     ); 
     balances[msg.sender] -= balances[msg.sender].sub(_value); 
     balances[_to] = balances[_to].add(_value); 
     Transfer(msg.sender, _to, _value); 
     return true; 
    } 

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 
     require(
      allowed[_from][msg.sender] >= _value 
      && balances[_from] >= _value 
      && _value > 0 
     ); 
     balances[_from] = balances[_from].sub(_value); 
     balances[_to] = balances [_to].add(_value); 
     allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); 
     Transfer(_from, _to, _value); 
     return true; 
    } 

    function approve (address _spender, uint256 _value) returns (bool success) { 
     allowed[msg.sender][_spender] =_value; 
     Approval(msg.sender, _spender, _value); 
     return true; 
    } 

    function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 
     return allowed[_owner][_spender]; 
    } 

    event Transfer(address indexed _from, address indexed_to, uint256 _value); 
    event Approval(address indexed_owner, address indexed_spender, uint256 _value); 
    function mul(uint256 a, uint256 b) internal constant returns (uint256) { 
    uint256 c = a * b; 
    assert(a == 0 || c/a == b); 
    return c; 
    } 
    function bytes32ToString(bytes32 x) constant returns (string) { 
     bytes memory bytesString = new bytes(32); 
     uint charCount = 0; 
     for (uint j = 0; j < 32; j++) { 
      byte char = byte(bytes32(uint(x) * 2 ** (8 * j))); 
      if (char != 0) { 
       bytesString[charCount] = char; 
       charCount++; 
      } 
     } 
     bytes memory bytesStringTrimmed = new bytes(charCount); 
     for (j = 0; j < charCount; j++) { 
      bytesStringTrimmed[j] = bytesString[j]; 
     } 
     return string(bytesStringTrimmed); 
    } 

} 

library SafeMath { 
    function mul(uint256 a, uint256 b) internal constant returns (uint256) { 
    uint256 c = a * b; 
    assert(a == 0 || c/a == b); 
    return c; 
    } 

    function div(uint256 a, uint256 b) internal constant returns (uint256) { 
    // assert(b > 0); // Solidity automatically throws when dividing by 0 
    uint256 c = a/b; 
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold 
    return c; 
    } 

    function sub(uint256 a, uint256 b) internal constant returns (uint256) { 
    assert(b <= a); 
    return a - b; 
    } 

    function add(uint256 a, uint256 b) internal constant returns (uint256) { 
    uint256 c = a + b; 
    assert(c >= a); 
    return c; 
    } 
} 

Answer 1

你在totalSupply有一個作用域的問題。

function totalSupply() constant returns (uint256 _totalSupply) { 
     return _totalSupply; 
    } 

基本上，你的回報你_totalSupply定義爲是要優先於_totalSupply實例的版本和本地值永遠不會設置成一個局部變量，總是返回0

你可以將其更改爲

function totalSupply() constant returns (uint256) { 
     return _totalSupply; 
    } 

或

function totalSupply() constant returns (uint256 _totalSupply) { 
     _totalSupply = __totalSupply; 
    } 

和更改

uint public _totalSupply = 10000000; 

到

uint private __totalSupply = 10000000; 

此，如果你設置你的總供給公共任何人都可以改變其值做反正是很重要的。