Solidez – Contrato Abstracto

Los contratos abstractos son contratos que tienen al menos una función sin su implementación o en el caso de que no proporcione argumentos para todos los constructores de contratos base. También en el caso de que no tengamos la intención de crear un contrato directamente, podemos considerar que el contrato es abstracto. No se puede crear una instancia de un resumen. Los contratos abstractos se utilizan como contratos base para que el contrato secundario pueda heredar y utilizar sus funciones. El contrato abstracto define la estructura del contrato y cualquier contrato derivado heredado de él debe proporcionar una implementación para las funciones incompletas, y si el contrato derivado tampoco implementa las funciones incompletas, ese contrato derivado también se marcará como abstracto. Un contrato abstracto se declara utilizando la palabra clave abstract. 

Ejemplo: En el siguiente ejemplo, se crea un contrato abstracto que es heredado por otro contrato que ha implementado todas las funciones del contrato abstracto. La instancia de contrato abstracto se crea en el contrato de llamada y se crea un objeto del contrato secundario. Utilizando el objeto del contrato secundario se invocan todas las funciones abstractas que se implementan en el contrato secundario.

// Solidity program to
// demonstrate
// Abstract contract
pragma solidity 0.4.19;
 
// Creating an abstract contract
abstract contract abstractContract {
 
    // Declaring functions
    function getStr(
      string _strIn) public view returns(
      string memory);
    function setValue(uint _in1, uint _in2) public;
    function add() public returns(uint);
}
 
// Child contract inheriting
// an abstract parent
// contract 'abstractContract'
contract derivedContract is abstractContract{
 
    // Declaring private
    // variables
    uint private num1;
    uint private num2;
 
    // Defining functions inherited
    // from abstract parent contract
    function getStr(
      string _strIn) public view returns(
      string memory){
        return _strIn;
    }
     
    function setValue(
      uint _in1, uint _in2) public{
        num1 = _in1;
        num2 = _in2;
    }
    function add() public returns(uint){
        return (num2 + num1);
    }
     
}
 
// Caller contract
contract call{
 
    // Creating an instance of
    // an abstract contract
    abstractContract abs;
     
    // Creating an object of
    // child contract
    function call(){
        abs = new derivedContract();
    }
 
    // Calling functions inherited
    // from abstract contract
    function getValues(
    ) public returns (uint){
        abs.setValue(10, 16);
        abs.getStr("GeeksForGeeks");
        return abs.add();
    }
     
}

Producción:

Aquí, el contrato abstractContract es un contrato abstracto que tiene algunas funciones sin su implementación, y el contrato derivado es su contrato secundario. Las funciones getStr() y setValues() toman strings y valores, mientras que la función add() agrega los valores de la función setValues() . abs es un objeto de abstractContract que crea una instancia de deriveContract en call contract que usa las variables del contrato y llama a las funciones.