Interview Questions BB 5

11. Difference Between Java and C++?

Java: no support for multiple inheritance ; default dynamic binding; auto garbage collection; no pointer for accessing memory address; pure oo,all are inside class; exception handling

C++ : support multiple inheritance; default static binding; no auto garbage collection; pointer for accessing memory address; main function is not in a class;

Additionally, Java compiles into bytecode and can be run on any machine with the proper JVM. C++ needs computer specific compilers.

12. What is inherited from the base class in C++?

In principle, a derived class inherits every member of a base class except:

• its constructor and its destructor
• its operator=() members
• its friends

Although the constructors and destructors of the base class are not inherited themselves, its default constructor (i.e., its constructor with no parameters) and its destructor are always called when a new object of a derived class is created or destroyed.

If the base class has no default constructor or you want that an overloaded constructor is called when a new derived object is created, you can specify it in each constructor definition of the derived class:

derived_constructor_name (parameters) : base_constructor_name (parameters) {...}
For example: 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

// constructors and derived classes #include <iostream> using namespace std; class mother { public: mother () { cout << "mother: no parameters\n"; } mother (int a) { cout << "mother: int parameter\n"; } }; class daughter : public mother { public: daughter (int a) { cout << "daughter: int parameter\n\n"; } }; class son : public mother { public: son (int a) : mother (a) { cout << "son: int parameter\n\n"; } }; int main () { daughter cynthia (0); son daniel(0); return 0; }

mother: no parameters daughter: int parameter mother: int parameter son: int parameter

Notice the difference between which mother's constructor is called when a new daughter object is created and which when it is a son object. The difference is because the constructor declaration of daughter and son:

1 2	daughter (int a) // nothing specified: call default son (int a) : mother (a) // constructor specified: call this

13. Whats is the difference between private, public, protected inheritance in c++

these access specifiers specifies the way the parent members are visible in its children.

In case of private inheritance, both public and protected member will become private in child class, and cannot be inherited further down.

In case of public inheritance, public members will remain as public in child class and can be inherited further down, where as the protected members will remain as protected in the child class.

In case of protected inheritance, public and protected members will become protected in the childclass.

To answer that question, I'd like to describe member's accesors first on my own words. If you already know this, goto next.

There are three accesors that I'm aware of: public, protected and private.

Let:

class Base {
    public:
        int publicMember;
    private:
        int privateMember;
    protected:
        int protectedMember;
};

• Everything which is aware of Base, is also aware that Base contains publicMember.
• Only the children (and their children) are aware that Base contains protectedMember.
• No one but Base is aware of privateMember.

By "been aware", I mean "acknowledge the existence of, thus, it can be access it".

next:

The same happens with public, private and protected inheritance. Let's have a class Base and a class Child which inherits from Base.

• Shall such inheritance be public, everything which is aware of Base and Child, is also aware that Child inherits from Base.
• Shall such inheritance be protected, only Child (and its children), is aware that itself inherits from Base.
• Shall such inheritance be private, no one other than Child is aware of such inheritance.

14. 

Friendship and inheritance

Friend functions

In principle, private and protected members of a class cannot be accessed from outside the same class in which they are declared. However, this rule does not affect friends.

Friends are functions or classes declared with the friend keyword.

If we want to declare an external function as friend of a class, thus allowing this function to have access to the private and protected members of this class, we do it by declaring a prototype of this external function within the class, and preceding it with the keyword friend:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// friend functions #include <iostream> using namespace std; class CRectangle { int width, height; public: void set_values (int, int); int area () {return (width * height);} friend CRectangle duplicate (CRectangle); }; void CRectangle::set_values (int a, int b) { width = a; height = b; } CRectangle duplicate (CRectangle rectparam) { CRectangle rectres; rectres.width = rectparam.width*2; rectres.height = rectparam.height*2; return (rectres); } int main () { CRectangle rect, rectb; rect.set_values (2,3); rectb = duplicate (rect); cout << rectb.area(); return 0; }

24

The duplicate function is a friend of CRectangle. From within that function we have been able to access the members width and height of different objects of type CRectangle, which are private members. Notice that neither in the declaration of duplicate() nor in its later use in main() have we considered duplicate a member of classCRectangle. It isn't! It simply has access to its private and protected members without being a member.

The friend functions can serve, for example, to conduct operations between two different classes. Generally, the use of friend functions is out of an object-oriented programming methodology, so whenever possible it is better to use members of the same class to perform operations with them. Such as in the previous example, it would have been shorter to integrate duplicate() within the class CRectangle.

Friend classes

Just as we have the possibility to define a friend function, we can also define a class as friend of another one, granting that first class access to the protected and private members of the second one.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// friend class #include <iostream> using namespace std; class CSquare; class CRectangle { int width, height; public: int area () {return (width * height);} void convert (CSquare a); }; class CSquare { private: int side; public: void set_side (int a) {side=a;} friend class CRectangle; }; void CRectangle::convert (CSquare a) { width = a.side; height = a.side; } int main () { CSquare sqr; CRectangle rect; sqr.set_side(4); rect.convert(sqr); cout << rect.area(); return 0; }

16

In this example, we have declared CRectangle as a friend of CSquare so that CRectangle member functions could have access to the protected and private members of CSquare, more concretely to CSquare::side, which describes the side width of the square.

You may also see something new at the beginning of the program: an empty declaration of class CSquare. This is necessary because within the declaration of CRectangle we refer to CSquare (as a parameter in convert()). The definition of CSquare is included later, so if we did not include a previous empty declaration for CSquare this class would not be visible from within the definition of CRectangle.

Consider that friendships are not corresponded if we do not explicitly specify so. In our example, CRectangle is considered as a friend class by CSquare, but CRectangle does not consider CSquare to be a friend, so CRectanglecan access the protected and private members of CSquare but not the reverse way. Of course, we could have declared also CSquare as friend of CRectangle if we wanted to.

Another property of friendships is that they are not transitive: The friend of a friend is not considered to be a friend unless explicitly specified.