A program in java to calculate the frequency of each character in a string.

import java.io.*;
class stringMain
public static void main(String args[])throws IOException
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String s;
char sarr[]=new char[30];
char b=”;
int count,len;
System.out.println(“Enter a string:”);
for(int i=0;i<len;i++)
for(int i =0;i<len;i++)
if(b== '')
for(int j=0;j<len;j++)
if(b == sarr[j])
{ count++;
System.out.println("the frequency of the character "+b+" in the string is " +count);

//This program is compile in SDK installed windows system.
Output of the program is:


Posted in Uncategorized | Leave a comment

of studies by Francis Bacon

Of Studies

Francis Bacon


Born in London and educated at Cambridge, Sir Francis Bacon spent much of his life practicing law, but to the end of it he busied himself with philosophical pursuits, and will be known to posterity chiefly for his deep and clear writings on these subjects. His constant direction in philosophy is to break away from assumption and tradition, and to be led only by sound induction based on knowledge of observed phenomena. Among the distinguished names in English literature, none stands higher in his field than that of Francis Bacon.

Reproduced here is  a short essay by him which is a model of lucid, vivid, balanced and presice prose writing. Students will see that his essay is replete with short and pithy sententences and aphorisms. It also informs the reader of the significance of various facets of “studies”. To Bacon “Reading maketh a full man, conference a ready man, and writing an exact man”.

Studies serve for delight, for ornament, and for ability. Their chief use for delight is in privateness, and retiring; for ornament, is in discourse; and for ability, is in the judgment and disposition of business; for expert men can execute, and perhaps judge of the particulars, one by one; but the general counsels, and the plots and marshaling of affairs, come best from those that are learned.

To spend too much time in studies, is sloth; to use them too much for ornament, is affectation; to make judgment wholly by their rules, is the humour of a scholar; they perfect nature and are perfected by experiencefor natural abilities are like natural plants, that need pruning by study; and studies themselves do give forth directions too much at large, except they be bounded in by experience. Crafty men condemn studies, simple men admire them, and wise men use them, for they teach not their own use; but that is a wisdom without them, and above them, won by observation.

Read not to contradict and confute, nor to believe and take for granted, nor to find talk and discourse, but to weigh and consider. Some books are to be tasted, others to be swallowed, and some few to be chewed and digested; that is, some books are to be read only in parts; others to be read, but not curiously; and some few to be read wholly, and with diligence and attention. Some books also may be read by deputy, and extracts made of them by others; but that would be only in the less important arguments, and the meaner sort of books; else distilled books are like common distilled waters, flashy things.

Reading maketh a full man, conference a ready man, and writing an exact man; and, therefore, if a man write little, he had need have a great memory; if he confer little, he had need have a present wit; and if he read little, he had need have much cunning, to seem to know that he doth not. Histories make men wise; poets, witty; the mathematics, subtle; natural philosophy, deep; moral philosophy, grave; logic and rhetoric, able to contend.


  • How do you think studies can make a man perfect?
  • “To spend too much time in studies, is sloth”. Comment.
  • ‘Some books are to be tasted, others to be swallowed, and some few to be chewed and digested; that is, some books are to be read only in parts; others to be read, but not curiously; and some few to be read wholly, and with diligence and attention.” Elaborat


Posted in Uncategorized | Leave a comment

Operator overloading guidline.

One of the nice features of C++ is that you can give special meanings to operators, when they are used with user-defined classes. This is called operator overloading. You can implement C++ operator overloads by providing special member-functions on your classes that follow a particular naming convention. For example, to overload the + operator for your class, you would provide a member-function named operator+ on your class.

The following set of operators is commonly overloaded for user-defined classes:

= (assignment operator)
+ – * (binary arithmetic operators)
+= -= *= (compound assignment operators)
== != (comparison operators)

Here are some guidelines for implementing these operators. These guidelines are very important to follow, so definitely get in the habit early.
Assignment Operator =

The assignment operator has a signature like this:

class manas_love {

manas_love & operator=(const manas_love &rhs);


manas_love a, b;

b = a;   // Same as b.operator=(a);

Notice that the = operator takes a const-reference to the right hand side of the assignment. The reason for this should be obvious, since we don’t want to change that value; we only want to change what’s on the left hand side.

Also, you will notice that a reference is returned by the assignment operator. This is to allow operator chaining. You typically see it with primitive types, like this:

int a, b, c, d, e;

a = b = c = d = e = 42;

This is interpreted by the compiler as:

a = (b = (c = (d = (e = 42))));

In other words, assignment is right-associative. The last assignment operation is evaluated first, and is propagated leftward through the series of assignments. Specifically:

e = 42 assigns 42 to e, then returns e as the result
The value of e is then assigned to d, and then d is returned as the result
The value of d is then assigned to c, and then c is returned as the result

Now, in order to support operator chaining, the assignment operator must return some value. The value that should be returned is a reference to the left-hand side of the assignment.

Notice that the returned reference is not declared const. This can be a bit confusing, because it allows you to write crazy stuff like this:

manas_love a, b, c;

(a = b) = c;  // What??

At first glance, you might want to prevent situations like this, by having operator= return a const reference. However, statements like this will work with primitive types. And, even worse, some tools actually rely on this behavior. Therefore, it is important to return a non-const reference from your operator=. The rule of thumb is, “If it’s good enough for ints, it’s good enough for user-defined data-types.”

So, for the hypothetical manas_love assignment operator, you would do something like this:

// Take a const-reference to the right-hand side of the assignment.
// Return a non-const reference to the left-hand side.
manas_love& manas_love::operator=(const manas_love &rhs) {
…  // Do the assignment operation!

return *this;  // Return a reference to myself.

Remember, this is a pointer to the object that the member function is being called on. Since a = b is treated as a.operator=(b), you can see why it makes sense to return the object that the function is called on; object a is the left-hand side.

But, the member function needs to return a reference to the object, not a pointer to the object. So, it returns *this, which returns what this points at (i.e. the object), not the pointer itself. (In C++, instances are turned into references, and vice versa, pretty much automatically, so even though *this is an instance, C++ implicitly converts it into a reference to the instance.)

Now, one more very important point about the assignment operator:


This is especially important when your class does its own memory allocation. Here is why: The typical sequence of operations within an assignment operator is usually something like this:

manas_love& manas_love::operator=(const manas_love &rhs) {
// 1.  Deallocate any memory that manas_love is using internally
// 2.  Allocate some memory to hold the contents of rhs
// 3.  Copy the values from rhs into this instance
// 4.  Return *this

Now, what happens when you do something like this:

manas_love mc;

mc = mc;     // BLAMMO.

You can hopefully see that this would wreak havoc on your program. Because mc is on the left-hand side and on the right-hand side, the first thing that happens is that mc releases any memory it holds internally. But, this is where the values were going to be copied from, since mc is also on the right-hand side! So, you can see that this completely messes up the rest of the assignment operator’s internals.

The easy way to avoid this is to CHECK FOR SELF-ASSIGNMENT. There are many ways to answer the question, “Are these two instances the same?” But, for our purposes, just compare the two objects’ addresses. If they are the same, then don’t do assignment. If they are different, then do the assignment.

So, the correct and safe version of the manas_love assignment operator would be this:

manas_love& manas_love::operator=(const manas_love &rhs) {
// Check for self-assignment!
if (this == &rhs)      // Same object?
return *this;        // Yes, so skip assignment, and just return *this.

… // Deallocate, allocate new space, copy values…

return *this;

Or, you can simplify this a bit by doing:

manas_love& manas_love::operator=(const manas_love &rhs) {

// Only do assignment if RHS is a different object from this.
if (this != &rhs) {
… // Deallocate, allocate new space, copy values…

return *this;

Remember that in the comparison, this is a pointer to the object being called, and &rhs is a pointer to the object being passed in as the argument. So, you can see that we avoid the dangers of self-assignment with this check.

In summary, the guidelines for the assignment operator are:

Take a const-reference for the argument (the right-hand side of the assignment).
Return a reference to the left-hand side, to support safe and reasonable operator chaining. (Do this by returning *this.)
Check for self-assignment, by comparing the pointers (this to &rhs).

Compound Assignment Operators += -= *=

I discuss these before the arithmetic operators for a very specific reason, but we will get to that in a moment. The important point is that these are destructive operators, because they update or replace the values on the left-hand side of the assignment. So, you write:

manas_love a, b;

a += b;    // Same as a.operator+=(b)

In this case, the values within a are modified by the += operator.

How those values are modified isn’t very important – obviously, what manas_love represents will dictate what these operators mean.

The member function signature for such an operator should be like this:

manas_love & manas_love::operator+=(const manas_love &rhs) {


We have already covered the reason why rhs is a const-reference. And, the implementation of such an operation should also be straightforward.

But, you will notice that the operator returns a manas_love-reference, and a non-const one at that. This is so you can do things like this:

manas_love mc;

(mc += 5) += 3;

Don’t ask me why somebody would want to do this, but just like the normal assignment operator, this is allowed by the primitive data types. Our user-defined datatypes should match the same general characteristics of the primitive data types when it comes to operators, to make sure that everything works as expected.

This is very straightforward to do. Just write your compound assignment operator implementation, and return *this at the end, just like for the regular assignment operator. So, you would end up with something like this:

manas_love & manas_love::operator+=(const manas_love &rhs) {
…   // Do the compound assignment work.

return *this;

As one last note, in general you should beware of self-assignment with compound assignment operators as well. Fortunately, none of the C++ track’s labs require you to worry about this, but you should always give it some thought when you are working on your own classes.
Binary Arithmetic Operators + – *

The binary arithmetic operators are interesting because they don’t modify either operand – they actually return a new value from the two arguments. You might think this is going to be an annoying bit of extra work, but here is the secret:

Define your binary arithmetic operators using your compound assignment operators.

There, I just saved you a bunch of time on your homeworks.

So, you have implemented your += operator, and now you want to implement the + operator. The function signature should be like this:

// Add this instance’s value to other, and return a new instance
// with the result.
const manas_love manas_love::operator+(const manas_love &other) const {
manas_love result = *this;     // Make a copy of myself.  Same as manas_love result(*this);
result += other;            // Use += to add other to the copy.
return result;              // All done!


Actually, this explicitly spells out all of the steps, and if you want, you can combine them all into a single statement, like so:

// Add this instance’s value to other, and return a new instance
// with the result.
const manas_love manas_love::operator+(const manas_love &other) const {
return manas_love(*this) += other;

This creates an unnamed instance of manas_love, which is a copy of *this. Then, the += operator is called on the temporary value, and then returns it.

If that last statement doesn’t make sense to you yet, then stick with the other way, which spells out all of the steps. But, if you understand exactly what is going on, then you can use that approach.

You will notice that the + operator returns a const instance, not a const reference. This is so that people can’t write strange statements like this:

manas_love a, b, c;

(a + b) = c;   // Wuh…?

This statement would basically do nothing, but if the + operator returns a non-const value, it will compile! So, we want to return a const instance, so that such madness will not even be allowed to compile.

To summarize, the guidelines for the binary arithmetic operators are:

Implement the compound assignment operators from scratch, and then define the binary arithmetic operators in terms of the corresponding compound assignment operators.
Return a const instance, to prevent worthless and confusing assignment operations that shouldn’t be allowed.

Comparison Operators == and !=

The comparison operators are very simple. Define == first, using a function signature like this:

bool manas_love::operator==(const manas_love &other) const {
…  // Compare the values, and return a bool result.

The internals are very obvious and straightforward, and the bool return-value is also very obvious.

The important point here is that the != operator can also be defined in terms of the == operator, and you should do this to save effort. You can do something like this:

bool manas_love::operator!=(const manas_love &other) const {
return !(*this == other);

That way you get to reuse the hard work you did on implementing your == operator. Also, your code is far less likely to exhibit inconsistencies between == and !=, since one is implemented in terms of the other.

Posted in Uncategorized | Leave a comment

Some c++ standered hader file.

The following files contain the declarations of the C++ Standard Library.



New in C++11 and TR1. Provides the container class template std::array, a container for a fixed sized array.


Provides the specialized container class std::bitset, a bit array.


Provides the container class template std::deque, a double-ended queue.


New in C++11 and TR1. Provides the container class template std::forward_list, a singly linked list.


Provides the container class template std::list, a doubly linked list.


Provides the container class templates std::map and std::multimap, sorted associative array and multimap.


Provides the container adapter class std::queue, a single-ended queue, and std::priority_queue, a priority queue.


Provides the container class templates std::set and std::multiset, sorted associative containers or sets.


Provides the container adapter class std::stack, a stack.


New in C++11 and TR1. Provides the container class template std::unordered_map and std::unordered_multimap, hash tables.


New in C++11 and TR1. Provides the container class template std::unordered_set and std::unordered_multiset.


Provides the container class template std::vector, a dynamic array.



Provides definitions of many container algorithms.


Provides several function objects, designed for use with the standard algorithms.


Provides classes and templates for working with iterators.


Provides classes and templates for working with locales.


Provides facilities for memory management in C++, including the class template std::unique_ptr.


Contains standard exception classes such as std::logic_error and std::runtime_error, both derived from std::exception.


New in C++11 and TR1. Provides a class template std::tuple, a tuple.


Provides the template class std::pair, for working with pairs (two-member tuples) of objects.



Provides the C++ standard string classes and templates.


Provides utilities for pattern matching strings using regular expressions.

Streams and Input/Output


Provides facilities for file-based input and output. See fstream.


Provides facilities to manipulate output formatting, such as the base used when formatting integers and the precision of floating point values.


Provides several types and functions basic to the operation of iostreams.


Provides forward declarations of several I/O-related class templates.


Provides C++ input and output fundamentals. See iostream.


Provides the template class std::istream and other supporting classes for input.


Provides the template class std::ostream and other supporting classes for output.


Provides the template class std::sstream and other supporting classes for string manipulation.


Provides reading and writing functionality to/from certain types of character sequences, such as external files or strings.



Provides class template std::complex and associated functions for working with complex numbers.


Provides algorithms for numerical processing


New in C++11. 26.5-1 This subclase defines a facility for generating (pseudo-)random numbers.


Provides the template class std::valarray, an array class optimized for numeric processing.

Language support


Provides several types and functions related to exception handling, including std::exception, the base class of all exceptions thrown by the Standard Library.


Provides the template class std::numeric_limits, used for describing properties of fundamental numeric types.


Provides operators new and delete and other functions and types composing the fundamentals of C++ memory management.


Provides facilities for working with C++ run-time type information.

Thread support library


New in C++11. Provide class and namespace for working with threads.


New in C++11. 30.4-1 This section provides mechanisms for mutual exclusion: mutexes, locks, and call once.


New in C++11. 30.5-1 Condition variables provide synchronization primitives used to block a thread until notified by some other thread that some condition is met or until a system time is reached.


New in C++11. 30.6.1-1 Describes components that a C++ program can use to retrieve in one thread the result (value or exception) from a function that has run in the same thread or another th


Posted in Uncategorized | Leave a comment

Some c++ short type interview and study base question.

Freequently Asked C++ Questions:-

Question : Why main function is special in C++ ?

Answer : Whenever a C++ program is executed, execution of the program starts and ends at main(). The main is the driver function of the program. If it is not present in a program, no execution can take place.

Question : What is run-time error, logical error and syntax error?

Answer : Syntax error – The errors which are traced by the compiler during compilation, due to wrong grammar for the language used in the program, are called syntax errors.
For example, cin<<a; // instead of extraction operator insertion operator is used.
Run time Error – The errors encountered during execution of the program, due to unexpected input or output are called run-time error.
For example – a=n/0; // division by zero
Logical Error – These errors are encountered when the program does not give the desired output, due to wrong logic of the program.
For example : remainder = a+b // instead of using % operator + operator is used.

Question : What is the role of #include directive in C++?

Answer : The preprocessor directive #include tells the complier to insert another file into your source file. In effect, #include directive is replaced by the contents of the file indicated.

Question : What is compiler and linker?

Answer : Compiler – It is a program which converts the program written in a programming language to a program in machine language.
Linker – It is a program which links a complied program to the necessary library routines, to make it an executable program. more details

Question : Why is char often treated as integer data type in C++ ?

Answer : The memory implementation of char data type is in terms of the number code. Therefore, it is said to be another integer data type.

Question : What is type conversion in C++ ?

Answer : When two operands of different data types are encountered in the same expression, the variable of lower data type is automatically converted to the data tpes of variable with higher data type, and then the expression is calculated.
For example: int a=98; float b=5; cout<<a/3.0; //converts to float type, since 3.0 is of float type.
cout<<a/b; // converts a temporarily to float type, since b is of float type, and gives the result 19.6.

Question : What is type casting in C++ ?

Answer : Type casting refers to the data type conversions specified by the programmer, as opposed to the automatic type conversions. This can be done when the compiler does not do the conversions automatically. Type casting can be done to higher or lower data type.
For example : cout<<(float)12/5; //displays 2.4, since 12 is converted to float type.

Question : What is the effect of absence of break in switch case in C++ ?

Answer : The break keyword causes the entire switch statement to exit, and the control is passed to statement following the switch.. case construct. Without break, the control passes to the statements for the next case. The break statement is optional in switch..case construct.

Question : In control structure switch-case what is the purpose of default in C++ ?

Answer : This keyword gives the switch..case construct a way to take an action if the value of the switch variable does not match with any of the case constants. No break statement is necessary after default case, since the control is already at the end of switch..case construct. The default is optional in case of switch..case construct.

Question : What is the difference between while and do-while loop?

Answer : While is an Entry Controlled Loop, the body of the loop may not execute even once if the test expression evaluates to be false the first time, whereas in do..while, the loop is executed at least once whether the condition holds true the first time or not. more details

Question : What is the difference between call by value and call by reference in a                     user defined function in C++?

Answer : The value of the actual parameters in the calling function do not get affected when the arguments are passed using call by value method, since actual and formal parameters have different memory locations.
The values of the formal parameters affect the values of actual parameters in the calling function, when the arguments are passed using call by reference method. This happens since the formal parameters are not allocated any memory, but they refer to the memory locations of their corresponding actual parameters. more details

Question : What is preprocessor directive?

Answer : A preprocessor directive is an instruction to the complier itself. A part of compiler called preprocessor deals with these directives, before real compilation process. # is used as preprocessor directive in C++.

Question : What is the difference between local variable and global variable?

Answer : Local variables are those variables which are declared within a function or a compound statement and these variables can only be used within that function/scope. They cannot be accessed from outside the function or a scope of it’s declaration. This means that we can have variables with the same names in different functions/scope. Local variables are local to the function/scope in which they are declared.
Global variables are those variables which are declared in the beginning of the program. They are not declared within a function. So, these variables can be accessed by any function of the program. So, global variables are global to all the functions of the program.

Question : What is the role of #define in C++?

Answer : It is a preprocessor directive to define a macro in a C++ program. Macros provide a mechanism for token replacement with or without a set of formal, function line parameters. For example :
#define PIE 3.1416
#define AVG(A,B,C) (A+B+C)/3

Question : What are the major differences between Object Oriented Programming                     and Procedural Programming?

Object Oriented Programming
*Emphasis on data
*Follow bottom up approach in program design
*Concept of Data hiding prevents accidental change in the data
*Polymorphism, inheritance, Data Encapsulation possible
Procedural Programming
*Emphasis on doing things (function)
*Follow top-down approach in program design
*Due to presence of global variables, there are possibilities of accidental change in data. more details

Question : What are the basic concepts of OOP?

Answer :Data Abstraction, Data Hiding, Data Encapsulation, Inheritance and Polymorphism are the basic concepts of OOP. more details

Question : How is OOP implement in C++?

Answer : A class binds together data and its associated function under one unit thereby enforcing encapsulation.
The private and protected member remain hidden from outside world. Thus a class enforces data hiding
The outside world is given only the essential information through public members, thereby enforcing abstraction.

Question : What is abstract class?

Answer : A class with no instances (no objects) is known as abstract class.

Question : What is concrete class?

Answer : A class having objects is known as concrete class.

Question : What is a constructor? What are its features?

Answer : It is a member function of class with the following unique features.
It has same name as the name of the class they belong to.
It has no return type.
It is defined in public visibility mode.
It is automatically called & executed when an object is declared/created.
Constructor can be overloaded. more details

Question : What does a destructor do?

Answer : A destructor deinitializes an object and deallocates all allocated resources.

Question : Define inheritance.

Answer : Inheritance is a process of creating new classes (derived classes) from existing classes (base classes). The derived classes not only inherit capabilities of the base class but also can add new features of own. The most important aspect of inheritance is that it allows reusability of code. more details

Question : Define Base class and derived class.

Answer : Base Class: A class from which another class inherits.
Derived Class: A class inheriting properties from another class.

Question : What are the different forms of inheritance in C++ ?

Answer : Single level inheritance, Multilevel inheritance, Hierarchical inheritance, Multiple inheritance and Hybrid inheritance. more details

Question : What is virtual base class in C++ ? What is its significance?

Answer : Multipath inheritance may lead to duplication of inherited members from a grandparent base class. This may be avoided by making the common base class a virtual base class. When a class is made a virtual base class, C++ takes necessary care to see that only one copy of that class is inherited. more details

Question : How are binary files different from text files in C++?

Answer : A text file store information in ASCII characters. In text files, each line of text is terminated, with a special character known as EOL character.
A binary file store information in the same format in which the information is held in memory. In binary file, there is no delimeter for a line.

Question : What is a stream? Name the streams generally used for file I/O.

Answer : A stream is a sequence of byte.
ofstream: Stream class to write on files
ifstream: Stream class to read from files
fstream: Stream class to both read and write from/to files. more details

Question : Difference between get() and getline().

Answer : get() does not extract the delimeter newline character from input stream. On the other hand getline() does extract the delimeter newline character from the input stream so that the stream is empty after getline() is over.

Question : Difference between ios::app and ios::out.

Answer : The ios::out is the default mode of ofstream. With the mode of the file does not exist, it gets created but if the file exists then its existing contents get deleted.
The ios::app is output mode of ofstream. With the mode of the file does not exist, it gets created but if the file exists then its existing contents are retained and new information is appended to it. more details

Question : What is pointer?

Answer : Pointer is an address of a memory location. A variable, which holds an address of a memory location, is known as a Pointer variable (or Simply Pointer). For example int *P; more details

Question : What is pointer arithmetic ? How is it performed?

Answer : Some arithmetic operators can be used with pointers:
Increment and decrement operators ++, —
Integers can be added to or subtracted from pointers using the operators +, -, +=, and -=
Each time a pointer is incremented by 1, it points to the memory location of the next element of its base type.
If “p” is a character pointer then “p++” will increment “p” by 1 byte.
If “p” were an integer pointer its value on “p++” would be incremented by 2 bytes.

Question : Differentiate between static and dynamic allocation of memory.

Answer : In the static memory allocation, the amount of memory to be allocated is predicted and preknown. This memory is allocated during the compilation itself.
In the dynamic memory allocation, the amount of memory allocated is not known beforehead. This memory is allocated during run time as and when required.

Question : What do you understand by memory leaks? How can memory leaks
be avoided?

Answer : Memory leak is a situation in which there lie so many orphaned memory blocks that are still allocated but no pointers are referencing to them.

Question : What is this pointer? What is its Significance?

Answer : The this pointer is an object pointer which points to the currently calling object, The this pointer is, by default, available to each called member function.

Question : What is the full form of LIFO? Give an example of LIFO list?

Answer : Full form of LIFO is LAST IN FIRST OUT. An example of LIFO list is stack. Stack is a linear data structure in which insertion and deletion of elements takes place only one end known as TOP.

Question : What is the full form of FIFO? What is FIFO list technically called?

Answer : Full form of FIFO is FIRST IN FIRST OUT. An example of FIFO list is Queue. Queue is a linear data structure in which insertion and deletion of elements takes place from two opposite ends rear and front respectively.

Question : What are the preconditions for Binary search to be performed on a
single dimensional array?

Answer : Precondition for Binary search to be performed on a single dimensional array is array should be sorted.

Posted in Uncategorized | Leave a comment

Different types of constant argumen passing.

The five types of const are:

  1. const variable
  2. const argument
  3. const return type
  4. const member function
  5. const member


Example of a const variable

This applies to both local and global variables.


int main()
const int dozen = 12;
//dozen cannot be changed


Example of a const argument


void Cout(const std::string& anyString)
//anyString cannot be changed
std::cout << something << std::endl;


Example of a const return type


struct Values
const std::vector<int>& GetValues() const
//Even after returning a reference to mV, mV cannot be changed
return mV;

std::vector<int> mV;


Example of a const member function


Nearly all ‘getters’ are const member functions.


struct MyClass
double GetValue() const
//Getting mValue does not change the (non-mutable) members of MyClass
return mValue;

double mValue;


Example of a const member


struct Person
Person(const bool isMale) : mIsMale(isMale) {}
const bool mIsMale; //After construction mIsMale cannot be changed

Posted in Uncategorized | Leave a comment

A short example in run time polymorphism.

A short example in run time polymorphism..

Posted in Uncategorized | Leave a comment