topic Re: Diff Between widening Cast & Narrowing Casting in Application Development and Automation Discussions

Diff Between widening Cast & Narrowing Casting

Former Member — Sat, 19 Apr 2008 10:38:06 GMT

Hi,

What are differences between widening Cast & Narrowing Casting ?

Give some exaples also.

Thanks

Re: Diff Between widening Cast & Narrowing Casting

Former Member — Sat, 19 Apr 2008 11:43:45 GMT

widening means when u type cast a char to integer it is called widening that means type casting lower to higher one this is also called as upcasting.

narrowing means when u type cast integer to char it is called narrowing that means type casting higher to lower one this is also called down casting.

reward if helpful.

cheers

amith

Re: Diff Between widening Cast & Narrowing Casting

Former Member — Sat, 19 Apr 2008 15:13:02 GMT

Hey fren,

Narrowing Cast is also known as Upcasting...

Widening Cast is known as Downcasting...

Let us take an example...

We define a class lcl_vehicle and other class lcl_truck inherited from lcl_vehicle.

CLASS lcl_vehicle DEFINITION.

      PUBLIC SECTION.
         METHODS constructor
                   IMPORTING im_make_v  TYPE string.
                   
         METHODS estimate_fuel
                   IMPORTING im_distance   TYPE s_distance
                   RETURNING value(re_fuel) TYPE s_capacity
      
         METHODS get_make........
                                        ........
          
         METHODS get_count........
                                        ........
          METHODS display_attributes........
                                        ........
      PROTECTED SECTION.
          DATA r_tank TYPE REF TO lcl_tank.
      
      PRIVATE SECTION.
          DATA make TYPE string.

ENDCLASS.

CLASS lcl_vehicle IMPLEMENTATION.
          
          METHOD constructor.
               make = im_make_v.
          ENDMETHOD.
          METHOD get_make.
             - - - 
             - - - 
          ENDMETHOD.
          METHOD get_count.
             - - -
             - - -
          ENDMETHOD.
          METHOD display_attributes.
             - - -
             - - -
          ENDMETHOD.

ENDCLASS.

Now we define a sub class lcl_truck to super class lcl_vehicle.

CLASS lcl_truck DEFINITION INHERITING FROM lcl_vehicle.

       PUBLIC SECTION.
            METHODS constructor IMPORTING im_make_t TYPE string
                                                         im_cargo_t TYPE s_plan_car
            METHODS estimate_fuel REDEFINITION.
            METHODS get_cargo RETURNING value( re_cargo ) TYPE s_plan_car.
       PRIVATE SECTION.
          DATA max_cargo TYPE s_plan_car.
ENDCLASS.

CLASS lcl_truck IMPLEMENTATION.
      METHOD constructor.
           CALL METHOD super->constructor( im_make_v  = im_make_t ).
            max_cargo = im_cargo_t.
      ENDMETHOD.

      METHOD estimete_fuel.
          DATA total_weight TYPE w_weight.
          total_weight = max_cargo + weight.
          re_fuel = total_weight * im_distance * correction_factor.
       ENDMETHOD.                    
ENDCLASS.

Now we again define one more subclass lcl_bus to superclass lcl_vehicle.

CLASS lcl_bus DEFINITION INHERITING FROM lcl_vehicle.

PUBLIC SECTION.
            METHODS constructor IMPORTING im_make_b TYPE string
                                                         im_load_b TYPE s_plan_car

       PRIVATE SECTION.
          DATA max_load TYPE s_plan_car.
ENDCLASS.  

CLASS lcl_bus IMPLEMENTATION.
      METHOD constructor.
           CALL METHOD super->constructor( im_make_v  = im_make_b ).
            max_cargo = im_load_b.
      ENDMETHOD.

      METHOD estimete_fuel.
          DATA total_weight TYPE w_weight.
          total_weight = max_passengers * average_weight + weight.
          re_fuel = total_weight * im_distance * correction_factor.
       ENDMETHOD.                    
ENDCLASS.

Variables of the type 'reference to superclass' can also refer to subclass instances at runtime.

This is called as Narrowing Casting...

Lets see how it works...



* Creating references to the classes.........

DATA:
    r_vehicle TYPE REF TO lcl_vehicle,
    r_truck    TYPE REF TO lcl_truck,
    r_bus      TYPE REF TO lcl_bus.

*Creating an object of class lcl_truck.........

CREATE OBJECT r_truck.

*Narrowing Cast ................

r_vehicle = r_truck.

Now reference --> superclass.... r_vehicle will point to only the inherited compenents of lcl_truck.

If you assign a subclass reference to a superclass reference, this ensures that all components that can be accessed syntactically after the cast assignment are actually available in the instance.

The subclass always contains at least the same components as the superclass. After all, the name and the signature of redefined methods are identical.

The user can, therefore, address the subclass instance in the same way as the superclass instance. However, he is restricted to using only the inherited components. In this example, after the assignment, the methods GET_MAKE, GET_COUNT, DISPLAY_ATTRIBUTES and ESTIMATE_FUEL of the instance LCL_TRUCK can only be accessed using the reference R_VEHICLE. If there are any restrictions regarding visibility, they are left unchanged.

It is not possible to access the specific components from the class LCL_TRUCK of the instance (GET_CARGO in the above example) using the reference R_VEHICLE. The view is thus usually narrowed (or at least unchanged). That is why we describe this type of assignment of reference variables as narrowing cast. There is a switch from a view of several components to a view of a few components. The term upcast is also common.

A typical use for narrowing cast assignments is to prepare for generic access. A user who is not at all interested in the finer points of the instances of the subclasses but who simply wants to address the shared components could use a superclass reference for this access.

In the example shown here, assume that a travel agency (LCL_RENTAL) needs to manage all imaginable kinds of vehicles in one list. This leads to the question of what types should be assigned to the internal table for the references to airplane instances. You should also assume that the car rental company needs to be able to calculate only the required amount of fuel for all its vehicles. Correspondingly, the ESTIMATE_FUEL method is defined in the superclass LCL_VEHICLE and is redefined in all subclasses.

This is about Narrowing Cast.

Inspire if this was needful,

Warm Regards,

Abhi...

Re: Diff Between widening Cast & Narrowing Casting

Former Member — Sat, 19 Apr 2008 16:16:08 GMT

Hey Fren,

Now lets discuss about Widening Cast....in this post..

Variables of the type reference to superclass can also refer to subclass instances at runtime.You may want to copy such a reference back to a suitable variable of the type reference to subclass.

Let us have the same example code to be continued in here....

We have lcl_vehicle as superclass and lcl_truck and lcl_bus as subclass.

As we have created the object of r_truck in the previous post, here we will create one more reference r_truck2 to class lcl_truck.


DATA:
    r_truck2 LIKE lcl_truck.

So First we will use Narrowing Cast.


*Narrowing Cast
      r_vehicle = r_truck.

While 'Widening Cast' we have the special symbol....?=


*Widening Cast.........
       r_truck2 ?= r_vehicle.

If you want to assign a superclass reference to a subclass reference, you must use the widening cast assignment operator

MOVE ... ?TO ... or its short form ?=.

Otherwise, you will get a message stating that it is not certain that all components that can be accessed syntactically after the cast assignment are actually available in the instance.

As a rule, the subclass class contains more components than the superclass.

After assigning this type of reference back to a subclass reference to the implementing class, clients are no longer limited to inherited components.

In the example given here, all components of the LCL_TRUCK instance can be accessed again after the assignment using the reference R_TRUCK2. The view is thus usually widened, or at least unchanged. That is why we describe this type of assignment of reference variables as widening cast; there is a switch from a view of a few components to a view of more components.

The term downcast is also common.

A typical use for widening cast assignments is when specific components of instances need to be addressed and their references are kept in variables that are typed on the superclass. A user who is interested in the finer points of the instances of a subclass cannot use the superclass reference for this access because it only allows access to the shared components.

In this example, a car rental company (LCL_RENTAL) wants to determine the maximum capacity of its trucks, but it stores all types of vehicle references in an internal table that is typed as LCL_VEHICLE. Therefore, what happens if there is no truck reference in the superclass reference R_VEHICLE at runtime but the widening cast assignment operator tries to copy the reference to the now invalid reference R_TRUCK?

This is about widening cast....

Hope this is needful to you.....

Inspire by rewarding,

Warm Regards,

Abhi....