Escolar Documentos
Profissional Documentos
Cultura Documentos
C++ Questions
• What are the major differences between C and C++?
o What are the differences between new and malloc?
o What is the difference between delete and delete[]?
o What are the differences between a struct in C and in C++?
o What are the advantages/disadvantages of using #define?
o What are the advantages/disadvantages of using inline and const?
• What is the difference between a pointer and a reference?
o When would you use a pointer? A reference?
o What does it mean to take the address of a reference?
• What does it mean to declare a function or variable as static?
• What is the order of initalization for data?
• What is name mangling/name decoration?
o What kind of problems does name mangling cause?
o How do you work around them?
• What is a class?
o What are the differences between a struct and a class in C++?
o What is the difference between public, private, and protected access?
o For class CFoo { }; what default methods will the compiler generate
for you>?
o How can you force the compiler to not generate them?
o What is the purpose of a constructor? Destructor?
o What is a constructor initializer list?
o When must you use a constructor initializer list?
o What is a:
Constructor?
Destructor?
Default constructor?
Copy constructor?
Conversion constructor?
o What does it mean to declare a...
member function as virtual?
member function as static?
member function as static?
member variable as static?
destructor as static?
o Can you explain the term "resource acquisition is initialization?"
o What is a "pure virtual" member function?
o What is the difference between public, private, and protected inheritance?
o What is virtual inheritance?
o What is placement new?
o What is the difference between operator new and the new operator?
• What is exception handling?
o Explain what happens when an exception is thrown in C++.
o What happens if an exception is not caught?
o What happens if an exception is throws from an object's constructor?
o What happens if an exception is throws from an object's destructor?
o What are the costs and benefits of using exceptions?
o When would you choose to return an error code rather than throw an
exception?
• What is a template?
• What is partial specialization or template specialization?
• How can you force instantiation of a template?
• What is an iterator?
• What is an algorithm (in terms of the STL/C++ standard library)?
• What is std::auto_ptr?
• What is wrong with this statement? std::auto_ptr ptr(new char[10]);
• It is possible to build a C++ compiler on top of a C compiler. How would you do
this? (Note: I've only asked this question once; and yes, he understood that I was
asking him how cfront was put together. We hired him.)
Code Snippets
I like to put these up on a whiteboard, and ask questions about them.
#include <iostream>
class A {
public:
A() {
this->Foo();
}
virtual void Foo() {
cout << "A::Foo()" << endl;
}
};
class B : public A {
public:
B() {
this->Foo();
}
virtual void Foo() {
cout << "B::Foo()" << endl;
}
};
return 0;
}
#include <iostream>
class A {
public:
A() {
cout << "A::A()" << endl;
}
~A() {
cout << "A::~A()" << endl; throw
"A::exception";
}
};
class B {
public:
B() {
cout << "B::B()" << endl; throw
"B::exception";
}
~B() {
cout << "B::~B()";
}
};
A objectA;
B objectB;
return 0;
}
C++
Category:
View
s:
1162
7
Rating: (4.0)
By:
37
users
Answer:
Virtual destructors: If an object (with a non-virtual destructor) is destroyed explicitly by applying
the delete operator to a base-class pointer to the object, the base-class destructor function
(matching the pointer type) is called on the object.
There is a simple solution to this problem – declare a virtual base-class destructor. This makes all
derived-class destructors virtual even though they don’t have the same name as the base-class
destructor. Now, if the object in the hierarchy is destroyed explicitly by applying the delete operator
to a base-class pointer to a derived-class object, the destructor for the appropriate class is called.
Virtual constructor: Constructors cannot be virtual. Declaring a constructor as a virtual function is
a syntax error. Does c++ support multilevel and multiple inheritance?
Yes.
What are the advantages of inheritance?
• It permits code reusability.
• Reusability saves time in program development.
• It encourages the reuse of proven and debugged high-quality software, thus reducing problem
after a system becomes functional.
What is the difference between declaration and definition?
The declaration tells the compiler that at some later point we plan to present the definition of this
declaration.
E.g.: void stars () //function declaration
The definition contains the actual implementation.
E.g.: void stars () // declarator
{
for(int j=10; j>=0; j--) //function body
cout<<”*”;
cout<<endl;
}
CoolInterview.com
What do you mean by inline function? Added: 10/22/2004
Question:
C++
Category: Views: 4436
(3.5)
By: 17 users
Rating:
The idea behind inline functions is to insert the code of a called function at the point where
Answer: the
function is called. If done carefully, this can improve the application's performance in exchange for
increased compile time and possibly (but not always) an increase in the size of the generated
binary executables.
CoolInterview.com
C++
Category: Views: 6297
(4.6)
By: 10 users
Rating:
The free subroutine frees a block of memory previously allocated by the malloc subroutine.
Answer: Undefined results occur if the Pointer parameter is not a valid pointer. If the Pointer
parameter is a
null value, no action will occur. The realloc subroutine changes the size of the block of
memory
pointed to by the Pointer parameter to the number of bytes specified by the Size parameter
and
returns a new pointer to the block. The pointer specified by the Pointer parameter must have
been
created with the malloc, calloc, or realloc subroutines and not been deallocated with the free
or
realloc subroutines. Undefined results occur if the Pointer parameter is not a valid pointer.
CoolInterview.com
C++
Category: Views: 4632
(3.1)
By: 7 users
Rating:
Templates allow to create generic functions that admit any data type as parameters and
Answer: return value
without having to overload the function with all the possible data types. Until certain point
they fulfill
the functionality of a macro. Its prototype is any of the two following ones:
The only difference between both prototypes is the use of keyword class or typename, its use
is
indistinct since both expressions have exactly the same meaning and behave exactly the
same way.
CoolInterview.com
What is the difference between class and structure? Added: 10/22/2004
Question:
C++
Category: Views: 2303
(4.6)
By: 8 users
Rating:
Structure: Initially (in C) a structure was used to bundle different type of data types together
Answer: to
perform a particular functionality. But C++ extended the structure to contain functions also.
The
major difference is that all declarations inside a structure are by default public.
Class: Class is a successor of Structure. By default all the members inside the class are
private.
CoolInterview.com
C++
Category: Views: 5952
(3.2)
By: 6 users
Rating:
Runtime type identification (RTTI) lets you find the dynamic type of an object when you have
Answer: only a
pointer or a reference to the base type. RTTI is the official way in standard C++ to discover
the type of an object and to convert the type of a pointer or reference (that is, dynamic
typing). The need came from practical experience with C++. RTTI replaces many homegrown
versions with a solid, consistent approach.
CoolInterview.com
C++
Category: Views: 4283
(2.8)
By: 12 users
Rating:
C++
Category: Views: 1683
(3.0)
By: 5 users
Rating:
Object is a software bundle of variables and related methods. Objects have state and behavior.
Answer: CoolInterview.com
What is public, protected, private? Added: 10/22/2004
Question:
C++
Category: Views: 1508
(2.5)
By: 2 users
Rating:
Ø Protected data members and member functions are only available to derived classes.
Ø Private data members and member functions can’t be accessed outside the class. However
there is an exception can be using friend classes.
CoolInterview.com
C++
Category: Views: 5788
(3.3)
By: 15 users
Rating:
Namespaces allow us to group a set of global classes, objects and/or functions under a name.
Answer: To say
it somehow, they serve to split the global scope in sub-scopes known
as namespaces.
Where identifier is any valid identifier and namespace-body is the set of classes, objects and
functions that are included within the namespace. For example:
namespace general { int a, b; } In this case, a and b are normal variables integrated within
the
general namespace. In order to access to these variables from outside the namespace we
have to
use the scope operator ::. For example, to access the previous variables we would have to
put:
general::a general::b
The functionality of namespaces is specially useful in case that there is a possibility that a
global
object or function can have the same name than another one, causing a redefinition error.
What do you mean by inheritance? Added: 10/22/2004
Question:
C++
Category: Views: 2000
(4.7)
By: 3 users
Rating:
Inheritance is the process of creating new classes, called derived classes, from existing
Answer: classes or
base classes. The derived class inherits all the capabilities of the base class, but can add
embellishments and refinements of its own.
CoolInterview.com
C++
Category: Views: 3497
(4.0)
By: 6 users
Rating:
Function overloading: C++ enables several functions of the same name to be defined, as long
Answer: as
these functions have different sets of parameters (at least as far as their types are
concerned). This
capability is called function overloading. When an overloaded function is called, the C++
compiler
selects the proper function by examining the number, types and order of the arguments in
the call.
Function overloading is commonly used to create several functions of the same name that
perform
similar tasks but on different data types.
Operator overloading allows existing C++ operators to be redefined so that they work on
objects
of user-defined classes. Overloaded operators are syntactic sugar for
equivalent function calls. They form a pleasant facade that doesn't add anything fundamental
to the
language (but they can improve understandability and reduce
maintenance costs).
CoolInterview.com
C++
Category: Views: 4279
(1.6)
By: 8 users
Rating:
Friend classes are used when two or more classes are designed to work together and need
Answer: access
to each other's implementation in ways that the rest of the world shouldn't be allowed to
have. In other words, they help keep private things private. For instance, it may be desirable
for class DatabaseCursor to have more privilege to the internals of class Database
than main() has.
CoolInterview.com
What do you mean by binding of data and functions? Added: 10/22/2004
Question:
C++
Category: Views: 3828
(4.0)
By: 5 users
Rating:
Encapsulation.
Answer: CoolInterview.com
C++
Category: Views: 6510
(3.5)
By: 14 users
Rating:
Classes and objects are separate but related concepts. Every object belongs to a class and
Answer: every
class contains one or more related objects.
Ø A Class is static. All of the attributes of a class are fixed before, during, and after the
execution of
a program. The attributes of a class don't change.
Ø The class to which an object belongs is also (usually) static. If a particular object belongs
to a
certain class at the time that it is created then it almost certainly will still belong to that class
right
up until the time that it is destroyed.
Ø An Object on the other hand has a limited lifespan. Objects are created and eventually
destroyed.
Also during that lifetime, the attributes of the object may undergo significant change.
CoolInterview.com
C++
Category: Views: 1972
(2.7)
By: 3 users
Rating:
Class is a user-defined data type in C++. It can be created to solve a particular kind of
Answer: problem.
After creation the user need not know the specifics of the working of a class.
CoolInterview.com
What is friend function? Added: 10/22/2004
Question:
C++
Category: Views: 1255
(5.0)
By: 1 users
Rating:
As the name suggests, the function acts as a friend to a class. As a friend of a class, it can
Answer: access its
private and protected members. A friend function is not a member of the class. But it must
be listed in the class definition.
CoolInterview.com
C++
Category: Views: 2512
(4.5)
By: 2 users
Rating:
C++
Category: Views: 1851
(5.0)
By: 1 users
Rating:
A virtual function allows derived classes to replace the implementation provided by the base
Answer: class.
The compiler makes sure the replacement is always called whenever the object in question is
actually of the derived class, even if the object is accessed by a base pointer rather than a
derived pointer. This allows algorithms in the base class to be replaced in the derived class,
even if users don't know about the derived class.
CoolInterview.com
C++
Category: Views: 2482
(3.1)
By: 8 users
Rating:
A scope resolution operator (::), can be used to define the member functions of a class
Answer: outside the
class.
What do you mean by pure virtual functions? Added: 10/22/2004
Question:
C++
Category: Views: 5740
(3.7)
By: 11 users
Rating:
A pure virtual member function is a member function that the base class forces derived
Answer: classes to
provide. Normally these member functions have no implementation. Pure virtual functions are
equated to zero.
class Shape { public: virtual void draw() = 0; };
CoolInterview.com
C++
Category: Views: 2611
(3.3)
By: 4 users
Rating:
"Poly" means "many" and "morph" means "form". Polymorphism is the ability of an object (or
Answer: reference) to assume (be replaced by) or become many different forms of object.
Example: function overloading, function overriding, virtual functions. Another example can be
a plus
‘+’ sign, used for adding two integers or for using it to concatenate two strings.
Important Point
There are nice syntactic differences between malloc() and new and between free() and
delete. But the most important differences are in their behavior. The malloc() function
allocates the requested number of bytes and returns a pointer to them. Nothing more. But
after allocating memory for an instance of a class, the new operator will automatically call
the constructor for that class to initialize that section of memory.
Important Point
The main difference between malloc() and new is that new calls a class
constructor after allocating the memory.
Likewise, free() and delete both return memory previously allocated to the system.
Important Point
The main difference between delete and free() is that delete calls the
class destructor method before returning the memory to the system.
The new operator can be used to dynamically allocate arrays (so can malloc()):
Widget *ar;
ar = new Widget[n];
...
The new operator will allocate the memory for the entire array and then call the default
Widget constructor on each element in the array in order to initialize it.
The delete operator has two forms one for simple instances, one for arrays.
...
d = new Data;
e = new Data[n];
...
delete d;
delete [] e;
When using delete [], the class destructor will be called on every element of the array
to clean up the array before the memory is returned to the system.
Important Point
Important Point
Mixing up the delete and delete [] operators will not cause compile time errors. Very
subtle errors will crop up at runtime in large projects which can be very difficult to track
down.
Answer
both malloc and new functions are used for dynamic memory allocations and the basic
difference is: malloc requires a special "typecasting" when it allocates memory for eg. if
the pointer used is the char pointer then after the processor allocates memory then this
allocated memory needs to be typecasted to char pointer i.e (char*).but new does not
requires any typecasting. Also, free is the keyword used to free the memory while using
malloc and delete the keyword to free memory while using new, otherwise this will lead
the memory leak.
[edit answer]
Answer
Besides the basic syntactical difference: malloc is a C function which will allocate the
amount of memory you ask and thats it. new is a C++ operator which will allocate
memory AND call the constructor of the class for which's object memory is being
allocated.
Similarily, free is a C function which will free up the memory allocated. but delete is a
C++ operator which will free up the allocated memory AND call the destructor of the
object.
[edit answer]
Answer
malloc in a function and new is an operator, and its a good programming practice to use
an operator instead of functions, because function itself requires some time to be
executed whenever that particular function is called. so the main difference is that we use
operators instead of malloc because of the TIME CONSTRAINT.
struct A {
int x;
};
typedef struct A A;
void f()
{
A a;
}
In C++, classes, structs, unions, and enum names are automatically type names, so you
can say:
struct A {
int x;
};
void f()
{
A a;
}
or:
enum E {ee};
void f()
{
E e;
}
By using the typedef trick, you can follow a style of programming in C somewhat like
that used in C++.
But there is a quirk or two when using C++. Consider usage like:
struct A {
int x;
};
int A;
void f()
{
A a;
}
This is illegal because the int declaration A hides the struct declaration. The struct A
can still be used, however, by specifying it via an "elaborated type specifier":
struct A
class A a;
union U u;
enum E e;
Taking advantage of this feature, that is, giving a class type and a variable or function the
same name, isn't very good usage. It's supported for compatibility reasons with old C
code; C puts structure tags (names) into a separate namespace, but C++ does not. Terms
like "struct compatibility hack" and "1.5 namespace rule" are sometimes used to describe
this feature.
C Interview Questions
Question When does the compiler not implicitly generate the address of the first
element of an array?
Answer Whenever an array name appears in an expression such as
array as an operand of the sizeof operator
array as an operand of & operator
Question Which expression always return true? Which always return false?
Answer expression if (a=0) always return false expression if (a=1) always return true
instructions to carry out this operation.
Question Is it possible to execute code even after the program exits the main()
function?
Answer The standard C library provides a function named atexit() that can be used to
perform “cleanup” operations when your program terminates. You can set up a set of
functions you want to perform automatically when your program exits by passing
function pointers to the at exit() function.
Question Can the sizeof operator be used to tell the size of an array passed to a
function?
Answer There’s no way to tell, at runtime, how many elements are in an array parameter
just by looking at the array parameter itself. Remember, passing an array to a function is
exactly the same as passing a pointer to the first element.
Question What is the heap?
Answer The heap is where malloc(), calloc(), and realloc() get memory. Getting memory
from the heap is much slower than getting it from the stack. On the other hand, the heap
is much more flexible than the stack. Memory can be allocated at any time and
deallocated in any order. Such memory isn’t deallocated automatically; you have to call
free(). Recursive data structures are almost always implemented with memory from the
heap. Strings often come from there too, especially strings that could be very long at
runtime. If you can keep data in a local variable (and allocate it from the stack), your
code will run faster than if you put the data on the heap. Sometimes you can use a better
algorithm if you use the heap—faster, or more robust, or more flexible. It’s a tradeoff.
If memory is allocated from the heap, it’s available until the program ends. That’s great
if you remember to deallocate it when you’re done. If you forget, it’s a problem. A
“memory leak” is some allocated memory that’s no longer needed but isn’t deallocated.
If you have a memory leak inside a loop, you can use up all the memory on the heap and
not be able to get any more. (When that happens, the allocation functions return a null
pointer.) In some environments, if a program doesn’t deallocate everything it allocated,
memory stays unavailable even after the program ends.
Question How can you determine the size of an allocated portion of memory?
Answer 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.
Question What is a “null pointer assignment” error? What are bus errors, memory
faults, and core dumps?
Answer These are all serious errors, symptoms of a wild pointer or subscript. Null pointer
assignment is a message you might get when an MS-DOS program finishes executing.
Some such programs can arrange for a small amount of memory to be available “where
the NULL pointer points to” (so to speak). If the program tries to write to that area, it
will overwrite the data put there by the compiler. When the program is done, code
generated by the compiler examines that area. If that data has been changed, the
compiler-generated code complains with null pointer assignment. This message carries
only enough information to get you worried. There’s no way to tell, just
from a null pointer assignment message, what part of your program is responsible for the
error. Some debuggers, and some compilers, can give you more help in finding the
problem. Bus error: core dumped and Memory fault: core dumped are messages you
might see from a program running under UNIX. They’re more programmer
friendly. Both mean that a pointer or an array subscript was wildly out of bounds. You
can get these messages on a read or on a write. They aren’t restricted to null pointer
problems. The core dumped part of the message is telling you about a file, called core,
that has just been written in your current directory. This is a dump of everything on the
stack and in the heap at the time the program was running. With the help of a debugger,
you can use the core dump to find where the bad pointer was used. That might not tell
you why the pointer was bad, but it’s a step in the right direction. If you don’t have write
permission in the current directory, you won’t get a core file, or the core dumped
message.
Question Why should we assign NULL to the elements (pointer) after freeing them?
Answer This is paranoia based on long experience. After a pointer has been freed, you
can no longer use the pointed-to data. The pointer is said to “dangle”; it doesn’t point at
anything useful. If you “NULL out” or “zero out” a pointer immediately after freeing it,
your program can no longer get in trouble by using that pointer. True, you might go
indirect on the null pointer instead, but that’s something your debugger might be able to
help you with immediately. Also, there still might be copies of the pointer that refer
to the memory that has been deallocated; that’s the nature of C. Zeroing out pointers after
freeing them won’t solve all problems;
Question What is the benefit of using an enum rather than a #define constant?
Answer 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.
Question What is the difference between #include <file> and #include “file”?
Answer 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 < and >. 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:\SOURCE\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.
Question How many levels of pointers can you have?
Answer The answer depends on what you mean by “levels of pointers.” If you mean
“How many levels of indirection can you have in a single declaration?” the answer is “At
least 12.”
int i = 0;
int *ip01 = & i;
int **ip02 = & ip01;
int ***ip03 = & ip02;
int ****ip04 = & ip03;
int *****ip05 = & ip04;
int ******ip06 = & ip05;
int *******ip07 = & ip06;
int ********ip08 = & ip07;
int *********ip09 = & ip08;
int **********ip10 = & ip09;
int ***********ip11 = & ip10;
int ************ip12 = & ip11;
************ip12 = 1; /* i = 1 */
The ANSI C standard says all compilers must handle at least 12 levels. Your compiler
might support more.
Question What is the difference between a string copy (strcpy) and a memory copy
(memcpy)? When should each be us
Answer The strcpy() function is designed to work exclusively with strings. It copies each
byte of the source string to the destination string and stops when the terminating null
character () has been moved. On the other hand, the memcpy() function is designed to
work with any type of data. Because not all data ends with a null character, you must
provide the memcpy() function with the number of bytes you want to copy from the
source to the destination.
Question What is a pragma?
Answer The #pragma preprocessor directive allows each compiler to implement
compiler-specific features that can be turned on and off with the #pragma statement. For
instance, your compiler might support a feature called loop optimization. This feature can
be invoked as a command-line option or as a #pragma directive. To implement this option
using the #pragma directive, you would put the following line into your code:
#pragma loop_opt(on)
Conversely, you can turn off loop optimization by inserting the following line into your
code:
#pragma loop_opt(off)
Question Can you define which header file to include at compile time?
Answer Yes. This can be done by using the #if, #else, and #endif preprocessor directives.
For example, certain compilers use different names for header files. One such case is
between Borland C++, which uses the header file alloc.h, and Microsoft C++,
which uses the header file malloc.h. Both of these headers serve the same purpose, and
each contains roughly the same definitions. If, however, you are writing a program that is
to support Borland C++ and Microsoft C++, you must define which header to include at
compile time. The following example shows how this can be done:
#ifdef _ _BORLANDC_ _
#include
#else
#include
#endif
Question How can you avoid including a header more than once?
Answer 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.
Question How can I make sure that my program is the only one accessing a file?
Answer By using the sopen() function you can open a file in shared mode and explicitly
deny reading and writing permissions to any other program but yours. This task is
accomplished by using the SH_DENYWR shared flag to denote that your program is
going to deny any writing or reading attempts by other programs. For example, the
following snippet of code shows a file being opened in shared mode, denying access to
all other files: /* Note that the sopen() function is not ANSI
compliant... */
fileHandle = sopen(“C:DATASETUP.DAT”, O_RDWR,
SH_DENYWR);
By issuing this statement, all other programs are denied access to the SETUP.DAT file. If
another program were to try to open SETUP.DAT for reading or writing, it would receive
an EACCES error code, denoting that access is denied to the file.
Question What is the name and path of the default configuration file used by the
syslogd
Daemon?
Answer : /etc/syslog.conf If no configuration file is specified when starting syslogd, then
it will start up with the configuration specified in the /etc/syslog.conf file.
Question which command is used to delete all files in the current directory and all
its sub-directories?
Answer rm -r *
C Interview Questions
Question Difference between arrays and pointers?
Answer 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.
Question When does the compiler not implicitly generate the address of the first
element of an array?
Answer Whenever an array name appears in an expression such as
array as an operand of the sizeof operator
array as an operand of & operator
Question Is it possible to execute code even after the program exits the main()
function?
Answer The standard C library provides a function named atexit() that can be used to
perform “cleanup” operations when your program terminates. You can set up a set of
functions you want to perform automatically when your program exits by passing
function pointers to the at exit() function.
Question How can you determine the size of an allocated portion of memory?
Answer 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.
Question What is a “null pointer assignment” error? What are bus errors, memory
faults, and core dumps?
Answer These are all serious errors, symptoms of a wild pointer or subscript. Null pointer
assignment is a message you might get when an MS-DOS program finishes executing.
Some such programs can arrange for a small amount of memory to be available “where
the NULL pointer points to” (so to speak). If the program tries to write to that area, it
will overwrite the data put there by the compiler. When the program is done, code
generated by the compiler examines that area. If that data has been changed, the
compiler-generated code complains with null pointer assignment. This message carries
only enough information to get you worried. There’s no way to tell, just
from a null pointer assignment message, what part of your program is responsible for the
error. Some debuggers, and some compilers, can give you more help in finding the
problem. Bus error: core dumped and Memory fault: core dumped are messages you
might see from a program running under UNIX. They’re more programmer
friendly. Both mean that a pointer or an array subscript was wildly out of bounds. You
can get these messages on a read or on a write. They aren’t restricted to null pointer
problems. The core dumped part of the message is telling you about a file, called core,
that has just been written in your current directory. This is a dump of everything on the
stack and in the heap at the time the program was running. With the help of a debugger,
you can use the core dump to find where the bad pointer was used. That might not tell
you why the pointer was bad, but it’s a step in the right direction. If you don’t have write
permission in the current directory, you won’t get a core file, or the core dumped
message.
Question Why should we assign NULL to the elements (pointer) after freeing them?
Answer This is paranoia based on long experience. After a pointer has been freed, you
can no longer use the pointed-to data. The pointer is said to “dangle”; it doesn’t point at
anything useful. If you “NULL out” or “zero out” a pointer immediately after freeing it,
your program can no longer get in trouble by using that pointer. True, you might go
indirect on the null pointer instead, but that’s something your debugger might be able to
help you with immediately. Also, there still might be copies of the pointer that refer
to the memory that has been deallocated; that’s the nature of C. Zeroing out pointers after
freeing them won’t solve all problems;
Question What is the benefit of using an enum rather than a #define constant?
Answer 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.
Question What is the difference between #include <file> and #include “file”?
Answer 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 < and >. 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:\SOURCE\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.
Question What is the difference between a string copy (strcpy) and a memory copy
(memcpy)? When should each be us
Answer The strcpy() function is designed to work exclusively with strings. It copies each
byte of the source string to the destination string and stops when the terminating null
character () has been moved. On the other hand, the memcpy() function is designed to
work with any type of data. Because not all data ends with a null character, you must
provide the memcpy() function with the number of bytes you want to copy from the
source to the destination.
Question Can you define which header file to include at compile time?
Answer Yes. This can be done by using the #if, #else, and #endif preprocessor directives.
For example, certain compilers use different names for header files. One such case is
between Borland C++, which uses the header file alloc.h, and Microsoft C++,
which uses the header file malloc.h. Both of these headers serve the same purpose, and
each contains roughly the same definitions. If, however, you are writing a program that is
to support Borland C++ and Microsoft C++, you must define which header to include at
compile time. The following example shows how this can be done:
#ifdef _ _BORLANDC_ _
#include
#else
#include
#endif
Question How can you avoid including a header more than once?
Answer 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.
Question How can I make sure that my program is the only one accessing a file?
Answer By using the sopen() function you can open a file in shared mode and explicitly
deny reading and writing permissions to any other program but yours. This task is
accomplished by using the SH_DENYWR shared flag to denote that your program is
going to deny any writing or reading attempts by other programs. For example, the
following snippet of code shows a file being opened in shared mode, denying access to
all other files: /* Note that the sopen() function is not ANSI
compliant... */
fileHandle = sopen(“C:DATASETUP.DAT”, O_RDWR,
SH_DENYWR);
By issuing this statement, all other programs are denied access to the SETUP.DAT file. If
another program were to try to open SETUP.DAT for reading or writing, it would receive
an EACCES error code, denoting that access is denied to the file.
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.
Question What is a const pointer?
AnswerThe access modifier keyword const is a promise the programmer makes to the
compiler that the value of a variable will not be changed after it is initialized. The
compiler will enforce that promise as best it can by not enabling the programmer to write
code which modifies a variable that has been declared const. A “const pointer,” or more
correctly, a “pointer to const,” is a pointer which points to data that is const
(constant, or unchanging). A pointer to const is declared by putting the word const at the
beginning of the pointer declaration. This declares a pointer which points to data that
can’t be modified. The pointer itself can be modified. The following example illustrates
some legal and illegal uses of a const pointer:
const char *str = “hello”;
char c = *str /* legal */
str++; /* legal */
*str = ‘a’; /* illegal */
str[1] = ‘b’; /* illegal */
Question What is the name and path of the default configuration file used by the
syslogd
Daemon?
Answer : /etc/syslog.conf If no configuration file is specified when starting syslogd, then
it will start up with the configuration specified in the /etc/syslog.conf file.
Question which command is used to delete all files in the current directory and all
its sub-directories?
Answer rm -r *
MEMORY MANAGEMENT
Const Data: The const data area stores string literals and other data whose values are
known at compile time. No objects of class type can exist in this area. All data in this
area is available during the entire lifetime of the program. Further, all of this data is read-
only, and the results of trying to modify it are undefined.
Stack: The stack stores automatic variables. Typically allocation is much faster than for
dynamic storage (heap or free store) because a memory allocation involves only pointer
increment rather than more complex management. Objects are constructed immediately
after memory is allocated and destroyed immediately before memory is deallocated, so
there is no opportunity for programmers to directly manipulate allocated but uninitialized
stack space.
Free Store: The free store is one of the two dynamic memory areas, allocated/freed by
new/delete. Object lifetime can be less than the time the storage is allocated; that is, free
store objects can have memory allocated without being immediately initialized, and can
be destroyed without the memory being immediately deallocated. During the period
when the storage is allocated but outside the object's lifetime, the storage may be
accessed and manipulated through a void* but none of the proto-object's nonstatic
members or member functions may be accessed, have their addresses taken, or be
otherwise manipulated.
Heap: The heap is the other dynamic memory area, allocated/freed by malloc / free and
their variants. Note that while the default global new and delete might be implemented in
terms of malloc and free by a particular compiler, the heap is not the same as free store
and memory allocated in one area cannot be safely deallocated in the other. Memory
allocated from the heap can be used for objects of class type by placement-new
construction and explicit destruction. If so used, the notes about free store object lifetime
apply similarly here.
Global/Static: Global or static variables and objects have their storage allocated at
program startup, but may not be initialized until after the program has begun executing.
For instance, a static variable in a function is initialized only the first time program
execution passes through its definition. The order of initialization of global variables
across translation units is not defined, and special care is needed to manage
dependencies between global objects (including class static’s). As always, uninitialized
Proto- objects' storage may be accessed and manipulated through a void* but no
nonstatic members or member functions may be used or referenced outside the object's
actual lifetime.
Automatic Storage
Local objects that are not explicitly declared static or extern, local objects that are
declared auto or register, and function arguments have automatic storage. This type of
storage is also called stack memory.
Static Storage
Global objects, static data members of a class, namespace variables, and static variables
in functions reside in static memory.
NOTE:
Static- storage allocated at link time, initialized at load time, and released on termination.
Stack- storage that is allocated, initialized, and released on a last in first out basis.
Heap- storage that can be dynamically allocated, initialized, and released.
Keep in mind, a pointer is like any other variable in the sense that it requires storage
space somewhere in the computer's memory, but it is not like most variables because it
contains no data, only an address. Since it is an address, it actually contains a number
referring to some memory location.
Static: In C++, the size of any object that is declared static can be determined at compile
time, and so storage for the object can be allocated by the linker. The object will be
created just before the program begins to execute, and will be destroyed just before the
program terminates. It is important to note that you have little or no control over the order
in which static objects are created or destroyed. (This can be a major source of portability
problems.)
Stack: In C++, an object that is declared directly is created on the stack. Objects are
destroyed in reverse order of creation. This is done automatically on exit of the block
they were created in.
Heap: Objects created with the new operator are placed on the heap. They will persist
until explicitly destroyed, or the program terminates. You cannot refer to such an object
directly, you need to use a pointer. Every object created with new should have a
corresponding delete, otherwise you will get memory leaks.
Calling Functions:
The parameters to procedure and function calls, and the return result are placed on the
stack. What is actually placed on the stack depends on the type of parameter. This is very
important to understand when it comes to passing objects to a procedure and returning
objects from a procedure. The default passing convention for parameters is by value. That
is, instead of the actual parameter, a copy of it is placed on the stack. The same holds for
the return value. A place is reserved for the return value on the stack, and when the return
is executed the value to be returned is copied into this place.
Passing a parameter by reference avoids the copying of values by putting a pointer to the
parameter on the stack. Returning by reference is similar
NOTE:
When the parameter appearing in the argument list is not of the correct type, such as
providing an int argument when a double is required, or having an expression in the
argument position. In that case a temporary object is created on the stack to store the
actual parameter. If that temporary object is being passed by const reference (it must be
const) then a pointer to the temporary is passed as the parameter.
Malloc returns a void pointer to the allocated buffer. This pointer must be cast into the
proper type to access the data to be stored in the buffer. On failure, malloc returns a null
pointer.
It is not necessary to cast the pointer argument back to void. The compiler handles this
conversion.
Disadvantage of New:
One disadvantage of New is that there is no way to reallocate memory. With Malloc you
can use Realloc to extend the amount of memory quickly. With New you have to create a
new chunk of memory with the modified size and then copy over the data from the
original buffer and then delete the original buffer. This can be a slow process.
Never use malloc () to allocate memory and then delete it. Likewise never use new to
allocate memory and then free() it. These are not compile time errors, but can cause
spectacular program crashes which again, are difficult to debug. Use the memory
allocation routines consistently.
Don't mix new /delete with C allocation/ deallocation functions, or the behavior is
undefined. Remember that new may throw exceptions (from failed memory allocation or
from constructor).
Can I free () pointers allocated with new? Can I delete pointers allocated with malloc ()?
NO
If you allocated via pointer = new char [nbytes], you must use delete [] p; you must not
use free (p). Or if you allocated via pointer = malloc (nbytes), you must use free (p); you
must not use delete [] p or delete p! Mixing these up could cause a catastrophic failure at
runtime if the code was ported to a new machine, a new compiler, or even a new version
of the same compiler.
Shallow Copies :
The default copy constructor and assignment operator make shallow copies.
Deep copies :
If an object has pointers to dynamically allocated memory, and the dynamically allocated
memory needs to be copied when the original object is copied, then a deep copy is
required.
A class that requires deep copies generally needs:
A constructor to either make an initial allocation or set the pointer to NULL.
A destructor to delete the dynamically allocated memory.
A copy constructor to make a copy of the dynamically allocated memory.
An overloaded assignment operator to make a copy of the dynamically allocated memory.
MEMORY MANAGEMENT
Const Data: The const data area stores string literals and other data whose values are
known at compile time. No objects of class type can exist in this area. All data in this
area is available during the entire lifetime of the program. Further, all of this data is read-
only, and the results of trying to modify it are undefined.
Stack: The stack stores automatic variables. Typically allocation is much faster than for
dynamic storage (heap or free store) because a memory allocation involves only pointer
increment rather than more complex management. Objects are constructed immediately
after memory is allocated and destroyed immediately before memory is deallocated, so
there is no opportunity for programmers to directly manipulate allocated but uninitialized
stack space.
Free Store: The free store is one of the two dynamic memory areas, allocated/freed by
new/delete. Object lifetime can be less than the time the storage is allocated; that is, free
store objects can have memory allocated without being immediately initialized, and can
be destroyed without the memory being immediately deallocated. During the period
when the storage is allocated but outside the object's lifetime, the storage may be
accessed and manipulated through a void* but none of the proto-object's nonstatic
members or member functions may be accessed, have their addresses taken, or be
otherwise manipulated.
Heap: The heap is the other dynamic memory area, allocated/freed by malloc / free and
their variants. Note that while the default global new and delete might be implemented in
terms of malloc and free by a particular compiler, the heap is not the same as free store
and memory allocated in one area cannot be safely deallocated in the other. Memory
allocated from the heap can be used for objects of class type by placement-new
construction and explicit destruction. If so used, the notes about free store object lifetime
apply similarly here.
Global/Static: Global or static variables and objects have their storage allocated at
program startup, but may not be initialized until after the program has begun executing.
For instance, a static variable in a function is initialized only the first time program
execution passes through its definition. The order of initialization of global variables
across translation units is not defined, and special care is needed to manage
dependencies between global objects (including class static’s). As always, uninitialized
Proto- objects' storage may be accessed and manipulated through a void* but no
nonstatic members or member functions may be used or referenced outside the object's
actual lifetime.
Automatic Storage
Local objects that are not explicitly declared static or extern, local objects that are
declared auto or register, and function arguments have automatic storage. This type of
storage is also called stack memory.
Static Storage
Global objects, static data members of a class, namespace variables, and static variables
in functions reside in static memory.
NOTE:
Static- storage allocated at link time, initialized at load time, and released on termination.
Stack- storage that is allocated, initialized, and released on a last in first out basis.
Heap- storage that can be dynamically allocated, initialized, and released.
Keep in mind, a pointer is like any other variable in the sense that it requires storage
space somewhere in the computer's memory, but it is not like most variables because it
contains no data, only an address. Since it is an address, it actually contains a number
referring to some memory location.
Static: In C++, the size of any object that is declared static can be determined at compile
time, and so storage for the object can be allocated by the linker. The object will be
created just before the program begins to execute, and will be destroyed just before the
program terminates. It is important to note that you have little or no control over the order
in which static objects are created or destroyed. (This can be a major source of portability
problems.)
Stack: In C++, an object that is declared directly is created on the stack. Objects are
destroyed in reverse order of creation. This is done automatically on exit of the block
they were created in.
Heap: Objects created with the new operator are placed on the heap. They will persist
until explicitly destroyed, or the program terminates. You cannot refer to such an object
directly, you need to use a pointer. Every object created with new should have a
corresponding delete, otherwise you will get memory leaks.
Calling Functions:
The parameters to procedure and function calls, and the return result are placed on the
stack. What is actually placed on the stack depends on the type of parameter. This is very
important to understand when it comes to passing objects to a procedure and returning
objects from a procedure. The default passing convention for parameters is by value. That
is, instead of the actual parameter, a copy of it is placed on the stack. The same holds for
the return value. A place is reserved for the return value on the stack, and when the return
is executed the value to be returned is copied into this place.
Passing a parameter by reference avoids the copying of values by putting a pointer to the
parameter on the stack. Returning by reference is similar
NOTE:
When the parameter appearing in the argument list is not of the correct type, such as
providing an int argument when a double is required, or having an expression in the
argument position. In that case a temporary object is created on the stack to store the
actual parameter. If that temporary object is being passed by const reference (it must be
const) then a pointer to the temporary is passed as the parameter.
Malloc returns a void pointer to the allocated buffer. This pointer must be cast into the
proper type to access the data to be stored in the buffer. On failure, malloc returns a null
pointer.
Disadvantage of New:
One disadvantage of New is that there is no way to reallocate memory. With Malloc you
can use Realloc to extend the amount of memory quickly. With New you have to create a
new chunk of memory with the modified size and then copy over the data from the
original buffer and then delete the original buffer. This can be a slow process.
Never use malloc () to allocate memory and then delete it. Likewise never use new to
allocate memory and then free() it. These are not compile time errors, but can cause
spectacular program crashes which again, are difficult to debug. Use the memory
allocation routines consistently.
Don't mix new /delete with C allocation/ deallocation functions, or the behavior is
undefined. Remember that new may throw exceptions (from failed memory allocation or
from constructor).
Can I free () pointers allocated with new? Can I delete pointers allocated with malloc ()?
NO
If you allocated via pointer = new char [nbytes], you must use delete [] p; you must not
use free (p). Or if you allocated via pointer = malloc (nbytes), you must use free (p); you
must not use delete [] p or delete p! Mixing these up could cause a catastrophic failure at
runtime if the code was ported to a new machine, a new compiler, or even a new version
of the same compiler.
Shallow Copies :
The default copy constructor and assignment operator make shallow copies.
Deep copies :
If an object has pointers to dynamically allocated memory, and the dynamically allocated
memory needs to be copied when the original object is copied, then a deep copy is
required.
A class that requires deep copies generally needs:
A constructor to either make an initial allocation or set the pointer to NULL.
A destructor to delete the dynamically allocated memory.
A copy constructor to make a copy of the dynamically allocated memory.
An overloaded assignment operator to make a copy of the dynamically allocated memory.
DATABASE Interview Questions
Uninitialized member fields have garbage in them. This creates the possibility
of a serious bug (eg, an uninitialized pointer, illegal values, inconsistent
values, ...).
Declaring a constructor
Destructors
When are destructors called?
If you don't have anything to clean up, like memory that you allocated for
some of the members, then the default constructor is probably ok.
If you need a copy constructor, it's because you need something like a deep
copy, or some other management of resources. Thus is is almost certain that
you will need a destructor and override the assignment operator.
Here is an example of a copy constructor for the Point class, which doesn't
really need one because the default copy constructor's action of copying
fields would work fine, but it shows how it works.
Unaddressed issue
[Question: When is the base (parent) class copy constructor called? Is it like
Java and the parent constructor is called at the beginning of each
constructor? Does it have to be explicit?]
Overloading Assignment
When to define assignment (and a copy constructor and
destructor)
Example
If a method is virtual, then calling the method on an object always invokes the method as
implemented by the most heavily derived class. If the method is not virtual, then the
implementation corresponding to the compile-time type of the object pointer.
class Sample {
public:
void f();
virtual void vf();
};
void function()
{
Derived d;
Sample* p = &d;
p->f();
p->vf();
}
The call to p->f() will result in a call to Sample::f because p is a pointer to a Sample.
The actual object is of type Derived, but the pointer is merely a pointer to a Sample. The
pointer type is used because f is not virtual.
On the other hand, the call to The call to p->vf() will result in a call to Derived::vf,
the most heavily derived type, because vf is virtual.
Virtual destructors work exactly the same way. It's just that you rarely invoke the
destructor explicitly. Rather, it's invoked when an automatic object goes out of scope or
when you delete the object.
void function()
{
Sample* p = new Derived;
delete p;
}
Since Sample does not have a virtual destructor, the delete p invokes the destructor of
the class of the pointer (Sample::~Sample()), rather than the destructor of the most
derived type (Derived::~Derived()). And as you can see, this is the wrong thing to do
in the above scenario.
Armed with this information, you can now answer the question.
A class must have a virtual destructor if it meets both of the following criteria:
• You do a delete p.
• It is possible that p actually points to a derived class.
Some people say that you need a virtual destructor if and only if you have a virtual
method. This is wrong in both directions.
Example of a case where a class has no virtual methods but still needs a virtual
destructor:
class Sample { };
class Derived : public Sample
{
CComPtr<IStream> m_p;
public:
Derived() { CreateStreamOnHGlobal(NULL, TRUE, &m_p); }
};
And here's an example of a case where a class has virtual methods but does not require a
virtual destructor.
Since the object deletion occurs from the pointer type that matches the type of the actual
object, the correct destructor will be invoked. This pattern happens often in COM objects,
which expose several virtual methods corresponding to its interfaces, but where the
object itself is destroyed by its own implementation and not from a base calss pointer.
(Notice that no COM interfaces contain virtual destructors.)
The problem with knowing when to make your destructor virtual or not is that you have
to know how people will be using your class. If C++ had a "sealed" keyword, then the
rule would be simpler: If you do a "delete p" where p is a pointer to an unsealed class,
then that class needs have a virtual destructor. (The imaginary "sealed" keyword makes it
explicit when a class can act as the base class for another class.)
Comments
Well, almost.
If the sizeof or layout of your class is a concern for some reason, making the destructor
virtual "costs nothing" if your base class already has a virtual method. You're already
carrying a vptr at that point.
There's rarely a reason NOT to make the destructor virtual if you already have a virtual
method, I think. (I guess it's possible you're going to create a LOT of temporary
Derived's, so the ~Derived virtual call becomes a bottleneck, but that seems very
unlikely...)
An empty virtual destructor for your last sample class would hardly be a maintenance
headache, and opens the possibility for the use case to change down the road without base
class changes.
Also, there's a small mistake - Derived isn't derived in the last bit of code.
In other words: somewhere, something knows that p isa Derived. Are there cases when
Derived::~Derived() is defined, but you would actually want "delete p" to do a
Simple::~Simple()?
struct Base
{
arbitraryType arbitraryMemberVariable;
virtual void doSomething() = 0;
~Base() {}
};
struct Derived : Base
{
arbitraryType arbitraryMemberVariable;
virtual void doSomething() { blahblahblah; }
~Derived() {}
};
In this case the Derived d-tor will be called in spite of being bound to a reference to Base,
because the compiler uses the static type of the temporary to figure out which destructor
to call.
Esoteric? Sure. Useless? Hell no, as anyone who's seen ScopeGuard will know.
The statement
It is possible that the base class destructor is invoked and the derived clas destructor isn't,
but that's just an instance of undefined behavior. Other instances are a program crash or
the computer catching fire.
5.3.5.3: "If the static type of the operand is different from its dynamic type, the static type
shall be a base class of the operand's dynamic type and the static type shall have a virtual
destructor or the behavior is undefined."
I think the rule about "When should your destructor be virtual? " can be:
And by the way, is not a good ideea to inherit public from a class without any virtual
method.
I wonder if we could perform a DNS attack on him by copying gigantic bitmaps into our
clipboard, then visiting his site :)
A: Create two pointers, each set 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\n\");
}
}
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, it’s either 1 or 2 jumps until they
meet.
Method
Array2D<float>data(10,20);
cout<<data[3][6]; // fine
80. Name some pure object oriented languages. Smalltalk, Java, Eiffel,
Sather.
81. Name the operators that cannot be overloaded. sizeof, ., .*, .->, ::, ?:
Salam in the comments notes that -> can be overloaded.
82. What is a node class? A node class is a class that,
o relies on the base class for services and implementation,
o provides a wider interface to the users than its base class,
o relies primarily on virtual functions in its public interface
o depends on all its direct and indirect base class
o can be understood only in the context of the base class
o can be used as base for further derivation
o can be used to create objects.
A node class is a class that has added new services or functionality beyond the
services inherited from its base class.
85. how to make a function which can take any no of argument?what is va_list.
1
Required for UNIX V compatibility.
Libraries
Return Value
va_arg returns the current argument; va_start and va_end do not return values.
Parameters
type
arg_ptr
prev_param
Remarks
The va_arg, va_end, and va_start macros provide a portable way to access the
arguments to a function when the function takes a variable number of arguments.
Two versions of the macros are available: The macros defined in STDARG.H conform
to the ANSI C standard, and the macros defined in VARARGS.H are compatible with
the UNIX System V definition. The macros are:
va_alist
va_arg
va_dcl
va_end
va_list
va_start
Macro to set arg_ptr to beginning of list of optional arguments (UNIX version only)
Both versions of the macros assume that the function takes a fixed number of
required arguments, followed by a variable number of optional arguments. The
required arguments are declared as ordinary parameters to the function and can be
accessed through the parameter names. The optional arguments are accessed
through the macros in STDARG.H or VARARGS.H, which set a pointer to the first
optional argument in the argument list, retrieve arguments from the list, and reset
the pointer when argument processing is completed.
• va_start sets arg_ptr to the first optional argument in the list of arguments
passed to the function. The argument arg_ptr must have va_list type. The
argument prev_param is the name of the required parameter immediately
preceding the first optional argument in the argument list. If prev_param is
declared with the register storage class, the macro’s behavior is undefined.
va_start must be used before va_arg is used for the first time.
• va_arg retrieves a value of type from the location given by arg_ptr and
increments arg_ptr to point to the next argument in the list, using the size of
type to determine where the next argument starts. va_arg can be used any
number of times within the function to retrieve arguments from the list.
• After all arguments have been retrieved, va_end resets the pointer to NULL.
• The last (or only) parameter to the function represents the list of optional
arguments. This parameter must be named va_alist (not to be confused with
va_list, which is defined as the type of va_alist).
• va_dcl appears after the function definition and before the opening left brace
of the function. This macro is defined as a complete declaration of the
va_alist parameter, including the terminating semicolon; therefore, no
semicolon should follow va_dcl.
• Within the function, va_start sets arg_ptr to the beginning of the list of
optional arguments passed to the function. va_start must be used before
va_arg is used for the first time. The argument arg_ptr must have va_list
type.
• va_arg retrieves a value of type from the location given by arg_ptr and
increments arg_ptr to point to the next argument in the list, using the size of
type to determine where the next argument starts. va_arg can be used any
number of times within the function to retrieve the arguments from the list.
• After all arguments have been retrieved, va_end resets the pointer to NULL.
Example
#include <stdio.h>
#define ANSI /* Comment out for UNIX version */
#ifdef ANSI /* ANSI compatible version */
#include <stdarg.h>
int average( int first, ... );
#else /* UNIX compatible version */
#include <varargs.h>
int average( va_list );
#endif
Output
Average is: 3
Average is: 8
Average is: 0
/* This following program defines and demonstrates the function
"_outtextf": */
/* Compile options needed: none
*/
#include <stdio.h>
#include <graph.h>
#include <stdarg.h>
va_start (arglist,format);
retval = vsprintf(buffer,format,arglist);
va_end (arglist);
_outtext (buffer);
return (retval);
}
//Using CString::FormatV(), you can write functions like the following:
You can call the above function with any number of parameters, for example:
which would add output to your fileLog file similar to the following:
A: Create two pointers, each set 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\n\");
}
}
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, it’s either 1 or 2 jumps until they
meet.
Method
Array2D<float>data(10,20);
cout<<data[3][6]; // fine
80. Name some pure object oriented languages. Smalltalk, Java, Eiffel,
Sather.
81. Name the operators that cannot be overloaded. sizeof, ., .*, .->, ::, ?:
Salam in the comments notes that -> can be overloaded.
82. What is a node class? A node class is a class that,
o relies on the base class for services and implementation,
o provides a wider interface to the users than its base class,
o relies primarily on virtual functions in its public interface
o depends on all its direct and indirect base class
o can be understood only in the context of the base class
o can be used as base for further derivation
o can be used to create objects.
A node class is a class that has added new services or functionality beyond the
services inherited from its base class.