ABAP CONV and CAST: Type Conversion and Casting

Category
ABAP-Statements
Published
Author
Johannes

The constructor expressions CONV and CAST enable type conversions inline. CONV converts elementary data types, while CAST is used for casting object references.

CONV – Type Conversion

The CONV operator converts a value to another data type.

Syntax

CONV <target_type>( <expression> )
CONV #( <expression> )  " Type is derived from context

Examples for CONV

1. Basic Type Conversion

" String to Integer
DATA(lv_int) = CONV i( '42' ).
WRITE: / lv_int.  " 42


" Integer to String
DATA(lv_str) = CONV string( 123 ).
WRITE: / lv_str.  " 123


" Packed to Float
DATA: lv_packed TYPE p DECIMALS 2 VALUE '123.45'.
DATA(lv_float) = CONV f( lv_packed ).
WRITE: / lv_float.  " 1.2345E+02

2. Comparison: CONV vs. Classic Conversion

" === CLASSIC ===
DATA: lv_string TYPE string VALUE '100',
      lv_number TYPE i.


lv_number = lv_string.  " Implicit conversion


" Or with MOVE
MOVE lv_string TO lv_number.




" === MODERN WITH CONV ===
DATA(lv_number2) = CONV i( '100' ).


" Inline in expressions
DATA(lv_result) = CONV i( '50' ) + CONV i( '30' ).
WRITE: / lv_result.  " 80

3. CONV for Decimal Numbers

" String to Packed Decimal
DATA(lv_amount) = CONV p DECIMALS 2( '1234.56' ).
WRITE: / lv_amount.  " 1234.56


" Division with correct result
DATA: lv_a TYPE i VALUE 10,
      lv_b TYPE i VALUE 3.


" Without CONV: Integer division
DATA(lv_div1) = lv_a / lv_b.
WRITE: / lv_div1.  " 3 (truncated)


" With CONV: Decimal result
DATA(lv_div2) = CONV decfloat34( lv_a ) / lv_b.
WRITE: / lv_div2.  " 3.333...

4. CONV in Calculations

DATA: lv_quantity TYPE i VALUE 7,
      lv_total    TYPE i VALUE 100.


" Percentage calculation with decimal result
DATA(lv_percentage) = CONV decfloat16( lv_quantity * 100 / lv_total ).
WRITE: / lv_percentage, '%'.  " 7%


" Precise calculation
DATA(lv_price) = CONV p DECIMALS 2( 100 / 3 ).
WRITE: / lv_price.  " 33.33

5. CONV for Strings

" Char to String
DATA: lv_char TYPE c LENGTH 10 VALUE 'Test'.
DATA(lv_string) = CONV string( lv_char ).


" Numeric to formatted string
DATA: lv_num TYPE i VALUE 42.
DATA(lv_formatted) = |Number: { CONV string( lv_num ) }|.


" NUMC to Integer
DATA: lv_numc TYPE n LENGTH 10 VALUE '0000000123'.
DATA(lv_int_from_numc) = CONV i( lv_numc ).
WRITE: / lv_int_from_numc.  " 123

6. CONV with #-Notation (Type Derivation)

METHODS: process_amount
  IMPORTING iv_amount TYPE p DECIMALS 2.


" Type is derived from parameter
process_amount( iv_amount = CONV #( '99.99' ) ).


" In assignments
DATA: lv_target TYPE p DECIMALS 2.
lv_target = CONV #( '123.45' ).  " Type derived from lv_target

7. CONV for Date and Time

" String to Date
DATA(lv_date) = CONV d( '20241115' ).
WRITE: / lv_date.  " 20241115


" Timestamp
DATA(lv_ts) = CONV timestamp( '20241115143000' ).


" Assemble date from parts
DATA: lv_year  TYPE n LENGTH 4 VALUE '2024',
      lv_month TYPE n LENGTH 2 VALUE '11',
      lv_day   TYPE n LENGTH 2 VALUE '15'.


DATA(lv_date2) = CONV d( |{ lv_year }{ lv_month }{ lv_day }| ).

8. CONV in Method Calls

METHODS: get_discount
  IMPORTING iv_amount TYPE p DECIMALS 2
  RETURNING VALUE(rv_discount) TYPE p DECIMALS 2.


" Direct conversion in call
DATA(lv_discount) = get_discount( iv_amount = CONV #( 100 ) ).


" With multiple parameters
calculate(
  iv_quantity = CONV i( '5' )
  iv_price    = CONV p DECIMALS 2( '19.99' )
).

9. CONV with Built-in Types

" Various types
DATA(lv_i)    = CONV i( '42' ).           " Integer
DATA(lv_i8)   = CONV int8( '9999999999' ). " 8-Byte Integer
DATA(lv_f)    = CONV f( '3.14159' ).      " Floating Point
DATA(lv_p)    = CONV p DECIMALS 4( '123.4567' ). " Packed
DATA(lv_df16) = CONV decfloat16( '123.456789' ). " Decimal Float 16
DATA(lv_df34) = CONV decfloat34( '123.456789' ). " Decimal Float 34
DATA(lv_c10)  = CONV c LENGTH 10( 'Test' ).      " Char 10
DATA(lv_n5)   = CONV n LENGTH 5( 42 ).           " NUMC 5

10. CONV to Avoid Runtime Errors

" Potentially erroneous without checking
DATA: lv_input TYPE string VALUE 'abc'.


" Catch with TRY-CATCH
TRY.
    DATA(lv_number) = CONV i( lv_input ).
  CATCH cx_sy_conversion_no_number.
    WRITE: / 'Not a valid number'.
ENDTRY.

CAST – Object Reference Casting

The CAST operator performs a downcast or crosscast of object references.

Syntax

CAST <target_type>( <object_reference> )
CAST #( <object_reference> )  " Type is derived from context

Examples for CAST

1. Downcast (Base Class → Subclass)

CLASS lcl_vehicle DEFINITION.
  PUBLIC SECTION.
    METHODS: get_type RETURNING VALUE(rv_type) TYPE string.
ENDCLASS.


CLASS lcl_car DEFINITION INHERITING FROM lcl_vehicle.
  PUBLIC SECTION.
    METHODS: get_brand RETURNING VALUE(rv_brand) TYPE string.
    DATA: mv_brand TYPE string.
ENDCLASS.


" Upcast: Car → Vehicle (implicit)
DATA: lo_vehicle TYPE REF TO lcl_vehicle.
lo_vehicle = NEW lcl_car( ).


" Downcast: Vehicle → Car (explicit with CAST)
DATA(lo_car) = CAST lcl_car( lo_vehicle ).
DATA(lv_brand) = lo_car->get_brand( ).

2. Comparison: CAST vs. Classic Casting

" === CLASSIC ===
DATA: lo_car_classic TYPE REF TO lcl_car.
lo_car_classic ?= lo_vehicle.  " Downcast with ?=




" === MODERN WITH CAST ===
DATA(lo_car_modern) = CAST lcl_car( lo_vehicle ).


" Or with type derivation
DATA: lo_target TYPE REF TO lcl_car.
lo_target = CAST #( lo_vehicle ).

3. CAST with Interface

INTERFACE lif_printable.
  METHODS: print.
ENDINTERFACE.


CLASS lcl_document DEFINITION.
  PUBLIC SECTION.
    INTERFACES: lif_printable.
ENDCLASS.


" Create object
DATA: lo_doc TYPE REF TO lcl_document.
lo_doc = NEW #( ).


" Upcast to interface
DATA: lo_printable TYPE REF TO lif_printable.
lo_printable = lo_doc.


" Downcast back to class
DATA(lo_doc_back) = CAST lcl_document( lo_printable ).

4. CAST for Method Chaining

" Without CAST: Intermediate variable needed
DATA: lo_base TYPE REF TO lcl_vehicle.
lo_base = get_vehicle( ).
DATA: lo_car TYPE REF TO lcl_car.
lo_car ?= lo_base.
lo_car->start_engine( ).


" With CAST: Inline casting
CAST lcl_car( get_vehicle( ) )->start_engine( ).

5. CAST in Expressions

" Direct access to subclass attributes
DATA(lv_brand) = CAST lcl_car( lo_vehicle )->mv_brand.


" In string templates
DATA(lv_info) = |Brand: { CAST lcl_car( lo_vehicle )->mv_brand }|.


" In conditions
IF CAST lcl_car( lo_vehicle )->mv_brand = 'BMW'.
  WRITE: / 'BMW found'.
ENDIF.

6. Safe Casting with IS INSTANCE OF

" Check first, then cast
IF lo_vehicle IS INSTANCE OF lcl_car.
  DATA(lo_safe_car) = CAST lcl_car( lo_vehicle ).
  lo_safe_car->start_engine( ).
ENDIF.


" With CASE TYPE OF
CASE TYPE OF lo_vehicle.
  WHEN TYPE lcl_car.
    CAST lcl_car( lo_vehicle )->start_engine( ).
  WHEN TYPE lcl_truck.
    CAST lcl_truck( lo_vehicle )->load_cargo( ).
  WHEN OTHERS.
    WRITE: / 'Unknown vehicle type'.
ENDCASE.

7. CAST with Generic Types

" With DATA as generic reference
DATA: lr_any TYPE REF TO data.
DATA: lt_table TYPE TABLE OF string.


lr_any = REF #( lt_table ).


" Cast to concrete table type
FIELD-SYMBOLS: <lt_strings> TYPE TABLE OF string.
ASSIGN CAST #( lr_any )->* TO <lt_strings>.

8. CAST with RTTS (Runtime Type Services)

DATA: lo_type TYPE REF TO cl_abap_typedescr.


lo_type = cl_abap_typedescr=>describe_by_data( lv_string ).


" Cast to specific descriptor
IF lo_type->kind = cl_abap_typedescr=>kind_elem.
  DATA(lo_elem) = CAST cl_abap_elemdescr( lo_type ).
  WRITE: / 'Length:', lo_elem->output_length.
ENDIF.

9. CAST for Factory Pattern

CLASS lcl_vehicle_factory DEFINITION.
  PUBLIC SECTION.
    CLASS-METHODS: create
      IMPORTING iv_type TYPE string
      RETURNING VALUE(ro_vehicle) TYPE REF TO lcl_vehicle.
ENDCLASS.


CLASS lcl_vehicle_factory IMPLEMENTATION.
  METHOD create.
    ro_vehicle = SWITCH #( iv_type
      WHEN 'CAR'   THEN NEW lcl_car( )
      WHEN 'TRUCK' THEN NEW lcl_truck( )
      ELSE NEW lcl_vehicle( )
    ).
  ENDMETHOD.
ENDCLASS.


" Usage with CAST
DATA(lo_my_car) = CAST lcl_car(
  lcl_vehicle_factory=>create( 'CAR' )
).

10. Catch CX_SY_MOVE_CAST_ERROR

TRY.
    " Erroneous cast (Vehicle is not a Car)
    DATA: lo_plain TYPE REF TO lcl_vehicle.
    lo_plain = NEW lcl_vehicle( ).


    DATA(lo_wrong) = CAST lcl_car( lo_plain ).  " ERROR!


  CATCH cx_sy_move_cast_error INTO DATA(lx_error).
    WRITE: / 'Cast failed:', lx_error->get_text( ).
ENDTRY.

CONV vs. CAST

AspectCONVCAST
PurposeData type conversionObject reference casting
UsageElementary types, structuresClass references, interfaces
ExampleCONV i( '42' )CAST lcl_car( lo_vehicle )
ErrorCX_SY_CONVERSION_*CX_SY_MOVE_CAST_ERROR
ClassicImplicit conversion?= operator

Built-in Conversion Functions

Besides CONV, there are built-in functions:

" Boolean conversion
DATA(lv_bool) = xsdbool( lv_age >= 18 ).  " abap_true/abap_false


" Conditional boolean
DATA(lv_cond) = boolc( lv_status = 'A' ).


" Alpha conversion (in string templates)
DATA(lv_matnr) = |{ lv_material ALPHA = OUT }|.


" Absolute value
DATA(lv_abs) = abs( -42 ).  " 42


" Sign
DATA(lv_sign) = sign( -5 ).  " -1


" Rounding
DATA(lv_round) = round( val = '3.7' dec = 0 ).  " 4


" Minimum/Maximum
DATA(lv_min) = nmin( val1 = 10 val2 = 5 ).  " 5
DATA(lv_max) = nmax( val1 = 10 val2 = 5 ).  " 10

Important Notes / Best Practice

  • CONV for data type conversions – explicitly replaces implicit conversions.
  • CAST for object reference casting – replaces the ?= operator.
  • Check with IS INSTANCE OF before a CAST to avoid runtime errors.
  • CONV #() and CAST #() derive the target type from context.
  • Use TRY-CATCH for unsafe conversions.
  • CONV enables inline conversions in expressions and method calls.
  • CAST allows method chaining without intermediate variables.
  • Combine with VALUE, COND and SWITCH.
  • For decimal calculations: Convert before division for precise results.
  • Use built-in functions like xsdbool(), abs(), round() for common conversions.