How TokenCreator/OwnedToken example from Solidity documentation works

Question

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;

Answer 1

As per the latest docs, any arguments passed while creating a contract via new will be passed in constructor

contract D {
    uint public x;
    constructor(uint a) payable {
        x = a;
    }
}

then,

D d = new D(4); // will be executed as part of C's constructor