# Question 1

How to list all the predefined identifiers?
Â

gcc provides a -dM option which works with -E.

# Question 2

How the compiler make difference between C and C++?
Â

Most compilers recognized the file type by looking at the file extension.

You might also be able to force the compiler to ignore the file type by supplying compiler switch. In MS VC++ 6, for example, the MSCRT defines a macro, __cplusplus. If you undefine that macro, then the compiler will treat your code as C code. You don't define the __cplusplus macro. It is defined by the compiler when compiling a C++ source. In MSVC6 there's a switch for the compiler, /Tc, that forces a C compilation instead of C++.

# Question 3

What are the general steps in compilation?
Â

1.Â LexicalÂ analysis. 2.Â SyntacticÂ analysis. 3.Â SematicÂ analysis.Â  4.Â Pre-optimizationÂ ofÂ internalÂ representation. 5.Â CodeÂ generation. 6.Â PostÂ optimization.

# Question 4

What are the different types of linkages?
Â

Linkage is used to determine what makes the same name declared in different scopes refer to the same thing. An object only ever has one name, but in many cases we would like to be able to refer to the same object from different scopes. A typical example is the wish to be able to call printf() from several different places in a program, even if those places are not all in the same source file.

The Standard warns that declarations which refer to the same thing must all have compatible type, or the behaviour of the program will be undefined. Except for the use of the storage class specifier, the declarations must be identical.

The three different types of linkage are:
Â

In an entire program, built up perhaps from a number of source files and libraries, if a name has external linkage, then every instance of a that name refers to the same object throughout the program. For something which has internal linkage, it is only within a given source code file that instances of the same name will refer to the same thing. Finally, names with no linkage refer to separate things.

Every data object or function that is actually used in a program (except as the operand of a sizeof operator) must have one and only one corresponding definition. This "exactly one" rule means that for objects with external linkage there must be exactly one definition in the whole program; for things with internal linkage (confined to one source code file) there must be exactly one definition in the file where it is declared; for things with no linkage, whose declaration is always a definition, there is exactly one definition as well.

The three types of accessibility that you will want of data objects or functions are:
Â

• Throughout the entire program,
• Restricted to one source file,
• Restricted to one function (or perhaps a single compound statement).

For the three cases above, you will want external linkage, internal linkage, and no linkage respectively. The external linkage declarations would be prefixed with extern, the internal linkage declarations with static.

#includeÂ  //Â ExternalÂ linkage. externÂ intÂ var1; //Â DefinitionsÂ withÂ externalÂ linkage. externÂ intÂ var2Â =Â 0; //Â InternalÂ linkage: staticÂ intÂ var3; //Â FunctionÂ withÂ externalÂ linkage voidÂ f1(intÂ a){} //Â FunctionÂ canÂ onlyÂ beÂ invokedÂ byÂ nameÂ fromÂ withinÂ thisÂ file. staticÂ intÂ f2(intÂ a1,Â intÂ a2) { Â Â Â Â return(a1Â *Â a2); }

# Question 5

What do you mean by scope and duration?
Â

The duration of an object describes whether its storage is allocated once only, at program start-up, or is more transient in its nature, being allocated and freed as necessary.

There are only two types of duration of objects: static duration and automatic duration. Static duration means that the object has its storage allocated permanently, automatic means that the storage is allocated and freed as necessary.

It's easy to tell which is which: you only get automatic duration if
Â

• The declaration is inside a function.
• And the declaration does not contain the static or extern keywords.
• And the declaration is not the declaration of a function.

The scope of the names of objects defines when and where a given name has a particular meaning. The different types of scope are the following:
Â

• function scope
• file scope
• block scope
• function prototype scope

The easiest is function scope. This only applies to labels, whose names are visible throughout the function where they are declared, irrespective of the block structure. No two labels in the same function may have the same name, but because the name only has function scope, the same name can be used for labels in every function. Labels are not objects?they have no storage associated with them and the concepts of linkage and duration have no meaning for them. Any name declared outside a function has file scope, which means that the name is usable at any point from the declaration on to the end of the source code file containing the declaration. Of course it is possible for these names to be temporarily hidden by declarations within compound statements. As we know, function definitions must be outside other functions, so the name introduced by any function definition will always have file scope. A name declared inside a compound statement, or as a formal parameter to a function, has block scope and is usable up to the end of the associated } which closes the compound statement. Any declaration of a name within a compound statement hides any outer declaration of the same name until the end of the compound statement. A special and rather trivial example of scope is function prototype scope where a declaration of a name extends only to the end of the function prototype. The scope of a name is completely independent of any storage class specifier that may be used in its declaration.