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.
What is the output of printf("%d")?
-
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.
-
When we use %d the compiler internally uses it to access the
argument in the stack (argument stack). deally 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.
-
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(...).
What is the difference between
"calloc(...)" and "malloc(...)"?
- · 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(...).
- · 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.
What is the difference between
"printf(...)" and "sprintf(...)"?
sprintf(...) writes data to the
character array whereas printf(...) writes data to the standard output device.
How to reduce a final size of
executable?
Size of the final executable can
be reduced using dynamic linking for libraries.
Can you tell me how to check
whether a linked list is circular?
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.
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);
}
What does static variable mean?
There are 3 main uses for the
static.
- · If you declare within a function: It retains the value between function calls
- · 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
- · 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 within the file
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 static specifier also have static scope.
Memory obtained from calls to
malloc(), alloc() or realloc() belongs to allocated storage class.
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.
Difference between const char* p
and char const* p
·
In const char* p, the character pointed by ‘p’ is constant, so u
can’t 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’.
What is hashing?
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.
How can you determine the size of
an allocated portion of memory?
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.
Can static variables be declared
in a header file?
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.
Can a variable be both const and
volatile?
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.
Can include files be nested?
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.
When does the compiler not
implicitly generate the address of the first element of an array?
Whenever an array name appears in
an expression such as
- · array as an operand of the sizeof operator
- · array as an operand of & operator
- · array as a string literal initializer for a character array
Then the compiler does not
implicitly generate the address of the address of the first element of an array.
What is a null pointer?
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
What is the difference between
text and binary modes?
Streams can be classified into
two types: text streams and binary streams.
·
Text streams are interpreted, with a maximum length of 255
characters. With text streams, carriage return/line feed combinations are
translated to the newline n character and vice versa.
·
Binary streams are uninterrupted and are treated one byte at a
time with no translation of characters.
Typically, a text stream would be
used for reading and writing standard text files, printing output to the screen
or printer, or receiving input from the keyboard. A binary text stream would
typically be used for reading and writing binary files such as graphics or word
processing documents, reading
mouse input, or reading and
writing to the modem.
What is static memory allocation and
dynamic memory allocation?
- · Static memory 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.
When should a far pointer be
used?
Sometimes you can get away with
using a small memory model in most of a given program. There might be just a
few things that don’t fit in your small data and code segments. When that
happens, you can use explicit far pointers and function declarations to get at
the rest of memory. A far function can be outside the 64KB segment most
functions are shoehorned into for a small-code model. (Often, libraries are
declared explicitly far, so they’ll work no matter what code model the program
uses.) A far pointer can refer to information outside the 64KB data segment.
Typically, such pointers are used with farmalloc() and such, to manage a heap
separate from where all the rest of the data lives. If you use a small-data,
large-code model, you should
explicitly make your function
pointers far.
How are pointer variables
initialized?
Pointer variable are initialized
by one of the following two ways
- · Static memory allocation
- · Dynamic memory allocation
Difference between arrays and pointers?
- - Pointers are used to manipulate data using the address. Pointers use * operator to access the data pointed to by them
- - Arrays use subscripted variables to access and manipulate data. Array variables can be equivalently written using pointer expression.
Is using exit() the same as using
return?
No. The exit() function is used
to exit your program and return control to the operating system. The return
statement is used to return from a function and return control to the calling function.
If you issue a return from the main() function, you are essentially returning
control to the calling function, which is the operating system. In this case,
the return statement and exit() function are similar.
What is a method?
Method is a way of doing
something, especially a systematic way; implies an orderly logical arrangement
(usually in steps).
What is indirection?
If you declare a variable, its
name is a direct reference to its value. If you have a pointer to a variable,
or any other object in memory, you have an indirect reference to its value.
What is modular programming?
If a program is large, it is
subdivided into a number of smaller programs that are called modules or
subprograms. If a complex problem is solved using more modules, this approach
is known as modular programming.
How many levels deep can include
files be nested?
Even though there is no limit to
the number of levels of nested include files you can have, your compiler might
run out of stack space while trying to include an inordinately high number of
files. This number varies according to your hardware configuration and possibly
your compiler.
What is the difference between
declaring a variable and defining a variable?
Declaring a variable means
describing its type to the compiler but not allocating any space for it.
Defining a variable means declaring it and also allocating space to hold the
variable. You can also initialize a variable at the time it is defined.
What is an lvalue?
An lvalue is an expression to
which a value can be assigned. The lvalue expression is located on the left
side of an assignment statement, whereas an rvalue is located on the right side
of an assignment statement. Each assignment statement must have an lvalue and an
rvalue. The lvalue expression must reference a storable variable in memory. It
cannot be a constant.
Differentiate between an internal
static and external static variable?
An internal static variable is
declared inside a block with static storage class whereas an external static
variable is declared outside all the blocks in a file. An internal static
variable has persistent storage, block
scope and no linkage. An external
static variable has permanent storage, file scope and internal linkage.