C/C++ Programming interview questions and

answers
By Satish Shetty, July 14th, 2004

What is encapsulation??

Containing and hiding information about an object, such as internal data structures and
code. Encapsulation isolates the internal complexity of an object's operation from the rest
of the application. For example, a client component asking for net revenue from a
business object need not know the data's origin.

What is inheritance?

Inheritance allows one class to reuse the state and behavior of another class. The derived
class inherits the properties and method implementations of the base class and extends it
by overriding methods and adding additional properties and methods.

What is Polymorphism??

Polymorphism allows a client to treat different objects in the same way even if they were
created from different classes and exhibit different behaviors.

You can use implementation inheritance to achieve polymorphism in languages such as

C++ and Java.

Base class object's pointer can invoke methods in derived class objects.

You can also achieve polymorphism in C++ by function overloading and operator
overloading.

What is constructor or ctor?

Constructor creates an object and initializes it. It also creates vtable for virtual functions.
It is different from other methods in a class.

What is destructor?

Destructor usually deletes any extra resources allocated by the object.

What is default constructor?

Constructor with no arguments or all the arguments has default values.

What is copy constructor?

Constructor which initializes the it's object member variables ( by shallow copying) with
another object of the same class. If you don't implement one in your class then compiler
implements one for you.

for example:
Boo Obj1(10); // calling Boo constructor

Boo Obj2(Obj1); // calling boo copy constructor

Boo Obj2 = Obj1;// calling boo copy constructor

When are copy constructors called?

Copy constructors are called in following cases:

a) when a function returns an object of that class by value
b) when the object of that class is passed by value as an argument to a function
c) when you construct an object based on another object of the same class
d) When compiler generates a temporary object

What is assignment operator?

Default assignment operator handles assigning one object to another of the same class.
Member to member copy (shallow copy)

What are all the implicit member functions of the class? Or what are all the
functions which compiler implements for us if we don't define one.??

default ctor
copy ctor
assignment operator
default destructor
address operator

What is conversion constructor?

constructor with a single argument makes that constructor as conversion ctor and it can
be used for type conversion.

for example:

class Boo
{
public:
Boo( int i );
};
Boo BooObject = 10 ; // assigning int 10 Boo object

What is conversion operator??

class can have a public method for specific data type conversions.

for example:
class Boo
{
double value;
public:
Boo(int i )
operator double()
{
return value;
}
};

Boo BooObject;

double i = BooObject; // assigning object to variable i of type double. now conversion

operator gets called to assign the value.

What is diff between malloc()/free() and new/delete?

malloc allocates memory for object in heap but doesn't invoke object's constructor to
initiallize the object.

new allocates memory and also invokes constructor to initialize the object.

malloc() and free() do not support object semantics

Does not construct and destruct objects
string * ptr = (string *)(malloc (sizeof(string)))
Are not safe
Does not calculate the size of the objects that it construct
Returns a pointer to void
int *p = (int *) (malloc(sizeof(int)));
int *p = new int;
Are not extensible
new and delete can be overloaded in a class

"delete" first calls the object's termination routine (i.e. its destructor) and then releases the
space the object occupied on the heap memory. If an array of objects was created using
new, then delete must be told that it is dealing with an array by preceding the name with
an empty []:-
Int_t *my_ints = new Int_t[10];

...

delete []my_ints;

what is the diff between "new" and "operator new" ?

"operator new" works like malloc.

What is difference between template and macro??

There is no way for the compiler to verify that the macro parameters are of compatible
types. The macro is expanded without any special type checking.

If macro parameter has a postincremented variable ( like c++ ), the increment is

performed two times.

Because macros are expanded by the preprocessor, compiler error messages will refer to
the expanded macro, rather than the macro definition itself. Also, the macro will show up
in expanded form during debugging.

for example:

Macro:

#define min(i, j) (i < j ? i : j)

template:
template<class T>
T min (T i, T j)
{
return i < j ? i : j;
}

What are C++ storage classes?

auto
register
static
extern
auto: the default. Variables are automatically created and initialized when they are
defined and are destroyed at the end of the block containing their definition. They are not
visible outside that block

register: a type of auto variable. a suggestion to the compiler to use a CPU register for
performance

static: a variable that is known only in the function that contains its definition but is
never destroyed and retains its value between calls to that function. It exists from the time
the program begins execution

extern: a static variable whose definition and placement is determined when all object
and library modules are combined (linked) to form the executable code file. It can be
visible outside the file where it is defined.

What are storage qualifiers in C++ ?

They are..

const
volatile
mutable

Const keyword indicates that memory once initialized, should not be altered by a
program.

volatile keyword indicates that the value in the memory location can be altered even
though nothing in the program
code modifies the contents. for example if you have a pointer to hardware location that
contains the time, where hardware changes the value of this pointer variable and not the
program. The intent of this keyword to improve the optimization ability of the
compiler.

mutable keyword indicates that particular member of a structure or class can be altered
even if a particular structure variable, class, or class member function is constant.

struct data
{
char name[80];
mutable double salary;
}

const data MyStruct = { "Satish Shetty", 1000 }; //initlized by complier

strcpy ( MyStruct.name, "Shilpa Shetty"); // compiler error

MyStruct.salaray = 2000 ; // complier is happy allowed
What is reference ??

reference is a name that acts as an alias, or alternative name, for a previously defined
variable or an object.

prepending variable with "&" symbol makes it as reference.

for example:

int a;
int &b = a;

What is passing by reference?

Method of passing arguments to a function which takes parameter of type reference.

for example:

void swap( int & x, int & y )

{
int temp = x;
x = y;
y = temp;
}

int a=2, b=3;

swap( a, b );

Basically, inside the function there won't be any copy of the arguments "x" and "y"
instead they refer to original variables a and b. so no extra memory needed to pass
arguments and it is more efficient.

When do use "const" reference arguments in function?

a) Using const protects you against programming errors that inadvertently alter data.
b) Using const allows function to process both const and non-const actual arguments,
while a function without const in the prototype can only accept non constant arguments.
c) Using a const reference allows the function to generate and use a temporary variable
appropriately.

When are temporary variables created by C++ compiler?

Provided that function parameter is a "const reference", compiler generates temporary
variable in following 2 ways.

a) The actual argument is the correct type, but it isn't Lvalue

double Cube(const double & num)

{
num = num * num * num;
return num;

double temp = 2.0;

double value = cube(3.0 + temp); // argument is a expression and not a Lvalue;

b) The actual argument is of the wrong type, but of a type that can be converted to the
correct type

long temp = 3L;

double value = cuberoot ( temp); // long to double conversion

What is virtual function?

When derived class overrides the base class method by redefining the same function, then
if client wants to access redefined the method from derived class through a pointer from
base class object, then you must define this function in base class as virtual function.

class parent
{
void Show()
{
cout << "i'm parent" << endl;
}
};

class child: public parent

{
void Show()
{
cout << "i'm child" << endl;
}

};

parent * parent_object_ptr = new child;

parent_object_ptr->show() // calls parent->show() i

now we goto virtual world...

class parent
{
virtual void Show()
{
cout << "i'm parent" << endl;
}
};

class child: public parent

{
void Show()
{
cout << "i'm child" << endl;
}

};

parent * parent_object_ptr = new child;

parent_object_ptr->show() // calls child->show()

What is pure virtual function? or what is abstract class?

When you define only function prototype in a base class without implementation and do
the complete implementation in derived class. This base class is called abstract class and
client won't able to instantiate an object using this base class.

You can make a pure virtual function or abstract class this way..

class Boo
{
void foo() = 0;
}

Boo MyBoo; // compilation error

What is Memory alignment??

The term alignment primarily means the tendency of an address pointer value to be a
multiple of some power of two. So a pointer with two byte alignment has a zero in the
least significant bit. And a pointer with four byte alignment has a zero in both the two
least significant bits. And so on. More alignment means a longer sequence of zero bits in
the lowest bits of a pointer.

What problem does the namespace feature solve?

Multiple providers of libraries might use common global identifiers causing a name
collision when an application tries to link with two or more such libraries. The
namespace feature surrounds a library's external declarations with a unique namespace
that eliminates the potential for those collisions.

namespace [identifier] { namespace-body }

A namespace declaration identifies and assigns a name to a declarative region.

The identifier in a namespace declaration must be unique in the declarative region in
which it is used. The identifier is the name of the namespace and is used to reference its
members.

What is the use of 'using' declaration?

A using declaration makes it possible to use a name from a namespace without the scope
operator.

What is an Iterator class?

A class that is used to traverse through the objects maintained by a container class. There
are five categories of iterators: input iterators, output iterators, forward iterators,
bidirectional iterators, random access. An iterator is an entity that gives access to the
contents of a container object without violating encapsulation constraints. Access to the
contents is granted on a one-at-a-time basis in order. The order can be storage order (as in
lists and queues) or some arbitrary order (as in array indices) or according to some
ordering relation (as in an ordered binary tree). The iterator is a construct, which provides
an interface that, when called, yields either the next element in the container, or some
value denoting the fact that there are no more elements to examine. Iterators hide the
details of access to and update of the elements of a container class. Something like a
pointer.

What is a dangling pointer?

A dangling pointer arises when you use the address of an object after its lifetime is over.
This may occur in situations like returning addresses of the automatic variables from a
function or using the address of the memory block after it is freed.

What do you mean by Stack unwinding?

It is a process during exception handling when the destructor is called for all local objects
in the stack between the place where the exception was thrown and where it is caught.

Name the operators that cannot be overloaded??

sizeof, ., .*, .->, ::, ?:

What is a container class? What are the types of container classes?

A container class is a class that is used to hold objects in memory or external storage. A
container class acts as a generic holder. A container class has a predefined behavior and a
well-known interface. A container class is a supporting class whose purpose is to hide the
topology used for maintaining the list of objects in memory. When a container class
contains a group of mixed objects, the container is called a heterogeneous container;
when the container is holding a group of objects that are all the same, the container is
called a homogeneous container.

What is inline function??

The __inline keyword tells the compiler to substitute the code within the function
definition for every instance of a function call. However, substitution occurs only at the
compiler's discretion. For example, the compiler does not inline a function if its address
is taken or if it is too large to inline.

What is overloading??

With the C++ language, you can overload functions and operators. Overloading is the
practice of supplying more than one definition for a given function name in the same
scope.

- Any two functions in a set of overloaded functions must have different argument lists.
- Overloading functions with argument lists of the same types, based on return type alone,
is an error.

What is Overriding?

To override a method, a subclass of the class that originally declared the method must
declare a method with the same name, return type (or a subclass of that return type), and
same parameter list.
The definition of the method overriding is:
· Must have same method name.
· Must have same data type.
· Must have same argument list.
Overriding a method means that replacing a method functionality in child class. To imply
overriding functionality we need parent and child classes. In the child class you define
the same method signature as one defined in the parent class.

What is "this" pointer?

The this pointer is a pointer accessible only within the member functions of a class,
struct, or union type. It points to the object for which the member function is called.
Static member functions do not have a this pointer.

When a nonstatic member function is called for an object, the address of the object is
passed as a hidden argument to the function. For example, the following function call

myDate.setMonth( 3 );

can be interpreted this way:

setMonth( &myDate, 3 );

The object's address is available from within the member function as the this pointer. It is
legal, though unnecessary, to use the this pointer when referring to members of the class.

What happens when you make call "delete this;" ??

The code has two built-in pitfalls. First, if it executes in a member function for an extern,
static, or automatic object, the program will probably crash as soon as the delete
statement executes. There is no portable way for an object to tell that it was instantiated
on the heap, so the class cannot assert that its object is properly instantiated. Second,
when an object commits suicide this way, the using program might not know about its
demise. As far as the instantiating program is concerned, the object remains in scope and
continues to exist even though the object did itself in. Subsequent dereferencing of the
pointer can and usually does lead to disaster.

You should never do this. Since compiler does not know whether the object was allocated
on the stack or on the heap, "delete this" could cause a disaster.

How virtual functions are implemented C++?

Virtual functions are implemented using a table of function pointers, called the vtable.
There is one entry in the table per virtual function in the class. This table is created by
the constructor of the class. When a derived class is constructed, its base class is
constructed first which creates the vtable. If the derived class overrides any of the base
classes virtual functions, those entries in the vtable are overwritten by the derived class
constructor. This is why you should never call virtual functions from a constructor:
because the vtable entries for the object may not have been set up by the derived class
constructor yet, so you might end up calling base class implementations of those virtual
functions
What is name mangling in C++??

The process of encoding the parameter types with the function/method name into a
unique name is called name mangling. The inverse process is called demangling.

For example Foo::bar(int, long) const is mangled as `bar__C3Fooil'.

For a constructor, the method name is left out. That is Foo::Foo(int, long) const is
mangled as `__C3Fooil'.

What is the difference between a pointer and a reference?

A reference must always refer to some object and, therefore, must always be initialized;
pointers do not have such restrictions. A pointer can be reassigned to point to different
objects while a reference always refers to an object with which it was initialized.

How are prefix and postfix versions of operator++() differentiated?

The postfix version of operator++() has a dummy parameter of type int. The prefix
version does not have dummy parameter.

What is the difference between const char *myPointer and char *const myPointer?

Const char *myPointer is a non constant pointer to constant data; while char *const
myPointer is a constant pointer to non constant data.

How can I handle a constructor that fails?

throw an exception. Constructors don't have a return type, so it's not possible to use return
codes. The best way to signal constructor failure is therefore to throw an exception.

How can I handle a destructor that fails?

Write a message to a log-file. But do not throw an exception.

The C++ rule is that you must never throw an exception from a destructor that is being
called during the "stack unwinding" process of another exception. For example, if
someone says throw Foo(), the stack will be unwound so all the stack frames between the
throw Foo() and the } catch (Foo e) { will get popped. This is called stack unwinding.
During stack unwinding, all the local objects in all those stack frames are destructed. If
one of those destructors throws an exception (say it throws a Bar object), the C++
runtime system is in a no-win situation: should it ignore the Bar and end up in the } catch
(Foo e) { where it was originally headed? Should it ignore the Foo and look for a } catch
(Bar e) { handler? There is no good answer -- either choice loses information.
So the C++ language guarantees that it will call terminate() at this point, and terminate()
kills the process. Bang you're dead.

What is Virtual Destructor?

Using virtual destructors, you can destroy objects without knowing their type - the correct
destructor for the object is invoked using the virtual function mechanism. Note that
destructors can also be declared as pure virtual functions for abstract classes.

if someone will derive from your class, and if someone will say "new Derived", where
"Derived" is derived from your class, and if someone will say delete p, where the actual
object's type is "Derived" but the pointer p's type is your class.

Can you think of a situation where your program would crash without reaching the
breakpoint which you set at the beginning of main()?

C++ allows for dynamic initialization of global variables before main() is invoked. It is
possible that initialization of global will invoke some function. If this function crashes the
crash will occur before main() is entered.

Name two cases where you MUST use initialization list as opposed to assignment in
constructors.

Both non-static const data members and reference data members cannot be assigned
values; instead, you should use initialization list to initialize them.

Can you overload a function based only on whether a parameter is a value or a

reference?

No. Passing by value and by reference looks identical to the caller.

What are the differences between a C++ struct and C++ class?

The default member and base class access specifiers are different.

The C++ struct has all the features of the class. The only differences are that a struct
defaults to public member access and public base class inheritance, and a class defaults to
the private access specifier and private base class inheritance.

What does extern "C" int func(int *, Foo) accomplish?

It will turn off "name mangling" for func so that one can link to code compiled by a C
compiler.

How do you access the static member of a class?

<ClassName>::<StaticMemberName>

What is multiple inheritance(virtual inheritance)? What are its advantages and

disadvantages?
Multiple Inheritance is the process whereby a child can be derived from more than one
parent class. The advantage of multiple inheritance is that it allows a class to inherit the
functionality of more than one base class thus allowing for modeling of complex
relationships. The disadvantage of multiple inheritance is that it can lead to a lot of
confusion(ambiguity) when two base classes implement a method with the same name.

What are the access privileges in C++? What is the default access level?

The access privileges in C++ are private, public and protected. The default access level
assigned to members of a class is private. Private members of a class are accessible only
within the class and by friends of the class. Protected members are accessible by the class
itself and it's sub-classes. Public members of a class can be accessed by anyone.

What is a nested class? Why can it be useful?

A nested class is a class enclosed within the scope of another class. For example:

// Example 1: Nested class

//
class OuterClass
{
class NestedClass
{
// ...
};
// ...
};
Nested classes are useful for organizing code and controlling access and dependencies.
Nested classes obey access rules just like other parts of a class do; so, in Example 1, if
NestedClass is public then any code can name it as OuterClass::NestedClass. Often
nested classes contain private implementation details, and are therefore made private; in
Example 1, if NestedClass is private, then only OuterClass's members and friends can use
NestedClass.

When you instantiate as outer class, it won't instantiate inside class.

What is a local class? Why can it be useful?

local class is a class defined within the scope of a function -- any function, whether a
member function or a free function. For example:

// Example 2: Local class

//
int f()
{
class LocalClass
 {
// ...
};
// ...
};
Like nested classes, local classes can be a useful tool for managing code dependencies.

Can a copy constructor accept an object of the same class as parameter, instead of
reference of the object?

No. It is specified in the definition of the copy constructor itself. It should generate an
error if a programmer specifies a copy constructor with a first argument that is an object
and not a reference.

if you have any comments/questions please email me at

copyright (c) 2004, Satish Shetty, All rights reserved,

visit my homepage at http://www.shettysoft.com

C interview questions and answers

By admin | December 23, 2003

1. What will print out?

main()
{
char *p1=“name”;
char *p2;
p2=(char*)malloc(20);
memset (p2, 0, 20);
while(*p2++ = *p1++);
printf(“%sn”,p2);

Answer:empty string.

2. What will be printed as the result of the operation below:

 main()
{
int x=20,y=35;
x=y++ + x++;
y= ++y + ++x;
printf(“%d%dn”,x,y);

Answer : 5794

3. What will be printed as the result of the operation below:

main()
{
int x=5;
printf(“%d,%d,%dn”,x,x< <2,x>>2);

Answer: 5,20,1

4. What will be printed as the result of the operation below:

#define swap(a,b) a=a+b;b=a-b;a=a-b;

void main()
{
int x=5, y=10;
swap (x,y);
printf(“%d %dn”,x,y);
swap2(x,y);
printf(“%d %dn”,x,y);
}

int swap2(int a, int b)

{
int temp;
temp=a;
b=a;
a=temp;
return 0;

}
 Answer: 10, 5
10, 5

5. What will be printed as the result of the operation below:

main()
{
char *ptr = ” Cisco Systems”;
*ptr++; printf(“%sn”,ptr);
ptr++;
printf(“%sn”,ptr);

Answer:Cisco Systems
isco systems

6. What will be printed as the result of the operation below:

main()
{
char s1[]=“Cisco”;
char s2[]= “systems”;
printf(“%s”,s1);
}

Answer: Cisco

7. What will be printed as the result of the operation below:

main()
{
char *p1;
char *p2;

p1=(char *)malloc(25);
p2=(char *)malloc(25);

strcpy(p1,”Cisco”);
strcpy(p2,“systems”);
strcat(p1,p2);

printf(“%s”,p1);

}
 Answer: Ciscosystems

8. The following variable is available in file1.c, who can access it?:

9. static int average;

Answer: all the functions in the file1.c can access the variable.

10. WHat will be the result of the following code?

#define TRUE 0 // some code

while(TRUE)
{

// some code

Answer: This will not go into the loop as TRUE is defined as 0.

11. What will be printed as the result of the operation below:

int x;
int modifyvalue()
{
return(x+=10);
}

int changevalue(int x)
{
return(x+=1);
}

void main()
{
int x=10;
x++;
changevalue(x);
x++;
modifyvalue();
printf("First output:%dn",x);

x++;
changevalue(x);
printf("Second output:%dn",x);
 modifyvalue();
printf("Third output:%dn",x);

Answer: 12 , 13 , 13

12. What will be printed as the result of the operation below:

main()
{
int x=10, y=15;
x = x++;
y = ++y;
printf(“%d %dn”,x,y);

Answer: 11, 16

13. What will be printed as the result of the operation below:

main()
{
int a=0;
if(a==0)
printf(“Cisco Systemsn”);
printf(“Cisco Systemsn”);

Answer: Two lines with “Cisco Systems” will be printed.

What is a node class?

A node class is a class that,
* relies on the base class for services and implementation,
* provides a wider interface to the users than its base class,
* relies primarily on virtual functions in its public interface
* depends on all its direct and indirect base class
* can be understood only in the context of the base class
* can be used as base for further derivation
* can be used to create objects.
A node class is a class that has added new services or functionality beyond the services
inherited from its base class.
What is a container class? What are the types of container classes?
A container class is a class that is used to hold objects in memory or external storage. A
container class acts as a generic holder. A container class has a predefined behavior and a
well-known interface. A container class is a supporting class whose purpose is to hide the
topology used for maintaining the list of objects in memory. When a container class
contains a group of mixed objects, the container is called a heterogeneous container;
when the container is holding a group of objects that are all the same, the container is
called a homogeneous container.

How do you write a function that can reverse a linked-list?

Answer1:

void reverselist(void)
{
if(head==0)
return;
if(head-<next==0)
return;
if(head-<next==tail)
{
head-<next = 0;
tail-<next = head;
}
else
{
node* pre = head;
node* cur = head-<next;
node* curnext = cur-<next;
head-<next = 0;
cur-<next = head;

for(; curnext!=0; )
{
cur-<next = pre;
pre = cur;
cur = curnext;
curnext = curnext-<next;
}

curnext-<next = cur;
}
}

Answer2:

node* reverselist(node* head)

{
if(0==head || 0==head->next)
//if head->next ==0 should return head instead of 0;
return 0;

{
node* prev = head;
node* curr = head->next;
node* next = curr->next;

for(; next!=0; )
{
curr->next = prev;
prev = curr;
curr = next;
next = next->next;
}
curr->next = prev;

head->next = 0;
head = curr;
}

return head;
}

What is polymorphism?
Polymorphism is the idea that a base class can be inherited by several classes. A base
class pointer can point to its child class and a base class array can store different child
class objects.

How do you find out if a linked-list has an end? (i.e. the list is not a cycle)
You can find out by using 2 pointers. One of them goes 2 nodes each time. The second
one goes at 1 nodes each time. If there is a cycle, the one that goes 2 nodes each time will
eventually meet the one that goes slower. If that is the case, then you will know the
linked-list is a cycle.

What is Boyce Codd Normal form?

A relation schema R is in BCNF with respect to a set F of functional dependencies if for
all functional dependencies in F+ of the form a-> , where a and b is a subset of R, at least
one of the following holds:
* a- > b is a trivial functional dependency (b is a subset of a)
* a is a superkey for schema R

What is virtual class and friend class?

Friend classes are used when two or more classes are designed to work together and need
access to each other's implementation in ways that the rest of the world shouldn't be
allowed to have. In other words, they help keep private things private. For instance, it
may be desirable for class DatabaseCursor to have more privilege to the internals of class
Database than main() has.

What is the word you will use when defining a function in base class to allow this
function to be a polimorphic function?
virtual

What do you mean by binding of data and functions?

Encapsulation.

How do I initialize a pointer to a function?

This is the way to initialize a pointer to a function
void fun(int a)
{

void main()
{
void (*fp)(int);
fp=fun;
fp(1);

How do you link a C++ program to C functions?

By using the extern "C" linkage specification around the C function declarations.

Explain the scope resolution operator.

It permits a program to reference an identifier in the global scope that has been hidden by
another identifier with the same name in the local scope.

What are the differences between a C++ struct and C++ class?
The default member and base-class access specifier are different.

How many ways are there to initialize an int with a constant?

Two.
There are two formats for initializers in C++ as shown in the example that follows. The
first format uses the traditional C notation. The second format uses constructor notation.
int foo = 123;
int bar (123);
How does throwing and catching exceptions differ from using setjmp and longjmp?
The throw operation calls the destructors for automatic objects instantiated since entry to
the try block.

What is a default constructor?

Default constructor WITH arguments class B { public: B (int m = 0) : n (m) {} int n; };
int main(int argc, char *argv[]) { B b; return 0; }

What is a conversion constructor?

A constructor that accepts one argument of a different type.

What is the difference between a copy constructor and an overloaded assignment

operator?
A copy constructor constructs a new object by using the content of the argument object.
An overloaded assignment operator assigns the contents of an existing object to another
existing object of the same class.

When should you use multiple inheritance?

There are three acceptable answers: "Never," "Rarely," and "When the problem domain
cannot be accurately modeled any other way."

Explain the ISA and HASA class relationships. How would you implement each in a
class design?
A specialized class "is" a specialization of another class and, therefore, has the ISA
relationship with the other class. An Employee ISA Person. This relationship is best
implemented with inheritance. Employee is derived from Person. A class may have an
instance of another class. For example, an employee "has" a salary, therefore the
Employee class has the HASA relationship with the Salary class. This relationship is best
implemented by embedding an object of the Salary class in the Employee class.

When is a template a better solution than a base class?

When you are designing a generic class to contain or otherwise manage objects of other
types, when the format and behavior of those other types are unimportant to their
containment or management, and particularly when those other types are unknown (thus,
the generosity) to the designer of the container or manager class.

What is a mutable member?

One that can be modified by the class even when the object of the class or the member
function doing the modification is const.

What is an explicit constructor?

A conversion constructor declared with the explicit keyword. The compiler does not use
an explicit constructor to implement an implied conversion of types. It’s purpose is
reserved explicitly for construction.
What is semaphore?
Semaphore is a special variable, it has two methods: up and down. Semaphore performs
atomic operations, which means ones a semaphore is called it can not be inturrupted.

The internal counter (= #ups - #downs) can never be negative. If you execute the “down”
method when the internal counter is zero, it will block until some other thread calls the
“up” method. Semaphores are use for thread synchronization.

Is C an object-oriented language?
C is not an object-oriented language, but limited object-oriented programming can be
done in C.

Name some major differences between C++ and Java.

C++ has pointers; Java does not. Java is platform-independent; C++ is not. Java has
garbage collection; C++ does not. Java does have pointers. In fact all variables in Java are
pointers. The difference is that Java does not allow you to manipulate the addresses of the
pointer

C++ Networking Interview Questions and Answers

What is the difference between Stack and Queue?

Stack is a Last In First Out (LIFO) data structure.
Queue is a First In First Out (FIFO) data structure

Write a fucntion that will reverse a string.

char *strrev(char *s)
{
int i = 0, len = strlen(s);
char *str;
if ((str = (char *)malloc(len+1)) == NULL)
/*cannot allocate memory */
err_num = 2;
return (str);
}
while(len)
str[i++]=s[–len];
str[i] = NULL;
return (str);
}

What is the software Life-Cycle?

The software Life-Cycle are
1) Analysis and specification of the task
2) Design of the algorithms and data structures
3) Implementation (coding)
4) Testing
5) Maintenance and evolution of the system
6) Obsolescence

What is the difference between a Java application and a Java applet?

The difference between a Java application and a Java applet is that a Java application is a
program that can be executed using the Java interpeter, and a JAVA applet can be
transfered to different networks and executed by using a web browser (transferable to the
WWW).

Name 7 layers of the OSI Reference Model?

-Application layer
-Presentation layer
-Session layer
-Transport layer
-Network layer
-Data Link layer
-Physical layer

C++ Algorithm Interview Questions and Answers

What are the advantages and disadvantages of B-star trees over Binary trees?

Answer1
B-star trees have better data structure and are faster in search than Binary trees, but it’s
harder to write codes for B-start trees.

Answer2
The major difference between B-tree and binary tres is that B-tree is a external data
structure and binary tree is a main memory data structure. The computational complexity
of binary tree is counted by the number of comparison operations at each node, while the
computational complexity of B-tree is determined by the disk I/O, that is, the number of
node that will be loaded from disk to main memory. The comparision of the different
values in one node is not counted.

Write the psuedo code for the Depth first Search.

dfs(G, v) //OUTLINE
Mark v as "discovered"
For each vertex w such that edge vw is in G:
If w is undiscovered:
dfs(G, w); that is, explore vw, visit w, explore from there as much as possible, and
backtrack from w to v. Otherwise:
"Check" vw without visiting w. Mark v as "finished".
Describe one simple rehashing policy.

The simplest rehashing policy is linear probing. Suppose a key K hashes to location i.
Suppose other key occupies H[i]. The following function is used to generate alternative
locations:
rehash(j) = (j + 1) mod h
where j is the location most recently probed. Initially j = i, the hash code for K. Notice
that this version of rehash does not depend on K.

Describe Stacks and name a couple of places where stacks are useful.

A Stack is a linear structure in which insertions and deletions are always made at one
end, called the top. This updating policy is called last in, first out (LIFO). It is useful
when we need to check some syntex errors, such as missing parentheses.

Suppose a 3-bit sequence number is used in the selective-reject ARQ, what is the
maximum number of frames that could be transmitted at a time?

If a 3-bit sequence number is used, then it could distinguish 8 different frames. Since the
number of frames that could be transmitted at a time is no greater half the numner of
frames that could be distinguished by the sequence number, so at most 4 frames can be
transmitted at a time.

What is the difference between Mutex and Binary semaphore?

semaphore is used to synchronize processes. where as mutex is used to provide
synchronization between threads running in the same process.

In C++, what is the difference between method overloading and method overriding?

Overloading a method (or function) in C++ is the ability for functions of the same name
to be defined as long as these methods have different signatures (different set of
parameters). Method overriding is the ability of the inherited class rewriting the virtual
method of the base class.

What methods can be overridden in Java?

In C++ terminology, all public methods in Java are virtual. Therefore, all Java methods
can be overwritten in subclasses except those that are declared final, static, and private.

What are the defining traits of an object-oriented language?

The defining traits of an object-oriented langauge are:
* encapsulation
* inheritance
* polymorphism

Write a program that ask for user input from 5 to 9 then calculate the average
int main()
{
int MAX=4;
int total =0;
int average=0;
int numb;
cout<<"Please enter your input from 5 to 9";
cin>>numb;
if((numb <5)&&(numb>9))
cout<<"please re type your input";
else
for(i=0;i<=MAX; i++)
{
total = total + numb;
average= total /MAX;
}
cout<<"The average number is"<<average<<endl;

return 0;
}

Assignment Operator - What is the diffrence between a "assignment operator" and

a "copy constructor"?
Answer1.
In assignment operator, you are assigning a value to an existing object. But in copy
constructor, you are creating a new object and then assigning a value to that object. For
example:
complex c1,c2;
c1=c2; //this is assignment
complex c3=c2; //copy constructor

Answer2.
A copy constructor is used to initialize a newly declared variable from an existing
variable. This makes a deep copy like assignment, but it is somewhat simpler:

There is no need to test to see if it is being initialized from itself.

There is no need to clean up (eg, delete) an existing value (there is none).
A reference to itself is not returned.

RTTI - What is RTTI?

Answer1.
RTTI stands for "Run Time Type Identification". In an inheritance hierarchy, we can find
out the exact type of the objet of which it is member. It can be done by using:

1) dynamic id operator
2) typecast operator

Answer2.
RTTI is defined as follows: Run Time Type Information, a facility that allows an object
to be queried at runtime to determine its type. One of the fundamental principles of object
technology is polymorphism, which is the ability of an object to dynamically change at
runtime.

STL Containers - What are the types of STL containers?

There are 3 types of STL containers:

1. Adaptive containers like queue, stack

2. Associative containers like set, map
3. Sequence containers like vector, deque

What is the need for a Virtual Destructor ?

Destructors are declared as virtual because if do not declare it as virtual the base class
destructor will be called before the derived class destructor and that will lead to memory
leak because derived class’s objects will not get freed.Destructors are declared virtual
so as to bind objects to the methods at runtime so that appropriate destructor is called.

What do you mean by inline function?

The idea behind inline functions is to insert the code of a called function at the point
where the function is called. If done carefully, this can improve the application's
performance in exchange for increased compile time and possibly (but not always) an
increase in the size of the generated binary executables.

What is the Standard Template Library (STL)?

A library of container templates approved by the ANSI committee for inclusion in the
standard C++ specification.
A programmer who then launches into a discussion of the generic programming model,
iterators, allocators, algorithms, and such, has a higher than average understanding of the
new technology that STL brings to C++ programming.

Describe run-time type identification.

The ability to determine at run time the type of an object by using the typeid operator or
the dynamic_cast operator.

What problem does the namespace feature solve?

Multiple providers of libraries might use common global identifiers causing a name
collision when an application tries to link with two or more such libraries. The
namespace feature surrounds a library’s external declarations with a unique namespace
that eliminates the potential for those collisions.
This solution assumes that two library vendors don’t use the same namespace identifier,
of course.

Are there any new intrinsic (built-in) data types?

Yes. The ANSI committee added the bool intrinsic type and its true and false value
keywords.

QuickCG Functions

Function Information
void screen(int width, int height, bool fullscreen, char* text=" ");
This is probably the most important function, because it creates the
graphical screen but also the whole SDL context. Always call this
function at the beginning of your programs, even if you don't need a
screen screen. The integers width and height determinate the resolution of your
window. If fullscreen is 0, it'll be a window, if it's 1, the graphics will
be drawn fullscreen. text can be used to give a title to the window. For
example to create a window of 640*480 pixels with the title "Hello",
use: screen(640,480,0,"Hello");
bool keyDown(int key);
After using the readKeys() or done() function for the current frame, this
function can check for every key whether or not it's pressed. For
keyDown
example, to check if the "a" button is pressed, check if
keyDown(SDLK_a) is true. For a full list of all the keys, see the SDL
Key table below.
bool keyPressed(int key);
The same as keyDown(), but while keyDown will return true as long as
the key is pressed, keyPressed will only return true the first time you
keyPressed check, and return true again only if the key has been released and
pressed again. So while keyDown would be useful in a game for a key
to walk forward, keyPressed can be used for a key that selects a
weapon.
void redraw();
This redraws the screen. If you draw things like pixels, circles and
redraw lines, you won't see them before you called redraw(); This function is
relatively slow though, so don't use it after every single pixel, but only
after you've drawn the whole screen.
cls void cls(int R = 0, int G = 0, int B = 0);
This clears the screen to black again. For example if you're making a
bouncing ball program you have to draw a circle at a new position
every time, but if you didn't use cls(), the old circles at old positions
will still be visible. You can also clear the screen to a certain RGB
 color.
void pset(int x, int y, ColorRGB color);
This function draws a pixel on the screen at position x, y (x has to be
pset between 0 and w-1, y has to be between 0 and h-1), with given RGB
color: ColorRGB color has 3 components r, g, b which are values
between 0 and 255
ColorRGB pget(int x, int y);
Returns the color value of the pixel at position x, y. This requires
reading the color from the memory of the video card, and is quite slow.
pget When you need this function a lot, for example if you're working with
transparency or flood fill, it's better to use a buffer to hold the colors,
read from this buffer, and draw this buffer to the screen with
drawBuffer.
void drawBuffer(Uint32 *buffer);
Draws a whole buffer at once to the screen. The buffer has to be exactly
drawBuffer
the same size as the screen, and is a 2D array. Color values are in 24-bit
format in one integer instead of 3 separate 8-bit variables. If it's
possible to use a buffer, it can be much faster than drawing each pixel
separately.
bool onScreen(int x, int y);
onScreen Checks if the point with coordinates x, y is on the screen: inside the
rectangle (0, 0) - ((w - 1), (h - 1)).
void sleep();
sleep When calling this function, the program will pause until you press any
key.
void waitFrame(double oldTime, double frameDuration);
This is made to be handy in cases where you want to limit an effect to a
maximum amount of frames per second. The parameter oldTime is the
waitFrame time of the previous frame after calling waitFrame that frame, and
frameDuration is the number of seconds per frame (e.g. 0.05 seconds
per frame is 20 frames per second). It waits until the minimum time
since the previous frame is passed.
bool done();
This function returns whether or not you want to close the program, that
is, if you press escape, or press the close button of the window. Use this
done
function in a while loop as follows: "while(!done()) {code goes
here}". Then the loop will keep running, until you press escape or the
close button of the window.
void end();
end
Calling this function immediately ends the program.
readKeys void readKeys();
 This function uses SDL Events to check what keys are pressed, and
gives the result to the global inkeys[] variable.
void getMouseState(int& mouseX, int& mouseY, bool& LMB, bool&
RMB);
Stores the position and pressed buttons of the mouse in the given
getMouseState variables (passed by reference) mouseX: the x coordinate of the mouse
cursor, mouseY: the y coordinate of the mouse cursor, LMB: true if the
left mouse button is pressed, RMB: true if the right mouse button is
pressed.
void getMouseState(int& mouseX, int& mouseY);
getMouseState
Stores the position of the mouse in the given variables (passed by
reference) mouseX: the x coordinate of the mouse cursor, mouseY: the
y coordinate of the mouse cursor.
long getTicks();
getTicks This function returns the time since the program started running in
milliseconds.
max(x, y)
max Returns the maximum of x and y, works with anything: it's defined with
preprocessor commands.
min(x, y)
min Returns the minimum of x and y, works with anything: it's defined with
preprocessor commands.
bool horLine(int y, int x1, int x2, ColorRGB color);
horLine Draw a horizontal line from position x1, y to x2, y with given color. It's
a bit faster than using drawLine() if you need a horizontal line.
bool verLine(int x, int y1, int y2, ColorRGB color);
verLine Draw a vertical line from position x1, y to x2, y with given color. It's a
bit faster than using drawLine() if you need a vertical line.
bool drawLine(int x1, int y1, int x2, int y2, ColorRGB color);
Draw a line from x1, y1 to x2, y2 with given color, using the
Bresenham line drawing algorithm. Note that all coordinates must lie
drawLine inside the screen, or the program will crash. You can use clipLine() in
combination with drawLine() if you need to draw an arbitrary line,
because the line function itself can't draw lines outside the screen and
will return 0 it any of the endpoints lies outside the screen.
bool drawCircle(int xc, int yc, int radius, ColorRGB color);
drawCircle Draw a circle with it's center at xc,yc, with radius radius, and RGB
color red, green, blue. This is an unfilled circle.
bool drawCisk(int xc, int yc, int radius, ColorRGB color);
drawDisk
Like circle, but this time it's filled.
 bool drawRect(int x1, int y1, int x2, int y2, ColorRGB color);
drawRect
Draw a rectangle with corners in x1,y1 and x2, y2, with given color.
bool clipLine(int x1, int y1, int x2, int y2, int & x3, int & y3, int & x4,
int & y4);
Use this if you need to bring the endpoints of a line you're trying to
draw into the screen. Give the function a line with coordinates x1,y1-
x2,y2, and it'll return a line with coordinates x3,y3-x4,y4 that are on the
edges or inside the screen (that is, inside the rectangle 0,w-0,h).
clipLine
x3,y3,x4 and y4 have to be given to the function by reference, so for
example use "clipLine(x1, y1, x2, y2, x3, y3, x4, y4)",
where x3, y3, x4 and y4 are normal integers that can be changed by the
function, to give the coordinates of the new line to those variables. The
function returns 1 if the line is on the screen and 0 if the line isn't on the
screen.
ColorHSL RGBtoHSL(ColorRGB colorRGB);
RGBtoHSL
Converts a color from the RGB to the HSL color model.
ColorRGB HSLtoRGB(ColorHSL colorHSL);
HSLtoRGB
Converts a color from the HSL to the RGB color model.
ColorHSV RGBtoHSV(ColorRGB colorRGB);
RGBtoHSV
Converts a color from the RGB to the HSV color model.
ColorRGB HSVtoRGB(ColorHSV colorHSV);
HSVtoRGB
Converts a color from the HSV to the RGB color model.
Uint32 RGBtoINT(ColorRGB colorRGB);
RGBtoINT Converts a color from RGB to a single integer for the video hardware
memory structure
ColorRGB INTtoRGB(Uint32 colorINT);
INTtoRGB Converts a color from a single integer to 3 bytes: r, g, and b from the
ColorRGB struct.
int loadImage(std::vector& out, unsigned long& w, unsigned long& h,
const std::string& filename)
loads a PNG image (no other image formats supported) with given
loadImage
filename into the std::vector. Also returns the width and height of the
image. If there happens a problem during loading, the function returns
"1" which means "error".
int loadImage(std::vector& out, unsigned long& w, unsigned long& h,
const std::string& filename)
loadImage
The same as the other loadImage function, but stores the color in
Uint32's instead, which is the format for SDL.
print template<typename T> int print(const T& val, int x = 0, int y = 0, const
ColorRGB& color = RGB_White, bool bg = 0, const ColorRGB&
color2 = RGB_Black);
 Draws a text on screen, using the standard IBM ASCII font, made out
of 256 characters of 8*8 pixels each.
"*text" is the text you want to output, "x" and "y" the location (in
pixels) of the top left corner of the first letter, "color" the foreground
color, "color2" the background, and bg whether or not the background
should be visible: if bg is 0, the background is invisible, if gb is 1, it's
fully opaque. The parameter forceLength is the minimum length that
should be printed, if the string is shorter, it prints 0 characters behind it
(useful if background is enabled and want to draw over a certain fixed
length). The return value is h * x + y where x is x position of next letter,
y is y position of next letter and h is height of the screen. This return
value is useful to find the start location for a possible next print
command that should be behind the previous text: x coordinate is then
returnvalue / h, y coordinate is returnvalue % h.
void getInputString(std::string& text, const std::string& message = "",
bool clear = false, int x = 0, int y = 0, const ColorRGB& color =
getInputString
RGB_White, bool bg = 0, const ColorRGB& color2 = RGB_Black);
Prints the message, after the message you can enter a string, which is
stored in text. The boolean "clear" determines if the text is still visible
after the user pressed enter.
template<typename T> T getInput(const std::string& message = "",
getInput
bool clear = false, int x = 0, int y = 0, const ColorRGB& color =
RGB_White, bool bg = 0, const ColorRGB& color2 = RGB_Black);
Convert user input into arbitrary variables.

C++ Operators

Operator Information
Add, Subtract, Multiply and Divide. Some of these are also defined for
+, -, *, /
QuickCG's matrices and vectors
% Modulo Division
& Bitwise AND
| Bitwise OR
^ Bitwise XOR
= Set equal to
Operators for conditions
&&, || Logical AND and OR (to use in conditions)
== Is it equal?
!= Not equal to
>,<, >=,
Greater than, Smaller than, Greater than or equal to, Smaller than or equal to
<=

C++ Functions

Some of those come from the standard header file <cmath>, so they're in the namespace
std. The line "using namespace std;" is put on top of the code though, so you don't need to
to add "std::" in front of the functions. This tutorial focuses on the algorithms and the
math and it's easier to recognise mathematical functions if there's no "std::" in front of
them.

Function Information
sqrt(x) The square root of x
cos(x), sin(x),
Cosine, Sine and Tangent (in radians)
tan(x)
acos(x), asin(x),
The inverse of Cosine, Sine and Tangent
atan(x)
pow(x, y) The power of one real number to another
ln(x) Natural Logarithm
exp(x) The exponential of a real number
Convert to integer or to floating point number. When dividing two
int(x), float(x),
integers through each other, the result will be an integer unless you
double(x)
convert one to a float.
Returns the next lowest integer, e.g. 3.1 becomes 3.0. Only works on
floor(x)
floating point numbers and doubles.
Returns the next highest integer, e.g. 3.1 becomes 4.0. Only works on
ceil(x)
floating point numbers and doubles.
Returns the absolute value of x. The function abs is for integers, while
abs(x), fabs(x)
fabs is for floating point numbers and doubles.