用于部署的以太令牌合同的总供应读数为零

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; 

此，如果你设置你的总供给公共任何人都可以改变其值做反正是很重要的。