# Excursion Down to Bits and Bytes This sheet goes a bit into the technical background of data types and data objects. It may be helpful for a better understanding of how to handle data in ABAP including a glance on casting and conversions. After its declaration, a [data object](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendata_object_glosry.htm "Glossary Entry") is usable in its context (procedure, class, program) according to its type. For example, a numeric data object can be assigned the result of a calculation: > [!NOTE] > For checking out the code snippets in [ABAP Cloud](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenabap_cloud_glosry.htm), you can use the interface `if_oo_adt_classrun` in a class by implementing the method `if_oo_adt_classrun~main`. ``` abap DATA num TYPE i. num = 2 * 3 * 5 * 53 * 2267. cl_demo_output=>display( num ). ``` After this assignment, the data object `num` contains the calculated value 3604530, which is also displayed accordingly with a type-compliant output as, for example, `cl_demo_output=>display`. And of course the same can be seen in the display of the variable in the ABAP Debugger when setting a breakpoint at the last statement. The ABAP Debugger also shows the hexadecimal value 32003700 of the data object. This directly represents the binary value `0011 0010 0000 0000 0011 0111 0000 0000` stored in the 4 bytes allocated to the 4-byte integer number in the memory. This value is platform dependent and for numeric types is defined by the [byte order](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenbyte_order_glosry.htm "Glossary Entry") order, where either the most significant (big endian) or least significant (little endian) byte is written to the first memory location. The decimal value of the hexadecimal value `32003700` shown here would be `838874880` and is not the integer value `3604530` that ABAP deals with. This shows the meaning of data types. A data object is a sequence of bytes stored in memory at its address, which is interpreted by the ABAP runtime framework according to the data type. The hexadecimal value is in most cases irrelevant to the programmer. Let us now consider a character-like field text with a length of two characters: ``` abap DATA text TYPE c LENGTH 2. text = '2' && '7'. cl_demo_output=>display( text ). ``` This field can be assigned the result of a string operation as shown and the result shown by `cl_demo_output=>display` as well as in the ABAP Debugger is the character string `27`. Again, it is the data type, that derives the value `27` from the actual hexadecimal content, which is `32003700` as in the previous example! In this case, `32003700` is the encoding of the string `27` in the Unicode character representation [UCS-2](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenucs2_glosry.htm "Glossary Entry"), which is supported by ABAP in Unicode systems. The Unicode character representation also depends on the platform-dependent byte order. Only for a byte-type data type does the value as interpreted by ABAP directly correspond to the hexadecimal content. The following lines modify the bits of a byte string with a bit-operation: ``` abap DATA hex TYPE x LENGTH 4 VALUE 'CDFFC8FF'. hex = BIT-NOT hex. cl_demo_output=>display( hex ). ``` Here, the output with `cl_demo_output=>display`, the value display of the ABAP Debugger as well as the hexadecimal value are the same, namely `32003700`. In the above examples, we presented three data objects that all occupy 4 bytes in memory that have the same binary values, but are handled differently by ABAP due to their data type. The data type is also responsible for the fact, that different kind of operations (numeric calculation, string concatenation, bit-operation) can be applied to the respective data objects. Using these examples we can have now look at the basic concepts of [casting](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abencast_casting_glosry.htm "Glossary Entry") and [type conversion](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abentype_conversion_glosry.htm "Glossary Entry") and their relation to bits and bytes. In ABAP, the term casting means nothing more than treating a data object according to a different data type than the one that is permanently assigned to it. This can be done using [field symbols](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenfield_symbol_glosry.htm "Glossary Entry"), with which a new (symbolic) name and a new type can be defined for the memory area of a data object. When the memory area is accessed using a field symbol, it is handled according to the type of the field symbol. The following lines show an example. ``` abap DATA hex TYPE x LENGTH 4 VALUE '32003700'. FIELD-SYMBOLS:   TYPE i,                TYPE c. ASSIGN hex TO   CASTING. ASSIGN hex TO CASTING. cl_demo_output=>new(   )->write_data( hex   )->write_data(   )->write_data( )->display( ). ``` The bit string in `hex` is cast to a numeric field when accessed using the name `` and to a text field when accessed using the name ``. The outputs are `32003700`, `3604530` and `27`, clearly showing the effect of the data type on handling one and the same hexadecimal content. In contrast, in a type conversion (or conversion for short), the actual binary content of a data object is converted so that it fits another data type. Type conversions usually occur in assignments between data objects of different data types. The goal of such a conversion is to preserve the type-specific meaning of the content in the source field as far as possible for the data type of the target field. For this purpose, ABAP contains a large set of [conversion rules](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenconversion_rules.htm). A simple example is shown here: ``` abap TYPES hex TYPE x LENGTH 4. FIELD-SYMBOLS:    TYPE hex,     TYPE hex. DATA: text TYPE c LENGTH 2 VALUE '27',       num  TYPE i. num = text. ASSIGN text TO CASTING. ASSIGN num  TO   CASTING. cl_demo_output=>new(   )->write_data( text   )->write_data(   )->write_data( num   )->write_data( )->display( ). ``` We are assigning the character-like field `text` to the numeric field `num` and display the result that can also be checked in the ABAP Debugger. The ABAP runtime framework recognizes that the character string `27` in text can be interpreted as the integer number `27`, generates the hexadecimal value 1B000000 in which this number is encoded for the numeric type of `num`, and assigns it to the memory location of `num`. Thus, the actual conversion takes place for the original hexadecimal content `32003700` of `text` to the new hexadecimal content `1B000000` of `num`. For character strings in text fields, for which no such meaningful conversion is possible, an exception occurs. The field symbols `` and `` are used to show the hexadecimal content of the fields `text` and `num` by casting them to a byte-like type. > [!TIP] > For reasons of simplicity this sheet is restricted to named elementary variables. Note that in particular the same holds for [literals](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenabap_literal_glosry.htm "Glossary Entry") that are handled internally in such a way as if they were constants of the data type assigned to the literal. In the preceding example, `text` can be replaced by a literal `'27'` yielding the same results.