In this post (Understanding TokenCreator/OwnedToken example from Solidity documentation) the detailed response was given, but I still have a question about "how it works".
contract OwnedToken {
// TokenCreator is a contract type that is defined below.
// It is fine to reference it as long as it is not used
// to create a new contract.
TokenCreator public creator;
address public owner;
string public name;
// This is the constructor which registers the
// creator and the assigned name.
function OwnedToken(string _name) {
owner = msg.sender;
// We do an explicit type conversion from `address`
// to `TokenCreator` and assume that the type of
// the calling contract is TokenCreator, there is
// no real way to check that.
creator = TokenCreator(msg.sender);
name = _name;
}
function changeName(string newName) {
// Only the creator can alter the name --
// the comparison is possible since contracts
// are implicitly convertible to addresses.
if (msg.sender == address(creator))
name = newName;
}
function transfer(address newOwner) {
// Only the current owner can transfer the token.
if (msg.sender != owner)
return;
// We also want to ask the creator if the transfer
// is fine. Note that this calls a function of the
// contract defined below. If the call fails (e.g.
// due to out-of-gas), the execution here stops
// immediately.
if (creator.isTokenTransferOK(owner, newOwner))
owner = newOwner;
}
}
contract TokenCreator {
mapping(string => address) addresses;
function getAddress(string name) constant returns (address) {
return addresses[name];
}
function createToken(string name)
returns (OwnedToken tokenAddress)
{
// Create a new Token contract and return its address.
// From the JavaScript side, the return type is simply
// "address", as this is the closest type available in
// the ABI.
tokenAddress = new OwnedToken(name);
addresses[name] = tokenAddress;
}
function changeName(string oldName, string newName) {
// Again, the external type of "tokenAddress" is
// simply "address".
address tokenAddress = addresses[oldName];
delete addresses[oldName];
addresses[newName] = tokenAddress;
OwnedToken(tokenAddress).changeName(newName);
}
function isTokenTransferOK(
address currentOwner,
address newOwner
) returns (bool ok) {
// Check some arbitrary condition.
address tokenAddress = msg.sender;
return (sha3(newOwner) & 0xff) == (bytes20(tokenAddress) & 0xff);
}
}
I didn't get when "function OwnedToken(string _name)" is called? As far as I understand When we call "new OwnedToken(name);" - "this does not execute a constructor" (c) as it's said in official documentation. As I assume it only creates an instance of "OwnedToken" contract and SOMEHOW (how it works, tho?) deploys it to SOME (where this address is located at?) address;