C,c++ interview q&a

C & C++ Interview Q&A
How do I know how many elements an array can hold?
The amount of memory an array can consume depends on the data type of an array. In
DOS environment, the amount of memory an array can consume depends on the current
memory model (i.e. Tiny, Small, Large, Huge, etc.). In general an array cannot consume
more than 64 kb. Consider following program, which shows the maximum number of
elements an array of type int, float and char can have in case of Small memory model.
main( )
{
int i[32767] ;
float f[16383] ;
char s[65535] ;
}

How do I write code that reads data at memory location specified
by segment and offset?
Use peekb( ) function. This function returns byte(s) read from specific segment and offset
locations in memory. The following program illustrates use of this function. In this
program from VDU memory we have read characters and its attributes of the first row.
The information stored in file is then further read and displayed using peek( ) function.
#include <stdio.h>
#include <dos.h>
main( )
{
char far *scr = 0xB8000000 ;
FILE *fp ;
int offset ;
char ch ;
if ( ( fp = fopen ( "scr.dat", "wb" ) ) == NULL )
{
printf ( "nUnable to open file" ) ;
exit( ) ;
}
// reads and writes to file
for ( offset = 0 ; offset < 160 ; offset++ )
fprintf ( fp, "%c", peekb ( scr, offset ) ) ;
fclose ( fp ) ;
if ( ( fp = fopen ( "scr.dat", "rb" ) ) == NULL )
{
exit( ) ;
}

{
fscanf ( fp, "%c", &ch ) ;
printf ( "%c", ch ) ;
}
fclose ( fp ) ;
}

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 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 is difference 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 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.

How do I write code that reads data at memory location specified
by segment and offset?
Use peekb( ) function. This function returns byte(s) read from specific segment and offset
locations in memory. The following program illustrates use of this function. In this
program from VDU memory we have read characters and its attributes of the first row.
The information stored in file is then further read and displayed using peek( ) function.
#include <stdio.h>
#include <dos.h>
main( )
{
char far *scr = 0xB8000000 ;
FILE *fp ;
int offset ;
char ch ;
if ( ( fp = fopen ( "scr.dat", "wb" ) ) == NULL )
{
exit( ) ;
}
fprintf ( fp, "%c", peekb ( scr, offset ) ) ;
fclose ( fp ) ;
if ( ( fp = fopen ( "scr.dat", "rb" ) ) == NULL )
{
exit( ) ;
}
{
fscanf ( fp, "%c", &ch ) ;
printf ( "%c", ch ) ;
}
fclose ( fp ) ;
}

What is Difference Between C/C++

C does not have a class/object concept.
C++ provides data abstraction, data encapsulation, Inheritance and Polymorphism.
C++ supports all C syntax.
In C passing value to a function is "Call by Value" whereas in C++ its "Call by
Reference"
File extension is .c in C while .cpp in C++.(C++ compiler compiles the files with .c
extension but C compiler can not!)
In C structures can not have contain functions declarations. In C++ structures are like
classes, so declaring functions is legal and allowed.
C++ can have inline/virtual functions for the classes.
c++ is C with Classes hence C++ while in c the closest u can get to an User defined data
type is struct and union.

What are Templates

C++ Templates allow u to generate families of functions or classes that can operate on a
variety of different data types, freeing you from the need to create a separate function or
class for each type. Using templates, u have the convenience of writing a single generic
function or class definition, which the compiler automatically translates into a specific
version of the function or class, for each of the different data types that your program
actually uses. Many data structures and algorithms can be defined independently of the
type of data they work with. You can increase the amount of shared code by separating
data-dependent portions from data-independent portions, and templates were introduced
to help you do that.

What is Polymorphism ?
'Polymorphism' is an object oriented term. Polymorphism may be defined as the ability of
related objects to respond to the same message with different, but appropriate actions. In
other words, polymorphism means taking more than one form. Polymorphism leads to
two important aspects in Object Oriented terminology - Function Overloading and
Function Overriding. Overloading is the practice of supplying more than one definition
for a given function name in the same scope. The compiler is left to pick the appropriate
version of the function or operator based on the arguments with which it is called.
Overriding refers to the modifications made in the sub class to the inherited methods
from the base class to change their behavior.

Is it acceptable to declare/define a variable in a C header?
A global variable that must be accessed from more than one file can and should be
declared in a header file. In addition, such a variable must be defined in one source file.

Variables should not be defined in header files, because the header file can be included in
multiple source files, which would cause multiple definitions of the variable. The ANSI
C standard will allow multiple external definitions, provided that there is only one
initialization. But because there’s really no advantage to using this feature, it’s probably
best to avoid it and maintain a higher level of portability.
Global variables that do not have to be accessed from more than one file should be
declared static and should not appear in a header file.

What is a void pointer?
A void pointer is a C convention for a raw address. The compiler has no idea what type
of object a void Pointer really points to. If you write
int *ip;
ip points to an int. If you write
void *p;
p doesn’t point to a void!
In C and C++, any time you need a void pointer, you can use another pointer type. For
example, if you have a char*, you can pass it to a function that expects a void*. You
don’t even need to cast it. In C (but not in C++), you can use a void* any time you need
any kind of pointer, without casting. (In C++, you need to cast it).
A void pointer is used for working with raw memory or for passing a pointer to an
unspecified type.
Some C code operates on raw memory. When C was first invented, character pointers
(char *) were used for that. Then people started getting confused about when a character
pointer was a string, when it was a character array, and when it was raw memory.

What is a macro and how do you use it?
A macro is a preprocessor directive that provides a mechanism for token replacement in
your source code. Macros are created by using the #define statement.
Here is an example of a macro: Macros can also utilize special operators such as the
stringizing operator (#) and the concatenation operator (##).The stringizing operator can
be used to convert macro parameters to quoted strings, as in the following example:
#define DEBUG_VALUE(v) printf(#v is equal to %d.n, v)
In your program, you can check the value of a variable by invoking the
DEBUG_VALUE macro:
…
int x = 20;
DEBUG_VALUE(x);
…
The preceding code prints x is equal to 20. on-screen. This example shows that the
stringizing operator used with macros can be a very handy debugging tool.

Is it better to use malloc() or calloc()?
Both the

and the calloc() functions are used to allocate dynamic memory. Each operates slightly
different from the other. malloc() takes a size and returns a pointer to a chunk of memory
at least that big:
void *malloc( size_t size );
calloc() takes a number of elements, and the size of each, and returns a pointer to a chunk
of memory at least big enough to hold them all:
void *calloc( size_t numElements, size_t sizeOfElement );
There’s one major difference and one minor difference between the two functions. The
major difference is that malloc() doesn’t initialize the allocated memory. The first time
malloc() gives you a particular chunk of memory, the memory might be full of zeros. If
memory has been allocated, freed, and reallocated, it probably has whatever junk was left
in it. That means, unfortunately, that a program might run in simple cases (when memory
is never reallocated) but break when used harder (and when memory is reused). calloc()
fills the allocated memory with all zero bits. That means that anything there you’re going
to use as a char or an int of any length, signed or unsigned, is guaranteed to be zero.
Anything you’re going to use as a pointer is set to all zero bits. That’s usually a null
pointer, but it’s not guaranteed.Anything you’re going to use as a float or double is set to
all zero bits; that’s a floating-point zero on some types of machines, but not on all.
The minor difference between the two is that calloc() returns an array of objects; malloc()
returns one object. Some people use calloc() to make clear that they want an array.

What is the easiest searching method to use?
Just as qsort() was the easiest sorting method, because it is part of the standard library,
bsearch() is the easiest searching method to use. If the given array is in the sorted order
bsearch() is the best method.
Following is the prototype for bsearch():
void *bsearch(const void *key, const void *buf, size_t num, size_t size, int
(*comp)(const void *, const void*));
Another simple searching method is a linear search. A linear search is not as fast as
bsearch() for searching among a large number of items, but it is adequate for many
purposes. A linear search might be the only method available, if the data isn’t sorted or
can’t be accessed randomly. A linear search starts at the beginning and sequentially
compares the key to each element in the data set.

When would you use a pointer to a function?
Pointers to functions are interesting when you pass them to other functions. A function
that takes function pointers says, in effect, Part of what I do can be customized. Give me
a pointer to a function, and I’ll call it when that part of the job needs to be done. That
function can do its part for me. This is known as a callback. It’s used a lot in graphical
user interface libraries, in which the style of a display is built into the library but the
contents of the display are part of the application.
As a simpler example, say you have an array of character pointers (char*s), and you want
to sort it by the value of the strings the character pointers point to. The standard qsort()
function uses function pointers to perform that task. qsort() takes four arguments,

- a pointer to the beginning of the array,
- the number of elements in the array,
- the size of each array element, and
- a comparison function, and returns an int.

How can you avoid including a header more than once?
One easy technique to avoid multiple inclusions of the same header is to use the #ifndef
and #define
preprocessor directives. When you create a header for your program, you can #define a
symbolic name that is unique to that header. You can use the conditional preprocessor
directive named #ifndef to check whether that symbolic name has already been assigned.
If it is assigned, you should not include the header, because it has already been
preprocessed. If it is not defined, you should define it to avoid any further inclusions of
the header. The following header illustrates this technique:
#ifndef _FILENAME_H
#define _FILENAME_H
#define VER_NUM 1.00.00
#define REL_DATE 08/01/94
#if _ _WINDOWS_ _
#define OS_VER WINDOWS
#else
#define OS_VER DOS
#endif
#endif

When the preprocessor encounters this header, it first checks to see whether
_FILENAME_H has been defined. If it hasn’t been defined, the header has not been
included yet, and the _FILENAME_H symbolic name is defined. Then, the rest of the
header is parsed until the last #endif is encountered, signaling the end of the conditional
#ifndef _FILENAME_H statement. Substitute the actual name of the header file for
FILENAME in the preceding example to make it applicable for your programs.

mory allocation: The compiler allocates the required memory space for a declared
variable.By using the address of operator,the reserved address is obtained and this
address may be assigned to a pointer variable.Since most of the declared variable have
static memory,this way of assigning pointer value to a pointer variable is known as static
memory allocation. memory is assigned during compilation time.
Dynamic memory allocation: It uses functions such as malloc( ) or calloc( ) to get
memory dynamically.If these functions are used to get memory dynamically and the
values returned by these functions are assingned to pointer variables, such assignments
are known as dynamic memory allocation.memory is assined during run time.

What is Preprocessor?
The preprocessor is used to modify your program according to the preprocessor directives
in your source code. Preprocessor directives (such as #define) give the preprocessor
specific instructions on how to modify your source code. The preprocessor reads in all of
your include files and the source code you are compiling and creates a preprocessed
version of your source code. This preprocessed version has all of its macros and constant
symbols replaced by their corresponding code and value assignments. If your source code
contains any conditional preprocessor directives (such as #if), the preprocessor evaluates
the condition and modifies your source code accordingly.
The preprocessor contains many features that are powerful to use, such as creating
macros, performing conditional compilation, inserting predefined environment variables
into your code, and turning compiler features on and off. For the professional
programmer, in-depth knowledge of the features of the preprocessor can be one of the
keys to creating fast, efficient programs.

What is the benefit of using #define to declare a constant?

Using the #define method of declaring a constant enables you to declare a constant in one
place and use it throughout your program. This helps make your programs more
maintainable, because you need to maintain only the #define statement and not several
instances of individual constants throughout your program.
For instance, if your program used the value of pi (approximately 3.14159) several times,
you might want to declare a constant for pi as follows:
#define PI 3.14159
Using the #define method of declaring a constant is probably the most familiar way of
declaring constants to traditional C programmers. Besides being the most common
method of declaring constants, it also takes up the least memory. Constants defined in
this manner are simply placed directly into your source code, with no variable space
allocated in memory. Unfortunately, this is one reason why most debuggers cannot
inspect constants created using the #define method.

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.

What does static variable mean?
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

Advantages of a macro over a function?
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 “=%dn”, 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.

What are the different storage classes in C?
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.

Oct 05

What is the difference between strings and character arrays?
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.

What is C language?
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. …

printf() Function
What is the output of printf("%d")?

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(…).

C,c++ interview q&a

Recommended

More Related Content

What's hot (18)

Viewers also liked (8)

Similar to C,c++ interview q&a (20)

More from Kumaran K (7)

C,c++ interview q&a