Class declaration and definition

A class declaration is anything, essentially, that tells the compiler a name is for a class. For example;

C++ Syntax

class  ClassName;

is known as a "forward declaration".

A class definition is a type of declaration that provides enough information that a compiler can create instances of the class, compute sizeof() for the class, call member functions, and access data members of the class.

A class with "prototypes of member functions" is one type of class definition.

A class "with member functions defined in the class" is another type of class definition - the only difference is that it is a class definition with inline definitions of member functions.

Including header types

In C++ it's common to see two methods of including a header file:

#include
#include "filename"

The difference between the two varies on the compiler you are using, however the rule of thumb is that the first version, between the "<" and ">", will have the compiler search for filename in a series of predefined paths. It is the standard to use the #include form when including header files that are part of the C++ standard library, such as iostream or cstdlib.
The second form of including a header file is meant mostly for custom header files that are located in the same path as the C++ application itself

Try out when free

You are given an arbitrarily long string of parentheses i.e. a string comprising of '(' and ')'.

Give an efficient way of finding whether a given string contains a balanced parentheses or not. Note that the string can be of any length.

A string with balanced parentheses is a string containing same number of left parentheses '(' and right parentheses ')'. Also, they must be in correct order i.e. ( ( ) ( ) ) is balanced whereas ( ) ) ( ( ) is not.

Memory CORRUPTION

From Wikipedia, the free encyclopedia

Memory corruption happens when the contents of a memory location are unintentionally modified due to programming errors. When the corrupted memory contents are used later in the computer program, it leads either to program crash or to strange and bizarre program behavior.

Modern programming languages like C and C++ have powerful features of explicit memory management and pointer arithmetic. These features are designed for developing efficient applications and system software. But when these features are used incorrectly, it may lead to memory corruption errors.

Memory corruption is one of the most intractable class of programming errors because of two reasons. First, the source of the memory corruption and its manifestation may be far apart making it hard to correlate the cause and the effect. Second, symptoms appear under unusual conditions, making it hard to consistently reproduce the error.

Memory corruption errors can be broadly classified into four categories:

1. Using un-initialized memory: Contents of un-initialized memory are considered
to be garbage values and using these values can lead to unpredictable program
behavior.
2. Using un-owned memory: It is common to use pointers for accessing and modifying
memory. If a pointer happens to be a null pointer, dangling pointer (pointing
to memory that has already been freed), or to a memory location outside of
current stack or heap bounds, it is referring to memory that is not currently
possessed by the program. And using such pointer is a serious programming
flaw. Writing to such memory can crash another program or even the operating
system.
3. Using beyond allocated memory (buffer overflow): If an array is used in a
loop, with incorrect terminating condition, memory beyond the array bounds may
be manipulated. Buffer overflow is one of the most common programming flaw
exploited by computer viruses causing serious computer security issues (e.g.
Return-to-libc attack, Stack-smashing protection) in widely used programs.
4. Faulty heap memory management: Memory leaks and freeing non-heap or unallocated
memory are the most frequent errors caused by faulty heap memory management.

Many memory debuggers such as Purify, Valgrind, Insure++ are available for detecting memory corruption errors.

Memory is said to be corrupted if we try one of the following :

* Free a dynamic variable that has already been freed

char *str = new char[100];
delete [] str;
delete [] str;

* Free a dynamic variable that has not been yet allocated

char *str;
delete str;

* Assign a certain value to a dynamic variable that was never allocated

char *str;
strcpy(str, "error");

The previous three examples will most probably cause the application to crash. However the next two "bugs" are harder to detect :

* Assign a certain value to a dynamic variable, after it has been freed (this may also affect other data stored in the heap)

char *str = new char[100];
delete [] str;
char *test = new char[100];
strcpy(str, "surprise !");
cout << test;
delete [] test;

* Access an element with an index out of range

char *str = new char[30];
str[40] = 'C';

Multi Threading Interview Questions

 
Q1) What are the two types of multitasking?
Ans : 1.process-based 2.Thread-based

Q2) What are the two ways to create the thread?
Ans : 1.By implementing Runnable 2.By extending Thread

Q3) What is the signature of the constructor of a thread class?
Ans : Thread(Runnable threadob,String threadName,Thread_KIND) //this depends on API

Q4) What are all the methods available in the Runnable Interface?
Ans : Run()

Q5) What is the data type for the method isAlive() and this method is available in which class? Ans : boolean, class Thread

Q6) What are all the methods available in the Thread class?
Ans : 1.isAlive() 2.join() 3.resume() 4.suspend() 5.stop() 6.start() 7.sleep() 8.destroy()

Q7) What are all the methods used for Inter Thread communication and what is the class in which these methods are defined?
Ans : 1. wait(),notify() & notifyall() 2. Object class

Q8) What is the mechanism defind by CPP for the Resources to be used by only one Thread at a time?
Ans : Synchronisation //find out how to achieve this

Q9) What is the procedure to own the monitor by many threads?
Ans : not possible ??

Q10) What is the unit for 1000 in the below statement?
objThrd.sleep(1000)
Ans : milliseconds

Q11) What is the data type for the parameter of the sleep() method?
Ans : long

Q12) What are all the values for the following level? max-priority , min-priority , normal-priority
Ans : 10,1,5 // varies with the API 100,0,50

Q13) What is the method available for setting the priority?
Ans : SetPriority()

Q14) What is the default thread at the time of starting the program?
Ans : Main thread

Q15) What are all the four states associated in the thread?
Ans : 1. new 2. runnable 3. blocked 4. dead

Q16) The suspend() method is used to teriminate a thread? True /False
Ans : False

Q17) The run() method should necessary exists in classes created as subclass of thread? True /False
Ans : True

Q18) When two threads are waiting on each other and can't proceed the programme is said to be in a deadlock? True/False
Ans : True

19) Which method waits for the thread to die ?
Ans : join() method

20) Which of the following is true? 1) wait(),notify(),notifyall() are defined as final & can be called only from with in a synchronized method 2) Among wait(),notify(),notifyall() the wait() method only throws IOException 3) wait(),notify(),notifyall() & sleep() are methods of object class
A-1
B-2
C-3
D-1 & 2
E-1,2 & 3
Ans : D

21) What is meant by timeslicing or time sharing?
Ans : Timeslicing is the method of allocating CPU time to individual threads in a priority schedule.

22) What is meant by daemon thread? In java runtime, what is it's role? //GC is.nET/Java Specific
Ans : Daemon thread is a low priority thread which runs intermittently in the background doing the garbage collection operation for the java runtime system.

Copy Constructor

A Copy Constructor is a special type of constructor in the C++ programming language used to creat a new objects a copy of another of an existing object. This constructor takes single argument : a reference of the object to be copied.
Normally the compiler automatically creates a copy constructor for each class (known as an implicit copy constructor) but for special cases the programmer creates a copy constructor, known as a explicit copy constructor. In such cases, the complier doesnt create the implicit one.
A copy constructor is generally needed when an object owns pointers or non-sharable references such as to a file and then you usually need a destructor and assignement operator too.
Copying of objects is achieved by the use of a copy constructor and a copy assignment operator. A copy constructor has as its first parameter a (possibly const or volatile) reference to its own class type. It can have more arguments, but the rest must have default values associated with them.

There are four instances when a copy constructor is called:
1) When an object is returned by value
2) When an object is passed (into a function) by value as an argument
3) When an object is constructed based on other object (pf same class)
4) When compiler generates a temporary object (e.g.-as in explicit casting)

Examples:
These examples illustrate how copy constructors work and why they are required sometimes.

The Implicit Copy Constructor

#include "iostream.h"
class Person
{
public:
int age;
Person(int age): age(age) {}
};
int main()
{
Person timmy(10);
Person sally(15);
Person timmy_clone = timmy;
std::cout << timmy.age << " " << sally.age << " " << timmy_clone.age << std::endl;
timmy.age = 23;
std::cout << timmy.age << " " << sally.age << " " << timmy_clone.age << std::endl;
return 0;
}
OutPut:
10 15 10
23 15 10

As expected, timmy has been copied to the new object, timmy_clone. While timmys age was changed, timmy_clones age remained the same. This is because they are totally different objects.
The compiler has generated a copy constructor for us, and it could be written like this:

Person(Person const& copy):age(copy.age) {}

The Explicit Copy Constructor:

#include "iostream.h"
class Array
{
public:
int size;
int* data;
Array(int size): size(size), data(new int[size]) {}
~Array()
{
delete[] data;
}
};
int main()
{
Array first(20);
first.data[0] = 25;
{
Array copy = first;
std::cout << first.data[0] << " " << copy.data[0] << std::endl;
} // (1)

first.data[0] = 10; // (2)
return 0;
}

OutPut:
25 25
Segmentation fault

Since we didn't specify a copy constructor, the compiler generated one for us. The generated constructor would look something like

Array(Array const& copy): size(copy.size), data(copy.data) {}

The problem with this constructor is that it performs a shallow copy of the data pointer. It only copies the address but not the actual data. When the program reaches line (1), copy`s destructor will get called (because objects on the stack are destroyed automatically when their scope ends). As you can see, Arrays destructor deletes the data array, therefore when it deleted copys data, it also deleted firsts data. Line (2) now accesses invalid data and writes to it! This produces the famous Segmentation Fault.
If we write our own copy constructor that performs a deep copy then this problem goes away.

Array(Array const& copy): size(copy.size), data(new int[copy.size])
{
std::copy(copy.data, copy.data + copy.size, data); // #include for std::copy
}

Here, we are creating a new int array and copying the contents to it. Now, copys destructor only deletes its data and not firsts data as well. Line (2) will not produce a segmentation fault anymore.
Instead of doing a deep copy right away, there are some optimization strategies that can be used. These allow you to safely share the same data between several objects, thus saving space. The Copy on write strategy makes a copy of the data only when it is written to. Reference counting keeps the count of how many objects are referencing the data, and will delete it only when this count reaches zero (e.g boost::shared_ptr).

If you still want to know more for Copy constructor then please go through the following link also
(1)http://www.fredosaurus.com/notes-cpp/oop-condestructors/copyconstructors.html
(2)http://cse.stanford.edu/class/cs193d/handouts/14CopyConstructors.pdf

Converting int to string(CString) in MFC

int nVAl = 10;
CString strConverter;
strConverter.Format("%d",nVal);
::AfxMessageBox(strConverter);

another method is native itoa

int nVAl = 10;
char strBuf[3];
_itoa( nVal,strBuf,3,10); // here 10 is radix
CString strForCnvrsn(strBuf);
::AfxMessageBox(strForCnvrsn);