- Exception Handling
- Type Casting
- Templates function and class in C++
- Features of Java
- Introduction to Java
- Comparison Between C++ and Java
- Inheritance
- Interface and Abstract class in Java
One of the advantages of C++ over C is Exception Handling.
Exceptions are run-time anomalies or abnormal conditions that a program encounters during its execution.
There are two types of exceptions:
a) Synchronous,
b) Asynchronous (Ex:which are beyond the program’s control, Disc failure etc). C++ provides following specialized keywords for this purpose.
try: represents a block of code that can throw an exception.
catch: represents a block of code that is executed when a particular exception is thrown.
throw: Used to throw an exception. Also used to list the exceptions that a function throws, but doesn’t handle itself.
Following are main advantages of exception handling over traditional error handling.
1) Separation of Error Handling code from Normal Code:
In traditional error handling codes, there are always if else conditions to handle errors. These conditions and the code to handle errors get mixed up with the normal flow. This makes the code less readable and maintainable. With try catch blocks, the code for error handling becomes separate from the normal flow.
2) Functions/Methods can handle any exceptions they choose:
A function can throw many exceptions, but may choose to handle some of them. The other exceptions which are thrown, but not caught can be handled by caller. If the caller chooses not to catch them, then the exceptions are handled by caller of the caller.
In C++, a function can specify the exceptions that it throws using the throw keyword. The caller of this function must handle the exception in some way (either by specifying it again or catching it)
Example:
Type casting is a way to convert a variable from one data type to another data type.
For example, if you want to store a long value into a simple integer then you can typecast long to int.
There are two types of type casting in OOP language (C++)
1. Implicit Type Conversion
2. Explicit Type Conversions
It is also known as automatic type conversion.
Done by the compiler on its own, without any external trigger from the user.
Generally takes place when in an expression more than one data type is present. In such condition type conversion (type promotion) takes place to avoid lose of data.
All the data types of the variables are upgraded to the data type of the variable with largest data type.
• bool -> char -> short int -> int ->
• unsigned int -> long -> unsigned ->
• long long -> float -> double -> long double
Imp Note: It is possible for implicit conversions to lose information, signs can be lost (when signed is implicitly converted to unsigned), and overflow can occur (when long long is implicitly converted to float).
For Example:
This process is also called type casting and it is user-defined.
Here the user can typecast the result to make it of a particular data type.
In C++, it can be done by two ways:
Converting by assignment: This is done by explicitly defining the required type in front of the expression in parenthesis. This can be also considered as forceful casting.
Syntax: (type) expression
#include using namespace std;
int main()
{
double x = 1.2;
// Explicit conversion from double to int int sum = (int)x + 1;
cout << "Sum = " << sum; return 0;
}
Conversion using Cast operator: A Cast operator is an unary operator which forces one data type to be converted into another data type.
C++ supports four types of casting:
1. Static Cast
2. Dynamic Cast
3. Const Cast
4. Reinterpret Cast
int main()
{
double x = 1.2;
// Explicit conversion from double to int int sum = (int)x + 1;
cout << "Sum = " << sum; return 0;
}
Conversion using Cast operator: A Cast operator is an unary operator which forces one data type to be converted into another data type.
C++ supports four types of casting:
1. Static Cast
2. Dynamic Cast
3. Const Cast
4. Reinterpret Cast
A template is a simple and yet very powerful tool in C++.
The simple idea is to pass data type as a parameter so that we don’t need to write the same code for different data types.
For example, a software company may need sort() for different data types. Rather than writing and maintaining the multiple codes, we can write one sort() and pass data type as a parameter.
C++ adds two new keywords to support
templates: template and typename.
The second keyword can always be replaced by keyword class.
Templates are expanded at compiler time.
This is like macros.
The difference is, compiler does type checking before template expansion.
The idea is simple, source code contains only function/class,
but compiled code may contain multiple copies of same function/class.
Java program can also be run through online Java Complier.
