5.2 Concepto de constructor en Solidity

En Solidity, un constructor es una función especial que se ejecuta una única vez cuando se despliega un contrato. Este se utiliza para inicializar el estado del contrato. A nivel técnico, los constructores son funciones opcionales, pero en la mayoría de los casos, se usan por sus capacidades de inicialización.

¿Qué es un constructor

Un constructor es una función que se define usando la palabra clave constructor. Se ejecuta precisamente una vez, en el momento de la creación del contrato, y nunca más. Si no se define un constructor, se generará uno por defecto que no realiza ninguna acción inicial.

Sintaxis básica

    pragma solidity ^0.8.0

    contract SimpleContract {
        
        // Estado del contrato
        uint256 public number

        // Constructor
        constructor(uint256 _initialNumber) {
            number = _initialNumber
        }

        function getNumber() public view returns (uint256) {
            return number
        }
    }
    

En el ejemplo anterior, el constructor toma un argumento _initialNumber y lo asigna a la variable de estado number. Este constructor se ejecutará cuando el contrato se despliegue en la blockchain, configurando la variable de estado inicial.

Constructor sin argumentos

Un constructor también puede no tener argumentos y simplemente actuar como inicializador.

    pragma solidity ^0.8.0

    contract NoArgsConstructor {
        
        // Estado del contrato
        bool public initialized

        // Constructor sin argumentos
        constructor() {
            initialized = true
        }

        function isInitialized() public view returns (bool) {
            return initialized
        }
    }
    

Aquí, el constructor constructor() inicializa la variable initialized en true cuando el contrato se despliega.

Constructores heredados

En Solidity, los constructores también pueden interactuar con contratos heredados. Cuando un contrato hereda de otro, es posible llamar al constructor del contrato padre desde el constructor del contrato hijo.

    pragma solidity ^0.8.0

    // Contrato base
    contract ParentContract {
        uint256 public parentNumber

        // Constructor del contrato base
        constructor(uint256 _parentNumber) {
            parentNumber = _parentNumber
        }
    }

    // Contrato hijo
    contract ChildContract is ParentContract {
        uint256 public childNumber

        // Constructor del contrato hijo
        constructor(uint256 _parentNumber, uint256 _childNumber) 
            ParentContract(_parentNumber) // Llama al constructor del contrato base
        {
            childNumber = _childNumber
        }
    }

    

En el ejemplo anterior, ChildContract hereda de ParentContract. El constructor del contrato hijo llama explícitamente al constructor del contrato base usando ParentContract(_parentNumber). Esto asegura que tanto la inicialización del contrato base como la del contrato hijo se realicen correctamente.

Limitaciones y consideraciones

• Un constructor no puede ser llamado directamente una vez que el contrato está desplegado. Solo se ejecuta una vez.
• El nombre del constructor no debe coincidir con el nombre del contrato, como era antes en versiones anteriores de Solidity.
• Los constructores no pueden tener un modificador internal o private, ya que se ejecutan como parte del despliegue del contrato.

Ejemplo completo

    pragma solidity ^0.8.0

    contract Example {
        
        // Estado
        address public owner
        string public contractName
        
        // Constructor
        constructor(string memory _name) {
            owner = msg.sender
            contractName = _name
        }

        function changeContractName(string memory _newName) public {
            require(msg.sender == owner, Only owner can change the contract name)
            contractName = _newName
        }
    }
    

En este ejemplo, el constructor realiza dos acciones clave: establece el propietario del contrato como la dirección que despliega el contrato usando msg.sender y asigna un nombre al contrato. Una vez desplegado, estas inicializaciones se mantienen a lo largo de la vida del contrato.