Solidez – Constructores

Un constructor es un método especial en cualquier lenguaje de programación orientado a objetos que se llama cada vez que se inicializa un objeto de una clase. Es totalmente diferente en el caso de Solidity, Solidity proporciona una declaración de constructor dentro del contrato inteligente y se invoca solo una vez cuando se implementa el contrato y se usa para inicializar el estado del contrato. El compilador crea un constructor predeterminado si no hay un constructor definido explícitamente.

Creando un constructor

Un constructor se define utilizando una palabra clave de constructor sin ningún nombre de función seguido de un modificador de acceso. Es una función opcional que inicializa las variables de estado del contrato. Un constructor puede ser interno o público, un constructor interno marca el contrato como abstracto. 

Sintaxis:

constructor() <Access Modifier> {          
} 

Ejemplo: en el siguiente ejemplo, en el contrato constructorExample , se crea un constructor para inicializar la variable de estado str. 

// Solidity program to demonstrate
// creating a constructor
pragma solidity ^0.5.0;       
         
// Creating a contract
contract constructorExample {       
         
    // Declaring state variable
    string str;       
             
    // Creating a constructor
    // to set value of 'str'
    constructor() public {                 
        str = "GeeksForGeeks";       
    }       
      
    // Defining function to
    // return the value of 'str' 
    function getValue(
    ) public view returns (
      string memory) {       
        return str;       
    }     
}

Producción : 

Constructor en Herencia

En caso de que no se defina un constructor, se llama al constructor predeterminado, pero si el constructor está definido en un contrato principal y tiene algunos argumentos, entonces el contrato secundario también debe proporcionar los parámetros necesarios para el constructor. Si el contrato hijo no pasa ningún parámetro al constructor del padre, el contrato hijo se convertirá en un contrato abstracto. Hay dos formas de llamar al constructor de un contrato principal: 

1. Inicialización directa: en el siguiente ejemplo, el método de inicialización directa se usa para inicializar el constructor de la clase principal.

// Solidity program to demonstrate
// Constructor in Inheritance
pragma solidity ^0.5.0;
 
// Creating a contract
contract Base {
 
   // Declaring variable
   uint data;
 
   // Defining a constructor
   constructor(uint _data) public {
      data = _data;  
   }
 
   // Defining function
   function Print(
   ) public  returns(string memory){
       return "Direct Initialization";
   }
 
}
 
// Child contract inheriting
// the parent contract 'Base'
contract Derived is Base(2){
 
    // Defining a constructor
    constructor() public {}
 
   // Defining function to access
   // variable of parent contract
   function getData(
   ) external returns(uint){
       uint result = data ** 2;
       return result;
   }
}
 
// Caller contract
contract caller{
 
   // Creating an object of child contract
    Derived c = new Derived();
 
   // Accessing functions of parent
   // and child contract using
   // object of child contract
    function getResult() public returns(uint){
        c.Print();
        return c.getData();
    }
}

Producción : 
 

2. Inicialización indirecta: en el siguiente ejemplo, la inicialización indirecta usando Base(string(abi.encodePacked(_info, _info))) se realiza para inicializar el constructor de la clase base.

// Solidity program to demonstrate
// Indirect Initialization
pragma solidity ^0.5.0;
 
// Creating a contract
contract Base {
 
   // Declaring state variable
   string str;
 
   // Defining a constructor
   constructor(
     string memory _str) public {
      str = _str;  
   }
 
   // Defining a function
   function Print(
   ) public returns(string memory){
       return "Indirect Initialization";
   }
}
 
// Child contract inheriting
// parent contract 'Base'
contract Derived is Base {
 
   // Defining a constructor
   constructor(
     string memory _info) Base(
     string(abi.encodePacked(
       _info, _info))) public {}
 
   // Defining function to
   // return value of parent
   // contract variable 'str'
   function getStr(
   ) public view returns(string memory){
       return str;
   }
}
 
// Caller contract
contract caller {
 
    // Creating an object of
    // child contract
    Derived c
      = new Derived("GeeksForGeeks");
 
    //Defining a function to access
    // functions of the parent
    //contract and child contract
    function getResult() public view{
        c.Print();
        c.getStr();
    }
}

Producción : 

Necesidad de Constructores

Los constructores son muy útiles en un contrato inteligente, se puede definir un valor de parámetro en el tiempo de ejecución y también se puede restringir la llamada al método. La sobrecarga de constructores no es compatible con Solidity, solo permite un constructor a la vez.

Ejemplo: en el siguiente ejemplo, el contrato constructorExample consta de un constructor para demostrar la necesidad del constructor.

// Solidity program to demonstrate
// Need of constructors
pragma solidity ^0.5.0;       
         
// Creating a contract
contract constructorExample {       
         
    // Declaring state variable
    string str;       
    address private owner
      = 0x62Ab98A0efB752C48bd82836D0b4335018B9B97e;
 
    // Defining constructor
    constructor(string memory string) public {                 
        if(msg.sender == owner){   
            str = string;   
        }       
    }       
     
    // Defining function to
    // return value of 'str'  
    function getValue() public view returns (
      string memory) {       
        return str;       
    }     
}

Producción :