YUVA....ROCKZZZZZZZZZZZZZ...........................................

http://rapidshare.com/files/260857783/aagaya_vennilave.mp3

Many companies and institutes are making group discussion as the first criteria for screening the candidates for face-to-face interviews. And there is reason too for giving huge importance for Group Discussion. First thing Group Discussion is used for mass elimination! And second thing group discussion selection criteria’s are based on actual company requirements.

Communication and Group Discussion skill are two relevant soft skills that are must for software testers.

Why group discussion should be the first criteria for selecting software testers?

Software tester requires communication with different people like team members, managers and customers. So interpersonal skill is very important for tester.

Yesterday one of our readers mailed me about her problem. She is very good at work but when it comes to taking credit for her work, someone else is taking the credit.

Why this is happening? She is lagging in interpersonal skills. Lagging in communication. She might be proficient in many skills, but what if she isn’t able to communicate her thoughts in front of her seniors or evaluators? Simply, she will lose the credits of her own work!

Making a good impression while speaking in meetings or interviews is the basic skill every professional should have. Let’s see how you can make this impression.

What skills are judged in group discussion?

Do’s and Don’ts of Group discussion:

1) Keep eye contact while speaking:
Do not look at the evaluators only. Keep eye contact with every team member while speaking.

2) Initiate the GD:
Initiating the GD is a big plus. But keep in mind - Initiate the group discussion only when you understood the GD topic clearly and have some topic knowledge. Speaking without proper subject knowledge is bad impression.

3) Allow others to speak:
Do not interrupt anyone in-between while speaking. Even if you don’t agree with his/her thoughts do not snatch their chance to speak. Instead make some notes and clear the points when it’s your turn.

4) Speak clearly:
Speak politely and clearly. Use simple and understandable words while speaking. Don’t be too aggressive if you are disagreeing with someone. Express your feelings calmly and politely.

5) Make sure to bring the discussion on track:
If by any means group is distracting from the topic or goal then simply take initiative to bring the discussion on the track. Make all group members aware that you all need to come to some conclusion at the end of the discussion. So stick to the topic.

6) Positive attitude:
Be confident. Do not try to dominate anyone. Keep positive body language. Show interest in discussion.

7) Speak sensibly:
Do not speak just to increase your speaking time. Don’t worry even if you speak less. Your thoughts should be sensible and relevant instead of irrelevant speech.

8 ) Listen carefully to others:
Speak less and listen more! Pay attention while others are speaking. This will make coherent discussion and you will get involved in the group positively. You will surely make people agree with you.

9) No need to go into much details:
Some basic subject analysis is sufficient. No need to mention exact figures while giving any reference. You have limited time so be precise and convey your thoughts in short and simple language.

10) Formal dressing:
Do not take it casually. No fancy and funny dressing. You should be comfortable while speaking in group. Positive gesture and body language will make your work easy.

Follow these 10 simple rules to easily crack the GD.

A group discussion or GD, is a form of many-on-many discussion. It has become an inseparable part of admissions to management institutes and your selection in campus interviews.

A GD is held to identify certain traits that companies and institutes like to see in their employees or students. Let's take a look at the traits which the evaluators look out for in a candidate during the GD. �

~ Knowledge: Whatever you do in a GD, your knowledge about the subject can't be replaced by anything else. You are required to talk in a GD but inputs that don't contain any substantial value will not help in any way. Be a voracious reader to increase your knowledge on various subjects. Newspapers, TV, magazines, news portals etc are great sources of knowledge.

~ Alertness and presence of mind: In a GD you are required to carefully listen to the other person's thoughts and keep an argument, example or a supportive statement, fact, example ready to participate in the discussion. Here comes into picture your alertness and ability to think and act immediately. As you participate in a GD, make sure that you sit with an attentive mind and keep taking down the relevant points put forward by others.

�

~ Communication: You may have a lot of good points to put across but if you can't communicate them clearly, you won't stand a chance when it comes to impressing the evaluators. Practice communicating in a clear and effective way with your friends, family or study group.

~ Confidence: Your self confidence adds a lot of value to your candidature. Look at every group member as you speak, avoid too much hand movement and looking at evaluators.

~ Leadership and team skills: Your participation in a GD clearly establishes not only your leadership skills but also your capability to work in a team. To meet the objectives, a good leader has to be a team player.

~ Goal orientation: Since so many people participate in a GD, the chances of the discussion moving away from the subject are high. Your focus on the goal can get you some extra points.

Now, as you are being evaluated for the above discussed traits, you must avoid things that can work to your disadvantage and might cost you the selection. Here are some things that you must avoid doing as a GD participant:

~ Initiating the discussion without proper subject knowledge
Although initiating the discussion helps you get the immediate attention of the evaluators, sharing irrelevant details just for teh sake of talking can work to your disadvantage. Start first only if you know the subject well otherwise wait for others to start and get a feel of the subject before entering into the discussion.

~ Snatching another's chance to speak
Give your group members a chance to speak. Talking more won't get you through the GD. In fact it will give the evaluators a feeling that you are not a team player. Making short and relevant contributions of 20-30 seconds 3-4 times in the discussion is enough.

�

~ Interrupting others

Let the other person finish his comment before you speak. Interrupting someone is counted as a negative trait. Remember, it is a discussion not a debate. Don't jump at the conclusions. Listen carefully to the other person before putting your point across.��

~ Dialogue
In a GD you are expected to communicate with all the members of the group. Do not keep looking at one person while talking. Establish eye contact with all the members of the group. It is a many-on-many discussion not one-on-one.

~ Shouting or dominating
Keep you emotions in check. Do not try to dominate the others or let your emotions rule you. Sometimes it might happen that a group member might say something that hurts your feelings such as a comment on your race or religion, make sure that you do not get into an argument. Your focus should be to effectively meet the goals of GD topic.

~ Showing off
You have to put across your knowledge on the subject during the GD but you have to be very careful about the thin demarcation between showing off and knowledge sharing. For eg, using statistics and facts during the GD is a good thing to do but you must not overdo it enough to nauseate the group members.

~ Low self confidence or insecurities
As we have seen earlier, one of the traits evaluated during a GD is your self confidence. Do not hesitate to speak confidently, even if you might be short of ideas or knowledge on the subject. Listen to others and put across your thoughts in a clear and audible voice. Make sure that you make eye contact with all the group members.

~ Slang and negative gestures
GD is a formal discussion. Avoid informal words and negative gestures. For eg avoid words like gonna, wanna, ya etc. Similarly avoid gestures like pointing fingers, tapping the desk with the pen.

If you ensure that you do not commit these mistakes during the GD, you will not have to worry too much about the negative marks and your chances of getting through it also become much brighter.

Key GD tips, revealed!

Let's go on to how GD is initiated and summarised.

A group discussion can be categorically divided into three different phases:

i. Initiation/ Introduction

ii. Body of the group discussion

iii. Summarisation/ Conclusion

Let's stress on the initiation and summarisation:

Initiation Techniques

Initiating a GD is a high profit-high loss strategy.

When you initiate a GD, you not only grab the opportunity to speak, you also grab the attention of the examiner and your fellow candidates.

If you can make a favourable first impression with your content and communication skills after you initiate a GD, it will help you sail through the discussion.

But if you initiate a GD and stammer/ stutter/ quote wrong facts and figures, the damage might be irreparable.

If you initiate a GD impeccably but don't speak much after that, it gives the impression that you started the GD for the sake of starting it or getting those initial kitty of points earmarked for an initiator!

When you start a GD, you are responsible for putting it into the right perspective or framework. So initiate one only if you have indepth knowledge about the topic at hand.

There are different techniques to initiate a GD and make a good first impression:

i. Quotes
ii. Definition
iii. Question
iv. Shock statement
v. Facts, figures and statistics
vi. Short story
vii. General statement

~ Quotes

Quotes are an effective way of initiating a GD.

If the topic of a GD is: Should the Censor Board be abolished?, you could start with a quote like, 'Hidden apples are always sweet'.

For a GD topic like, Customer is King, you could quote Sam (Wal-mart) Walton's famous saying, 'There is only one boss: the customer. And he can fire everybody in the company -- from the chairman on down, simply by spending his money somewhere else.'

~ Definition

Start a GD by defining the topic or an important term in the topic.

For example, if the topic of the GD is Advertising is a Diplomatic Way of Telling a Lie, why not start the GD by defining advertising as, 'Any paid form of non-personal presentation and promotion of ideas, goods or services through mass media like newspapers, magazines, television or radio by an identified sponsor'?

For a topic like The Malthusian Economic Prophecy is no longer relevant, you could start by explaining the definition of the Malthusian Economic Prophecy.

~ Question

Asking a question is an impactful way of starting a GD.

It does not signify asking a question to any of the candidates in a GD so as to hamper the flow. It implies asking a question, and answering it yourself.

Any question that might hamper the flow of a GD or insult a participant or play devil's advocate must be discouraged.

Questions that promote a flow of ideas are always appreciated.

For a topic like, Should India go to war with Pakistan, you could start by asking, 'What does war bring to the people of a nation? We have had four clashes with Pakistan. The pertinent question is: what have we achieved?'

~ Shock statement

Initiating a GD with a shocking statement is the best way to grab immediate attention and put forth your point.

If a GD topic is, The Impact of Population on the Indian Economy, you could start with, 'At the centre of the Indian capital stands a population clock that ticks away relentlessly. It tracks 33 births a minute, 2,000 an hour, 48,000 a day. Which calculates to about 12 million every year. That is roughly the size of Australia. As a current political slogan puts it, 'Nothing's impossible when 1 billion Indians work together'.'

~ Facts, figures and statistics

If you decide to initiate your GD with facts, figure and statistics, make sure to quote them accurately.

Approximation is allowed in macro level figures, but micro level figures need to be correct and accurate.

For example, you can say, approximately 70 per cent of the Indian population stays in rural areas (macro figures, approximation allowed).

But you cannot say 30 states of India instead of 28 (micro figures, no approximations).

Stating wrong facts works to your disadvantage.

For a GD topic like, China, a Rising Tiger, you could start with, 'In 1983, when China was still in its initial stages of reform and opening up, China's real use of Foreign Direct Investment only stood at $636 million. China actually utilised $60 billion of FDI in 2004, which is almost 100 times that of its 1983 statistics."

~ Short story

Use a short story in a GD topic like, Attitude is Everything.

This can be initiated with, 'A child once asked a balloon vendor, who was selling helium gas-filled balloons, whether a blue-coloured balloon will go as high in the sky as a green-coloured balloon. The balloon vendor told the child, it is not the colour of the balloon but what is inside it that makes it go high.'

~ General statement

Use a general statement to put the GD in proper perspective.

For example, if the topic is, Should Sonia Gandhi be the prime minister of India?, you could start by saying, 'Before jumping to conclusions like, 'Yes, Sonia Gandhi should be', or 'No, Sonia Gandhi should not be', let's first find out the qualities one needs to be a a good prime minister of India. Then we can compare these qualities with those that Mrs Gandhi possesses. This will help us reach the conclusion in a more objective and effective manner.'

Summarisation Techniques

Most GDs do not really have conclusions. A conclusion is where the whole group decides in favour or against the topic.

But every GD is summarised. You can summarise what the group has discussed in the GD in a nutshell.

Keep the following points in mind while summarising a discussion:

• Avoid raising new points.
• Avoid stating only your viewpoint.
• Avoid dwelling only on one aspect of the GD.
• Keep it brief and concise.
• It must incorporate all the important points that came out during the GD.
• If the examiner asks you to summarise a GD, it means the GD has come to an end. Do not add anything once the GD has been summarised.

1.What is C language?
A..The C programming language is a standardized programming language developed in the early 1970s by Ken Thompson and Dennis Ritchie for use on the UNIX operating system. It has since spread to many other operating systems, and is one of the most widely used programming languages. C is prized for its efficiency, and is the most popular programming language for writing system software, though it is also used for writing applications.

2.What does static variable mean?

A.there are 3 main uses for the static.
1. If you declare within a function:
It retains the value between function calls

2.If it is declared for a function name:
By default function is extern..so it will be visible from other files if the function declaration is as static..it is invisible for the outer files

3. Static for global variables:
By default we can use the global variables from outside files If it is static global..that variable is limited to with in the file

3.What are the different storage classes in C ?

A.C has three types of storage: automatic, static and allocated.

Variable having block scope and without static specifier have automatic storage duration.

Variables with block scope, and with static specifier have static scope. Global variables (i.e, file scope) with or without the the static specifier also have static scope.

Memory obtained from calls to malloc(), alloc() or realloc() belongs to allocated storage class.

4.What is hashing?

A.To hash means to grind up, and that’s essentially what hashing is all about. The heart of a hashing algorithm is a hash function that takes your nice, neat data and grinds it into some random-looking integer.

The idea behind hashing is that some data either has no inherent ordering (such as images) or is expensive to compare (such as images). If the data has no inherent ordering, you can’t perform comparison searches.

If the data is expensive to compare, the number of comparisons used even by a binary search might be too many. So instead of looking at the data themselves, you’ll condense (hash) the data to an integer (its hash value) and keep all the data with the same hash value in the same place. This task is carried out by using the hash value as an index into an array.

To search for an item, you simply hash it and look at all the data whose hash values match that of the data you’re looking for. This technique greatly lessens the number of items you have to look at. If the parameters are set up with care and enough storage is available for the hash table, the number of comparisons needed to find an item can be made arbitrarily close to one.

One aspect that affects the efficiency of a hashing implementation is the hash function itself. It should ideally distribute data randomly throughout the entire hash table, to reduce the likelihood of collisions. Collisions occur when two different keys have the same hash value.

There are two ways to resolve this problem. In open addressing, the collision is resolved by the choosing of another position in the hash table for the element inserted later. When the hash table is searched, if the entry is not found at its hashed position in the table, the search continues checking until either the element is found or an empty position in the table is found.

The second method of resolving a hash collision is called chaining. In this method, a bucket or linked list holds all the elements whose keys hash to the same value. When the hash table is searched, the list must be searched linearly.

5.Can static variables be declared in a header file?

A.You can’t declare a static variable without defining it as well (this is because the storage class modifiers static and extern are mutually exclusive). A static variable can be defined in a header file, but this would cause each source file that included the header file to have its own private copy of the variable, which is probably not what was intended.

6.Can a variable be both const and volatile?

A.Yes. The const modifier means that this code cannot change the value of the variable, but that does not mean that the value cannot be changed by means outside this code. For instance, in the example in FAQ 8, the timer structure was accessed through a volatile const pointer. The function itself did not change the value of the timer, so it was declared const. However, the value was changed by hardware on the computer, so it was declared volatile. If a variable is both const and volatile, the two modifiers can appear in either order.

7.Can include files be nested?

Answer Yes. Include files can be nested any number of times. As long as you use precautionary measures , you can avoid including the same file twice. In the past, nesting header files was seen as bad programming practice, because it complicates the dependency tracking function of the MAKE program and thus slows down compilation. Many of today’s popular compilers make up for this difficulty by implementing a concept called precompiled headers, in which all headers and associated dependencies are stored in a precompiled state.
Many programmers like to create a custom header file that has #include statements for every header needed for each module. This is perfectly acceptable and can help avoid potential problems relating to #include files, such as accidentally omitting an #include file in a module.

8.What is a null pointer?

A.There are times when it’s necessary to have a pointer that doesn’t point to anything. The macro NULL, defined in , has a value that’s guaranteed to be different from any valid pointer. NULL is a literal zero, possibly cast to void* or char*. Some people, notably C++ programmers, prefer to use 0 rather than NULL.
The null pointer is used in three ways:
1) To stop indirection in a recursive data structure
2) As an error value
3) As a sentinel value
9.printf() Function
What is the output of printf("%d")?

A.1. When we write printf("%d",x); this means compiler will print the value of x. But as here, there is nothing after %d so compiler will show in output window garbage value.

2. When we use %d the compiler internally uses it to access the argument in the stack (argument stack). Ideally compiler determines the offset of the data variable depending on the format specification string. Now when we write printf("%d",a) then compiler first accesses the top most element in the argument stack of the printf which is %d and depending on the format string it calculated to offset to the actual data variable in the memory which is to be printed. Now when only %d will be present in the printf then compiler will calculate the correct offset (which will be the offset to access the integer variable) but as the actual data object is to be printed is not present at that memory location so it will print what ever will be the contents of that memory location.

3. Some compilers check the format string and will generate an error without the proper number and type of arguments for things like printf(...) and scanf(...).
malloc()

10.What is the difference between "calloc(...)" and "malloc(...)"?

A.1. calloc(...) allocates a block of memory for an array of elements of a certain size. By default the block is initialized to 0. The total number of memory allocated will be (number_of_elements * size).

malloc(...) takes in only a single argument which is the memory required in bytes. malloc(...) allocated bytes of memory and not blocks of memory like calloc(...).

2. malloc(...) allocates memory blocks and returns a void pointer to the allocated space, or NULL if there is insufficient memory available.

calloc(...) allocates an array in memory with elements initialized to 0 and returns a pointer to the allocated space. calloc(...) calls malloc(...) in order to use the C++ _set_new_mode function to set the new handler mode.

11.printf() Function- What is the difference between "printf(...)" and "sprintf(...)"?

A.sprintf(...) writes data to the character array whereas printf(...) writes data to the standard output device.

12.Compilation How to reduce a final size of executable?

A.Size of the final executable can be reduced using dynamic linking for libraries.

13.Linked Lists -- Can you tell me how to check whether a linked list is circular?

A.Create two pointers, and set both to the start of the list. Update each as follows:
while (pointer1) {
pointer1 = pointer1->next;
pointer2 = pointer2->next;
if (pointer2) pointer2=pointer2->next;
if (pointer1 == pointer2) {
print ("circular");
}
}

If a list is circular, at some point pointer2 will wrap around and be either at the item just before pointer1, or the item before that. Either way, its either 1 or 2 jumps until they meet.

14."union" Data Type What is the output of the following program? Why?

#include
main() {
typedef union {
int a;
char b[10];
float c;
}
Union;

Union x,y = {100};
x.a = 50;
strcpy(x.b,"hello");
x.c = 21.50;
printf("Union x : %d %s %f n",x.a,x.b,x.c);
printf("Union y : %d %s %f n",y.a,y.b,y.c);
}

String Processing --- Write out a function that prints out all the permutations of a string. For example, abc would give you abc, acb, bac, bca, cab, cba.

void PrintPermu (char *sBegin, char* sRest) {
int iLoop;
char cTmp;
char cFLetter[1];
char *sNewBegin;
char *sCur;
int iLen;
static int iCount;

iLen = strlen(sRest);
if (iLen == 2) {
iCount++;
printf("%d: %s%s\n",iCount,sBegin,sRest);
iCount++;
printf("%d: %s%c%c\n",iCount,sBegin,sRest[1],sRest[0]);
return;
} else if (iLen == 1) {
iCount++;
printf("%d: %s%s\n", iCount, sBegin, sRest);
return;
} else {
// swap the first character of sRest with each of
// the remaining chars recursively call debug print
sCur = (char*)malloc(iLen);
sNewBegin = (char*)malloc(iLen);
for (iLoop = 0; iLoop < ctmp =" sCur[iLoop];" x="10;" x="10," y="15;" x =" x++;" y =" ++y;" a="0;" a="="0)" i="0;">>=1){
if (x & 0X1)
i++;
}
return i;
}

Answer: returns the number of ones in the input parameter X

What will happen in these three cases?
if(a=0){
//somecode
}
if (a==0){
//do something
}
if (a===0){
//do something
}

15.What are x, y, y, u
#define Atype int*
typedef int *p;
p x, z;
Atype y, u;

Answer: x and z are pointers to int. y is a pointer to int but u is just an integer variable

16.Advantages of a macro over a function?
A.Macro gets to see the Compilation environment, so it can expand __ __TIME__ __FILE__ #defines. It is expanded by the preprocessor.

For example, you can’t do this without macros
#define PRINT(EXPR) printf( #EXPR “=%d\n”, EXPR)

PRINT( 5+6*7 ) // expands into printf(”5+6*7=%d”, 5+6*7 );

You can define your mini language with macros:
#define strequal(A,B) (!strcmp(A,B))

Macros are a necessary evils of life. The purists don’t like them, but without it no real work gets done.

17.What is the difference between strings and character arrays?
A.A major difference is: string will have static storage duration, whereas as a character array will not, unless it is explicity specified by using the static keyword.

Actually, a string is a character array with following properties:

* the multibyte character sequence, to which we generally call string, is used to initialize an array of static storage duration. The size of this array is just sufficient to contain these characters plus the terminating NUL character.

* it not specified what happens if this array, i.e., string, is modified.

* Two strings of same value[1] may share same memory area. For example, in the following declarations:

char *s1 = “Calvin and Hobbes”;
char *s2 = “Calvin and Hobbes”;

the strings pointed by s1 and s2 may reside in the same memory location. But, it is not true for the following:

char ca1[] = “Calvin and Hobbes”;
char ca2[] = “Calvin and Hobbes”;

[1] The value of a string is the sequence of the values of the contained characters, in order.

18.Write down the equivalent pointer expression for referring the same element a[i][j][k][l]?
A.a[i] == *(a+i)
a[i][j] == *(*(a+i)+j)
a[i][j][k] == *(*(*(a+i)+j)+k)
a[i][j][k][l] == *(*(*(*(a+i)+j)+k)+l)

19.Which bit wise operator is suitable for checking whether a particular bit is on or off?
A.The bitwise AND operator. Here is an example:enum {
KBit0 = 1,
KBit1,
…
KBit31,
};

if ( some_int & KBit24 )
printf ( “Bit number 24 is ON\n” );
else
printf ( “Bit number 24 is OFF\n” );

20.Which bit wise operator is suitable for turning off a particular bit in a number?
A.The bitwise AND operator, again. In the following code snippet, the bit number 24 is reset to zero.
some_int = some_int & ~KBit24;

21.Which bit wise operator is suitable for putting on a particular bit in a number?
A.The bitwise OR operator. In the following code snippet, the bit number 24 is turned ON:
some_int = some_int | KBit24;

22.Does there exist any other function which can be used to convert an integer or a float to a string?
A.Some implementations provide a nonstandard function called itoa(), which converts an integer to string.

#include

char *itoa(int value, char *string, int radix);

DESCRIPTION
The itoa() function constructs a string representation of an integer.

PARAMETERS
value:
Is the integer to be converted to string representation.

string:
Points to the buffer that is to hold resulting string.
The resulting string may be as long as seventeen bytes.

radix:
Is the base of the number; must be in the range 2 - 36.

A portable solution exists. One can use sprintf():

char s[SOME_CONST];
int i = 10;
float f = 10.20;

sprintf ( s, “%d %f\n”, i, f );

23.Why does malloc(0) return valid memory address ? What's the use ?
A.malloc(0) does not return a non-NULL under every implementation.
An implementation is free to behave in a manner it finds
suitable, if the allocation size requested is zero. The
implmentation may choose any of the following actions:

* A null pointer is returned.

* The behavior is same as if a space of non-zero size
was requested. In this case, the usage of return
value yields to undefined-behavior.

Notice, however, that if the implementation returns a non-NULL
value for a request of a zero-length space, a pointer to object
of ZERO length is returned! Think, how an object of zero size
should be represented?

For implementations that return non-NULL values, a typical usage
is as follows:

void
func ( void )
{
int *p; /* p is a one-dimensional array,
whose size will vary during the
the lifetime of the program */
size_t c;

p = malloc(0); /* initial allocation */
if (!p)
{
perror (”FAILURE” );
return;
}

/* … */

while (1)
{
c = (size_t) … ; /* Calculate allocation size */
p = realloc ( p, c * sizeof *p );

/* use p, or break from the loop */
/* … */
}
return;
}

Notice that this program is not portable, since an implementation
is free to return NULL for a malloc(0) request, as the C Standard
does not support zero-sized objects.

23.Difference between const char* p and char

const* p
A.in const char* p, the character pointed by ‘p’

is constant, so u cant change the value of

character pointed by p but u can make ‘p’ refer

to some other location.

in char const* p, the ptr ‘p’ is constant not the

character referenced by it, so u cant make ‘p’

to reference to any other location but u can

change the value of the char pointed by ‘p’.

How can method defined in multiple base

classes with same name can be invoked from

derived class simultaneously
ex:

class x
{
public:
m1();

};

class y
{
public:
m1();

};

class z :public x, public y
{
public:
m1()
{
x::m1();
y::m1();
}

};

25.Write a program to interchange 2 variables

without using the third one.
A.a=7;
b=2;
a = a + b;
b = a - b;
a = a - b;

25.What is the result of using Option Explicit?
A.When writing your C program, you can

include files in two ways.
The first way is to surround the file you want

to include with the angled brackets <>.
This method of inclusion tells the preprocessor

to look for the file in the predefined default

location.
This predefined default location is often an

INCLUDE environment variable that denotes

the path to your include files.
For instance, given the INCLUDE variable
INCLUDE=C:\COMPILER\INCLUDE;S:\SO

URCE\HEADERS;
using the #include version of file inclusion, the

compiler first checks the
C:\COMPILER\INCLUDE
directory for the specified file. If the file is not

found there, the compiler then checks the
S:\SOURCE\HEADERS directory. If the file is

still not found, the preprocessor checks the

current directory.
The second way to include files is to surround

the file you want to include with double

quotation marks. This method of inclusion tells

the preprocessor to look for the file in the

current directory first, then look for it in the

predefined locations you have set up. Using the

#include file version of file inclusion and

applying it to the preceding example, the

preprocessor first checks the current directory

for the specified file. If the file is not found in

the current directory, the

C:COMPILERINCLUDE directory is

searched. If the file is still not found, the

preprocessor checks the S:SOURCEHEADERS

directory.
The #include method of file inclusion is often

used to include standard headers such as

stdio.h or
stdlib.h.
This is because these headers are rarely (if

ever) modified, and they should always be read

from your compiler’s standard include file

directory.
The #include file method of file inclusion is

often used to include nonstandard header files

that you have created for use in your program.

This is because these headers are often

modified in the current directory, and you will

want the preprocessor to use your newly

modified version of the header rather than the

older, unmodified version.

What is the benefit of using an enum rather

than a #define constant?
The use of an enumeration constant (enum) has

many advantages over using the traditional

symbolic constant style of #define. These

advantages include a lower maintenance

requirement, improved program readability,

and better debugging capability.
1) The first advantage is that enumerated

constants are generated automatically by the

compiler. Conversely, symbolic constants must

be manually assigned values by the

programmer.
For instance, if you had an enumerated

constant type for error codes that could occur

in your program, your enum definition could

look something like this:
enum Error_Code
{
OUT_OF_MEMORY,
INSUFFICIENT_DISK_SPACE,
LOGIC_ERROR,
FILE_NOT_FOUND
};
In the preceding example,

OUT_OF_MEMORY is automatically assigned

the value of 0 (zero) by the compiler because it

appears first in the definition. The compiler

then continues to automatically assign numbers

to the enumerated constants, making

INSUFFICIENT_DISK_SPACE equal to 1,

LOGIC_ERROR equal to 2, and

FILE_NOT_FOUND equal to 3, so on.
If you were to approach the same example by

using symbolic constants, your code would look

something like this:
#define OUT_OF_MEMORY 0
#define INSUFFICIENT_DISK_SPACE 1
#define LOGIC_ERROR 2
#define FILE_NOT_FOUND 3
values by the programmer. Each of the two

methods arrives at the same result: four

constants assigned numeric values to represent

error codes. Consider the maintenance

required, however, if you were to add two

constants to represent the error codes

DRIVE_NOT_READY and CORRUPT_FILE.

Using the enumeration constant method, you

simply would put these two constants anywhere

in the enum definition. The compiler would

generate two unique values for these constants.

Using the symbolic constant method, you would

have to manually assign two new numbers to

these constants. Additionally, you would want

to ensure that the numbers you assign to these

constants are unique.
2) Another advantage of using the enumeration

constant method is that your programs are

more readable and thus can be understood

better by others who might have to update your

program later.

3) A third advantage to using enumeration

constants is that some symbolic debuggers can

print the value of an enumeration constant.

Conversely, most symbolic debuggers cannot

print the value of a symbolic constant. This can

be an enormous help in debugging your

program, because if your program is stopped at

a line that uses an enum, you can simply

inspect that constant and instantly know its

value. On the other hand, because most

debuggers cannot print #define values, you

would most likely have to search for that value

by manually looking it up in a header file.

26.How can I open a file so that other

programs can update it at the same time?
Your C compiler library contains a low-level

file function called sopen() that can be used to

open a file in shared mode. Beginning with

DOS 3.0, files could be opened in shared mode

by loading a special program named

SHARE.EXE. Shared mode, as the name

implies, allows a file to be shared with other

programs as well as your own.
Using this function, you can allow other

programs that are running to update the same

file you are updating.
The sopen() function takes four parameters: a

pointer to the filename you want to open, the

operational mode you want to open the file in,

the file sharing mode to use, and, if you are

creating a file, the mode to create the file in.

The second parameter of the sopen() function,

usually referred to as the operation flag

parameter, can have the following values

assigned to it:
Constant Description O_APPEND Appends all

writes to the end of the file
O_BINARY Opens the file in binary

(untranslated) mode
O_CREAT If the file does not exist, it is

created
O_EXCL If the O_CREAT flag is used and the

file exists, returns an error
O_RDONLY Opens the file in read-only mode
O_RDWR Opens the file for reading and

writing
O_TEXT Opens the file in text (translated)

mode
O_TRUNC Opens an existing file and writes

over its contents
O_WRONLY Opens the file in write-only

mode
The third parameter of the sopen() function,

usually referred to as the sharing flag, can have

the following values assigned to it:
Constant Description
SH_COMPAT No other program can access

the file
SH_DENYRW No other program can read

from or write to the file
SH_DENYWR No other program can write to

the file
SH_DENYRD No other program can read

from the file
SH_DENYNO Any program can read from or

write to the file

If the sopen() function is successful, it returns a

non-negative number that is the file’s handle. If

an error occurs, 1 is returned, and the global

variable errno is set to one of the following

values:
Constant Description
ENOENT File or path not found
EMFILE No more file handles are available
EACCES Permission denied to access file
EINVACC Invalid access code
Constant Description
27.What is the quickest sorting method to use?
A.The answer depends on what you mean by

quickest. For most sorting problems, it just

doesn’t matter how quick the sort is because it

is done infrequently or other operations take

significantly more time anyway. Even in cases

in which sorting speed is of the essence, there is

no one answer. It depends on not only the size

and nature of the data, but also the likely

order. No algorithm is best in all cases.
There are three sorting methods in this

author’s toolbox that are all very fast and that

are useful in different situations. Those

methods are quick sort, merge sort, and radix

sort.
The Quick Sort
The quick sort algorithm is of the divide and

conquer type. That means it works by reducing

a sorting problem into several easier sorting

problems and solving each of them. A dividing

value is chosen from the input data, and the

data is partitioned into three sets: elements

that belong before the dividing value, the value

itself, and elements that come after the dividing

value. The partitioning is performed by

exchanging elements that are in the first set but

belong in the third with elements that are in the

third set but belong in the first Elements that

are equal to the dividing element can be put in

any of the three setsthe algorithm will still

work properly.
The Merge Sort
The merge sort is a divide and conquer sort as

well. It works by considering the data to be

sorted as a sequence of already-sorted lists (in

the worst case, each list is one element long).

Adjacent sorted lists are merged into larger

sorted lists until there is a single sorted list

containing all the elements. The merge sort is

good at sorting lists and other data structures

that are not in arrays, and it can be used to

sort things that don’t fit into memory. It also

can be implemented as a stable sort.
The Radix Sort
The radix sort takes a list of integers and puts

each element on a smaller list, depending on

the value of its least significant byte. Then the

small lists are concatenated, and the process is

repeated for each more significant byte until

the list is sorted. The radix sort is simpler to

implement on fixed-length data such as ints.

when should the volatile modifier be used?
The volatile modifier is a directive to the

compiler’s optimizer that operations involving

this variable should not be optimized in certain

ways. There are two special cases in which use

of the volatile modifier is desirable. The first

case involves memory-mapped hardware (a

device such as a graphics adaptor that appears

to the computer’s hardware as if it were part of

the computer’s memory), and the second

involves shared memory (memory used by two

or more programs running simultaneously).
Most computers have a set of registers that can

be accessed faster than the computer’s main

memory. A good compiler will perform a kind

of optimization called redundant load and

store removal. The compiler looks for places in

the code where it can either remove an

instruction to load data from memory because

the value is already in a register, or remove an

instruction to store data to memory because the

value can stay in a register until it is changed

again anyway.
If a variable is a pointer to something other

than normal memory, such as memory-mapped

ports on a peripheral, redundant load and

store optimizations might be detrimental. For

instance, here’s a piece of code that might be

used to time some operation:
time_t time_addition(volatile const struct timer

*t, int a)
{
int n;
int x;
time_t then;
x = 0;
then = t->value;
for (n = 0; n <>
{
x = x + a;
}
return t->value - then;
}

In this code, the variable t-> value is actually a

hardware counter that is being incremented as

time passes. The function adds the value of a to

x 1000 times, and it returns the amount the

timer was incremented by while the 1000

additions were being performed. Without the

volatile modifier, a clever optimizer might

assume that the value of t does not change

during the execution of the function, because

there is no statement that explicitly changes it.

In that case, there’s no need to read it from

memory a second time and subtract it, because

the answer will always be 0. The compiler

might therefore optimize the function by

making it always return 0.
If a variable points to data in shared memory,

you also don’t want the compiler to perform

redundant load and store optimizations.

Shared memory is normally used to enable two

programs to communicate with each other by

having one program store data in the shared

portion of memory and the other program read

the same portion of memory. If the compiler

optimizes away a load or store of shared

memory, communication between the two

programs will be affected.

28.When should the register modifier be used?

Does it really help?
A.The register modifier hints to the compiler

that the variable will be heavily used and

should be kept in the CPU’s registers, if

possible, so that it can be accessed faster.
There are several restrictions on the use of the

register modifier.
First, the variable must be of a type that can be

held in the CPU’s register. This usually means

a single value of a size less than or equal to the

size of an integer. Some machines have

registers that can hold floating-point numbers

as well.
Second, because the variable might not be

stored in memory, its address cannot be taken

with the unary & operator. An attempt to do so

is flagged as an error by the compiler. Some

additional rules affect how useful the register

modifier is. Because the number of registers is

limited, and because some registers can hold

only certain types of data (such as pointers or

floating-point numbers), the number and types

of register modifiers that will actually have any

effect are dependent on what machine the

program will run on. Any additional register

modifiers are silently ignored by the compiler.
Also, in some cases, it might actually be slower

to keep a variable in a register because that

register then becomes unavailable for other

purposes or because the variable isn’t used

enough to justify the overhead of loading and

storing it.
So when should the register modifier be used?

The answer is never, with most modern

compilers. Early C compilers did not keep any

variables in registers unless directed to do so,

and the register modifier was a valuable

addition to the language. C compiler design has

advanced to the point, however, where the

compiler will usually make better decisions

than the programmer about which variables

should be stored in registers.
In fact, many compilers actually ignore the

register modifier, which is perfectly legal,

because it is only a hint and not a directive.

29.How can you determine the size of an

allocated portion of memory?
A.You can’t, really. free() can , but there’s no

way for your program to know the trick free()

uses. Even if you disassemble the library and

discover the trick, there’s no guarantee the

trick won’t change with the next release of the

compiler.