Skip to content

ABAP Keyword Documentation →  ABAP − Reference →  Program Layout →  Modularization Statements →  Procedures 

Parameter Interface of Procedures

The parameter interface of a procedure consists of formal parameters and specifies the exceptions possible in the procedure.

Other versions: 7.31 | 7.40 | 7.54

Formal Parameters

Formal parameters are input parameters, output parameters, input/output parameters, or return values. Several obsolete table parameters also exist. Formal parameters are either generic or fully typed. Pass by reference or pass by value can be specified for most formal parameters. Pass by value is mandatory for some formal parameters.

Programming Guideline

Choose the appropriate formal parameter type


Class-based exceptions can be declared using RAISING for all procedures ( methods, function modules , and subroutines ), and can then be propagated from the procedure. EXCEPTIONS can also be used in methods and function modules to define non-class-based exceptions, which can then be triggered in the procedure using RAISE or MESSAGE ... RAISING.

Pass by Reference or Pass by Value

Parameters can be passed to procedures either by reference or by value.

  • Pass by reference
    In the case of pass by reference, a reference to the actual parameter is passed to the procedure when it is called. The procedure then works with the actual parameter. No local data object is created for the actual parameter. Input parameters that are passed by reference cannot be changed in the procedure (with the exception of USING parameters of subroutines).
  • Pass by value
    In the case of pass by value, a type-friendly local data object is created as a copy of the actual parameter for the formal parameter. The system initializes output parameters and return values when the procedure is started. Input parameters as well as input/output parameters receive the value of the actual parameter. A changed formal parameter is only passed to the actual parameter if the procedure is completed without errors.

When deciding whether to use pass by reference or pass by value for a formal parameter, the performance and robustness of each pass-by type must be compared.

In ABAP, pass by reference always leads to better performance since no local data object has to be stored and no data transport is necessary when the procedure is called. Therefore, for performance reasons, pass by reference is usually preferable, unless explicit or implicit writes are made to an input parameter in the procedure or if it is necessary to ensure that an input/output parameter or an output parameter is returned only if the procedure ends without any errors. In such cases, pass by value is mandatory, to make sure that the assigned actual parameter is not modified simultaneously in the caller when writes are made to a formal parameter. For performance reasons, only parameters of 100 bytes or less should be passed in these cases, whenever possible.

Also note the following when using pass by reference:

  • In subroutines, writes can be made to an input parameter defined using USING without a syntax error being produced (as is the case with input parameters of methods or function modules defined using IMPORTING).
  • An output parameter that is passed by reference acts like an input/ output parameter; in other words, if read access to an output parameter exists in the procedure before the value of that parameter is changed, this value is not initial, unlike with pass by value, but is the same as the current value of the actual parameter in the caller.
  • If a procedure is stopped because of an error (that is, if it is stopped for a reason other than reaching its last statement or RETURN, EXIT, or CHECK), all actual parameters that are passed by reference retain the value of the assigned formal parameter that the parameter had when the program was stopped. In pass by value, no values are passed to actual parameters when a procedure terminates.

Procedures and their calls have to be programmed so that these kinds of errors do not occur.

To summarize, pass by reference is always preferable when performance is an issue, while pass by value is more suitable in situations where robustness and data consistency are more important. These factors must be taken into account in each individual case when deciding which pass-by type to use with which type of parameter.

Programming Guideline

Choose a suitable pass-by type


  • When strings or internal tables of the same type are passed by value, table sharing comes into force between the data object created locally and the data object passed, as in assignments. However, table sharing only happens if the row type of the internal table permits it. This means that, when passing strings and internal tables, the performance benefits of pass by reference over pass by value may be negated by sharing (in certain circumstances).

  • A local data object is generated for formal parameters passed by reference that are not bound to an actual parameter during the call (as for pass by value).

  • When a literal is bound, its typing is not checked as strictly.

  • When a function, a calculation expression, a constructor expression, or a table expression is bound, passing is always pass by value, even if the formal parameter is defined as pass by reference.

  • The result of the typing check when passing actual parameters to formal parameters is independent of the pass type. In a pass by value, the check for pass by reference is always carried out, even though this is stricter than necessary in individual cases. For example, a special reference variable cannot be passed to a general typed CHANGING parameter, even if pass by value is defined for this parameter.


For a method meth, CHANGING parameter p1 is defined for pass by reference and p2 for pass by value. The values of both parameters are modified before an exception is raised. The actual parameter a1 bound to the parameter using pass by reference contains the modified value when the exception is handled. The actual parameter a2 bound to the parameter using pass by value, on the other hand, keeps its value.

CLASS cx_exception DEFINITION 
                   INHERITING FROM cx_static_check. 

    CLASS-METHODS meth CHANGING p1        TYPE i 
                               VALUE(p2) TYPE i 
                       RAISING  cx_exception. 

  METHOD meth. 
    p1 = 333. 
    p2 = 444. 
    RAISE EXCEPTION TYPE cx_exception. 

  DATA(a1) = 111. 
  DATA(a2) = 222. 
      cls=>meth( CHANGING p1 = a1 
                         p2 = a2 ). 
    CATCH cx_exception. 
      cl_demo_output=>display( |{ a1 }, { a2 }| ). 


Pass by Parameter