- Conversion rule:
- If a function call uses
mismatched data types then:
- The input parameters
must be converted
to the
data type of the
parameter variable of the
function
- The return value must be converted to the data type of the receiving variable of the function call
- The input parameters
must be converted
to the
data type of the
parameter variable of the
function
- If a function call uses
mismatched data types then:
-
Example:
- Consider the following
function call to
float f(float x):
int main() { int x, y; x = 4; y = f(x); // x is int, but f( ) uses a float parameter !!! // Also: f( ) returns a float value, y is an int !!! }
- The following
data type conversions
must take place
in order to
use the
function call correctly:
- Consider the following
function call to
float f(float x):
- Recall:
- Different types of
data uses
different encoding methods
Examples:
- Signed integer uses
2's complement encoding
- Floating point numbers uses the IEEE 754 encoding
- Signed integer uses
2's complement encoding
- The same value is represented differently when using different encoding methods
- Different types of
data uses
different encoding methods
-
Example:
The int value 4 is represented as: 00000000 00000000 00000000 00000100 (this is the encoding of 4 in int)
The float value 4.0 is represented as: 01000000 10000000 00000000 00000000 Because: 4.010 = 1002 = 1.0 × 22 The mantissa = 1.00000000000000000000000000 (leading 1 is omitted !) The exponent = 2, encoded in excess 01111111 ==> 10000001 Therefore: 4.0 is represented as: 01000000 10000000 00000000 00000000 (this is the encoding of 4 in float) ^^^^^^^^^------------------------- Exponent Mantissa
- Conversion between
data types:
- Conversion between data types = transform the representation from one encoding to another while preserving the value that is represented
- Note:
- The CPU has built-in instructions to perform type (encoding) conversions
- Recall:
- If a function call uses
mismatched data types then:
- The input parameters
must be converted
to the
data type of the
parameter variable of the
function
- The return value must be converted to the data type of the receiving variable of the function call
- The input parameters
must be converted
to the
data type of the
parameter variable of the
function
- If a function call uses
mismatched data types then:
- Fact:
- Type conversion can
result in
represention errors
- Example:
int x = 1234567; short y; y = x; // Result in a wrong value being represented ! // 1234567 is too big for a short variable
- Type conversion can
result in
represention errors
- Therefore:
- Each programming language establishes its own set of permissible conversions when data types in a function call is mismatched
- Java's conversion rule:
- If mismatched data types are used in a function call, then Java will allow the function call if it can perform a safe conversions to make the data types match
-
Example 1: safe conversions
public class JavaFunc1 { public static int f(float x) { return (int) (x*x); } public static void main(String[] args) { int a; float b; a = 4; b = f(a); // int a is converted to float before calling f // int return value is converted to float // before assigning to b System.out.println("a = " + a + ", b = " + b); } }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: javac JavaFunc1.java
- To run: java JavaFunc1
-
Example 2:
unsafe
conversions
public class JavaFunc2 { public static float f(int x) { return (x*x); } public static void main(String[] args) { float a; int b; a = 4; b = f(a); // cannot convert float a to int parameter safely !!!! System.out.println("a = " + a + ", b = " + b); } }Result:
cheung@aruba> javac JavaFunc2.java JavaFunc2.java:17: error: method f in class JavaFunc2 cannot be applied to given types; b = f(a); ^ required: int found: float reason: actual argument float cannot be converted to int by method invocation conversion 1 error
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: javac JavaFunc2.java
- To run: java JavaFunc2
- C's conversion rule:
- If mismatched data types
are used in a function call,
then C will
always allow
the function call
- The C compiler will always perform the necessary conversions to make the data types match
- If mismatched data types
are used in a function call,
then C will
always allow
the function call
-
Example 1: safe conversions
#include <stdio.h> int f(float x) { return (int) (x*x); } void main(int argc, char * argv[]) { int a; float b; a = 4; b = f(a); // C will convert int a to float // C will also convert the int return value to float printf("a = %d, b = %f\n", a, b); }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: gcc CFunc1.c
- To run: a.out
-
Example 2:
unsafe
conversions
#include <stdio.h> float f(int x) { return (x*x); } void main(int argc, char *argv[]) { float a; int b; a = 4; b = f(a); // C compiler will convert float a to int // C compiler will also convert float return value to int printf("a = %f, b = %d\n", a, b); }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: gcc Func2.c
- To run: a.out