ABAP Keyword Documentation →  ABAP - Reference →  Declarative statemnts →  Typing →  Checking Typing 

Functions and Expressions as Actual Parameters

Functions and expressions can be passed to input parameters of methods as actual parameters in the method call, when creating an object, or when raising exceptions. In this case, special rules apply both for checking the typing and for passing the parameters.

Other versions: 7.31 | 7.40 | 7.54

Checking Typing

• A numerical function, a description function, or an arithmetic expression can be attached to any numerically typed input parameter.

• A bit function or a bit expression can be bound to any byte-type typed formal parameter.

• A string function or a string expression can be bound to any character-type typed formal parameter.

Calculation Type and Calculation Length

• The calculation type of an arithmetic expression is derived from the involved operands of the expression and the typing of the formal parameter, provided it is fully typed. If the formal parameter is typed generically, then only the operands of the expression are evaluated.

• The calculation length of a bit expression is the length of the largest operand.

Passing Parameters

When binding a function or an arithmetic expression, the parameters are always passed by value, even if the formal parameter is defined as to be passed by reference.

Fully Typed

With a static method call, if required, the return value of the function, or the result of the arithmetic expression is converted to the type of the formal parameter and then passed.

Note

With the dynamic method call the same rules apply as with the static call. However, the handling during runtime is time-consuming. Therefore, in a dynamic call you should use help variables instead of functions or arithmetic expressions if possible.

Generically Typed

• In a function, the formal parameter takes on the type of the return value.

• With an arithmetic expression, the formal parameter takes over the calculation type determined by the operand. If the calculation type is p, the number of decimal places is determined by the accuracy required by the calculation and therefore depends on the values of the operands.

• In a bit expression, the formal parameter is set to type x in the calculation length determined by the operands.

• In a string expression, the formal parameter is set to the type string, if the typing is fully generic. If the typing is not fully generic, the length is set to the length of the result of the string expression.

Example

The functional method m1 is called twice for each assignment to result. The first call is executed in an arithmetical expression, which is passed as an actual parameter in the second call. In the first call of each assignment, the formal parameter p1 has type p of length 16. The number of decimal places is 0 in the first assignment, 14 in the second, and 1 in the third assignment. In the second call, the formal parameter p1 has the type decfloat34 in each assignment, because the calculation type of the arithmetical expression is determined by the return value of m1.

CLASS c1 DEFINITION. 
  PUBLIC SECTION. 
    CLASS-METHODS m1 IMPORTING p1 TYPE numeric 
                     RETURNING value(ret) TYPE decfloat34. 
ENDCLASS. 

CLASS c1 IMPLEMENTATION. 
  METHOD m1. 
    ret = p1. 
  ENDMETHOD. 
ENDCLASS. 

DATA num1   TYPE p DECIMALS 2 VALUE '2.00'. 
DATA num2   TYPE p DECIMALS 2 VALUE '1.00'. 
DATA result TYPE decfloat34. 

START-OF-SELECTION. 
  result = c1=>m1( sqrt( 4 ) +  c1=>m1( num1 / 2 )  ). 
  result = c1=>m1( sqrt( 4 ) +  c1=>m1( num1 / 3 )  ). 
  result = c1=>m1( sqrt( 4 ) +  c1=>m1( num2 / 2 )  ).