In modern ABAP Object Oriented Programming, we define method parameters using the IMPORTING, EXPORTING keywords, each of which can use pass by value or pass by reference, as well as the RETURNING keyword, which always uses pass by value, and the CHANGING keyword, which always uses pass by reference.

Let’s understand the difference between them.

1. Pass by Value

When a parameter is passed by value, a copy of the data is made.

This means any changes inside the method do not affect the original variable outside the method. In methods we explicitly define pass by value using the VALUE keyword.

Example 1) of Pass by Value

Explanation:

• The VALUE keyword ensures iv_number is passed by value, thus a copy of the data is created inside the method.
• Any modifications to the copied data within change_value do not affect lv_number outside the method.
• Note: The IMPORTING parameter was able to be „changed“ due to VALUE( ) without needing to define it as a CHANGING parameter.

That’s great, but what if instead of:

We have:

We have IMPORTING VALUE(), which is implicitly pass-by-value, so it creates a copy of the data, but now we don’t have TYPE i but TYPE REF TO i as our type.

Let’s take a look.

Example 2) of Pass by Value

Explanation

• lv_number is an integer and lo_number is a reference that points to its memory location.
• The method is pass-by-value and expects a reference, so the reference (memory address) is copied.
• When the dereferenced value behind that address is changed inside the method, the change persists outside the method even on the original lv_number since it shares the same address.
• Note: lv_number->* ue be can be modified, despite lv_number being desfined as an IMPORTING parameter

Next, let’s check out pass-by-reference in methods.

2. Pass by Reference

When a parameter is passed by reference, no copy of the data is created.

Instead, the method copies the memory address of the data as a reference and operates directly on the original variable, meaning any changes made inside the method will reflect outside the method, as the original data was changed via this reference.

Example 1) of Pass by Reference

Explanation:

• lv_number is passed by reference to the method, thus the method acts directly on the data behind the reference.
• The changes to cv_number reflect outside the method on lv_number.
• Note: cv_number must be made a CHANGING parameter, because IMPORTING parameters cannot be changed by reference.

Example 2) of Pass by Reference

Explanation:

• lv_number is an integer and lo_number is a reference that points to its memory location.
• The method is pass-by-reference and expects a reference, so a reference to a reference is acted upon.
• When the dereferenced value behind that reference is changed inside the method, the change persists outside the method even on the original lv_number as it was passed by reference

3. Field-Symbols

We’ve pretty much covered pass-by-value and pass-by-reference in the context of methods and their parameters, and we’ve also talked about variables and ref variables.

I know some readers are going to be wondering: “What about Field-Symbols?”

So let’s briefly discuss them as well and you’ll find more details in the performance comparisons below.

What are field-symbols?

Field-symbols are pass-by-reference. Their syntax differs a bit from references, but basically they’re pointers in ABAP, allowing dynamic access to memory locations without copying data or needing to be dereferenced.

While field-symbols offer a slight performance advantage due to not needing to be dereferenced, which is a negligible performance cost, they are becoming obsolete and are not recommended by SAP.

Hence, why I only want to mention them briefly.

4. Compare & Contrast

Pass-by-value vs. Pass-by-reference:

Aspect	Pass-by-value	Pass-by-reference
Concept	The method receivs a copy of the variables’s value	The method receives a pointer (reference) to the original variable
Memory Usage	Higher (creates a copy)	Lower (uses original memory)
Performance	Slower for large data	Faster, especially for tables
Scope	Changes only affect the copy within the method	Changes affect the original variable directly
Usage	Common for small data types or when memory is no concern	Common for large structures, itabs and objects
Data Integrity	Safer (no unintended modifications)	Risk of unintended modifications
Modifications	No impact on the original data	Modifies the original data directl.y
Flexibility	Safer, as the original data remains unchanged	More flexible, but requires careful handling
Syntax	IMPORTING VALUE( ) TYPE	IMPORTING TYPE REF TO

Field-Symbols vs. References:

Aspect	Field-Symbols (< >)	References (REF #( ))
Concept	Acts like a pointer, referencing existing memory directly	Creates a reference object pointing to data
Memory Usage	No new memory allocation	Requires memory for the reference itself
Performance	Very fast (direct access)	Slightly slower due to dereferencing
Scope	Only valid within the block where assigned	Persistent across method calls
Usage	Good for internal table processing, loops, dynamic access	Useful for object-oriented design, method parameters
Modifications	Changes the original data directly	Changes data via the reference
Flexibility	More flexible for direct memory operations	Better for passing objects and structured data
Dereferencing	Implicit (no extra step needed)	Explicit (lo_ref->*)

*Dereferencing is very fast, operating at memory access speed. The performance cost is negligible compared to large data copies or database accesses.

5. Overview of Behaviour

1. In ABAP OOP, using VALUE() or not in your IMPORTING and EXPORTING parameters determines whether the method implicitly behaves as pass-by-value or pass-by-reference.
   
2. A reference to an object is the memory address of an object via which the object can be accessed (dereferenced, ->*) and acted upon. Passing only memory addresses requires less computation than copying the entire datasets around.
   
3. Pass-by-value methods create a copy of the object, even when the object itself is a reference. Thus the original object stays unchanged outside the method.
   
4. Pass-by-reference methods access the memory address of the original object and may act upon its data by dereferencing. The original object doesn’t stay unchanged outside the method. This can sometimes lead to unexpected behavior, when appending to EXPORTING tables in separate method calls throughout a program, where one would expect the parameter to be cleared automatically with each call, but isn’t. Manual clearing of EXPORTING parameters for tables, is often wanted, when appending to pass-by-reference parameters.
   
5. CHANGING is always pass-by-reference and RETURNING is always pass-by-value. IMPORTING and EXPORTING can be either.

Conclusion

Modern ABAP OOP syntax allows clear control over pass by reference vs. pass by value, influencing performance and data integrity. By understanding these principles, developers can write more efficient and maintainable code in ABAP.

Let’s Keep the Conversation Going!

Do you have questions or your own experiences on this topic? Feel free to reach out to Jonathan Rumpl on LinkedIn!

Stay up to date! Sign up for our Cadaxo newsletter and receive regular insights, best practices, and news from the SAP world.