{"id":37,"date":"2002-09-27T01:26:13","date_gmt":"2002-09-27T01:26:13","guid":{"rendered":"http:\/\/bitpost.com\/news\/?p=14"},"modified":"2008-07-24T23:53:47","modified_gmt":"2008-07-25T04:53:47","slug":"reuse-dammit","status":"publish","type":"post","link":"https:\/\/bitpost.com\/news\/2002\/reuse-dammit\/","title":{"rendered":"C++ Skills Interview Questions"},"content":{"rendered":"
  • ABB: “Interview these 12 people TODAY!”<\/li>\n
  • Me: “OK…”, HOURS later… “I liked these 2, what’s next?”<\/li>\n
  • ABB: “Didn’t you hear? Hiring freeze in effect for the next 12 months!”With all the non-productive interviews Zac and I have done here at ABB over the last few months, I’ve scrounged up a lame list like this<\/a> at least two dozen times. NO MORE! \ud83d\ude1b\n

    And to guarantee this is the final time, I’m cutting and pasting it into the body of this article (hit “Read More” to see it)…<\/p>\n

    The C++ Interview<\/h2>\n

    These 40 questions and answers will help you land the assignment<\/h3>\n

    by Alex Bykov<\/i>
    \nHow do you rank your C++ skills on a scale of 1 to 10?<\/b>
    \nThis is often the first question you will hear on an interview for a
    \nC++ contract. You will be tempted to rate yourself high, and you should.
    \nThis is your chance to convince the client that you are just what he is
    \nlooking for–an assertive and knowledgeable professional who will be productive
    \neither working on a team or on your own. Naturally, though, you should
    \nbe able to support the ranking you gave yourself by doing well on the
    \ninterview. This article will help you prepare for your C++ interview.<\/p>\n

    I put together a list of 40 questions that I have had to answer during
    \nnumerous technical interviews in the past few years. You, too, will have
    \nto answer at least some of them during an interview. Even if you use C++
    \non a daily basis, it pays to go through the questions. Most of us, no
    \nmatter how experienced, use only a segment of the language that we are
    \nmost comfortable with. Brief answers are included, but you can find more
    \ninformation in the     references<\/a> listed.
    \nQ1.<\/b> Is there anything you can do in C++ that you cannot
    \ndo in C?<\/b><\/i>
    \nA1.<\/b> No. There is nothing you can do in C++ that you cannot do
    \nin C. After all you can write a C++ compiler in C.
    \nQ2.<\/b> What is the difference between C++ structure and C++
    \nclass?<\/i><\/b>
    \nA2.<\/b> The default access level assigned to members of struct is
    \npublic while the default access level assigned to a class is private.<\/p>\n

    Q3.<\/b> What is encapsulation?<\/i> <\/b>
    \nA3.<\/b> Encapsulation is welding of code and data together into objects.
    \nQ4.<\/b> What is inheritance?<\/i><\/b>
    \nA4.<\/b> Inheritance is a mechanism through which a subclass inherits
    \nthe properties and behavior of its superclass.
    \nQ5. What is polymorphism?<\/i><\/b>
    \nA5.<\/b> In Greek this means "many shapes." As a consequence
    \nof inheritance and virtual functions, a single task (for example, drawing
    \na geometrical shape) can be implemented using the same name (like draw())
    \nand implemented differently (via virtual functions) as each type in object
    \nhierarchy requires(circle.draw() or rectangle.draw()). Later, when a polymorphic
    \nobject (whose type is not known at compile time) executes the draw() virtual
    \nfunction, the correct implementation is chosen and executed at run time.<\/p>\n

    Q6. What would you say if you saw "delete this" while
    \nreviewing your peer’s code?<\/i><\/b>
    \nA6.<\/b> You should never do this. Since compiler does not know whether
    \nthe object was allocated on the stack or on the heap, "delete this"
    \ncould cause a disaster.
    \nQ7. What is the difference between public, protected, and private
    \nmembers of a class?<\/i><\/b>
    \nA7.<\/b> Private members are accessible only by members and friends
    \nof the class. Protected members are accessible by members and friends
    \nof the class and by members and friends of derived classes. Public members
    \nare accessible by everyone.
    \nQ8. What is the difference between non-virtual and virtual functions?<\/i><\/b><\/p>\n

    A8.<\/b> The behavior of a non-virtual function is known at compile
    \ntime while the behavior of a virtual function is not known until the run
    \ntime.
    \nQ9. What is a pure virtual function?<\/i><\/b>
    \nA9.<\/b> “A pure virtual function is a function declared in a base
    \nclass that has no definition relative to the base.”
    \nQ10. What is an abstract base class?<\/i><\/b>
    \nA10.<\/b> It is a class that has one or more pure virtual functions.<\/p>\n

    Q11. What is the difference between MyClass p; and MyClass p();?<\/i><\/b><\/p>\n

    A11.<\/b> MyClass p; creates an instance of class MyClass by calling
    \na constructor for MyClass. MyClass p(); declares function p which takes
    \nno parameters and returns an object of class MyClass by value.
    \nQ12. How do you know that your class needs a virtual destructor?<\/i><\/b><\/p>\n

    A12.<\/b> If your class has at least one virtual function, you should
    \nmake a destructor for this class virtual. This will allow you to delete
    \na dynamic object through a pointer to a base class object. If the destructor
    \nis non-virtual, then wrong destructor will be invoked during deletion
    \nof the dynamic object.
    \nQ13. Why were the templates introduced?<\/i><\/b>
    \nA13.<\/b> Many data structures and algorithms can be defined independently
    \nof the type of data they work with. You can increase the amount of shared
    \ncode by separating data-dependent portions from data-independent portions,
    \nand templates were introduced to help you do that.
    \nQ14. What is a static member of a class?<\/i><\/b>
    \nA14.<\/b> Static data members exist once for the entire class, as opposed
    \nto non-static data members, which exist individually in each instance
    \nof a class.
    \nQ15.<\/b> What feature of C++ would you use if you wanted to
    \ndesign a member function that guarantees to leave "this\u00c3\u201c object unchanged?<\/i><\/b><\/p>\n

    A15.<\/b> It is "const" as in: "int MyFunc (int test)
    \nconst;"
    \nQ16. Can you overload a function based only on whether a parameter
    \nis a value or a reference?<\/i><\/b>
    \nA16.<\/b> No. Passing by value and by reference looks identical to
    \nthe caller.
    \nQ17. What is the difference between function overloading and function
    \noverriding?<\/i><\/b>
    \nA17.<\/b> Overloading is a method that allows defining multiple member
    \nfunctions with the same name but different signatures. The compiler will
    \npick the correct function based on the signature. Overriding is a method
    \nthat allows the derived class to redefine the behavior of member functions
    \nwhich the derived class inherits from a base class. The signatures of
    \nboth base class member function and derived class member function are
    \nthe same; however, the implementation and, therefore, the behavior will
    \ndiffer.
    \nQ18. Can derived class override some but not all of a set of overloaded
    \nvirtual member functions inherited from the base class?<\/i><\/b>
    \nA18.<\/b> Compiler will allow this, but it is a bad practice since
    \noverridden member functions will hide all of the inherited overloads from
    \nthe base class. You should really override all of them.
    \nQ19. What is the difference between assignment and initialization
    \nin C++?<\/i><\/b>
    \nA19.<\/b> Assignment changes the value of the object that has already
    \nbeen constructed. Initialization constructs a new object and gives it
    \na value at the same time.
    \nQ20. When are copy constructors called?<\/i><\/b>
    \nA20.<\/b> Copy constructors are called in three cases: when a function
    \nreturns an object of that class by value, when the object of that class
    \nis passed by value as an argument to a function, and, finally, when you
    \nconstruct an object based on another object of the same class (Circle
    \nc1=c2;).
    \nQ21. Why do you have to provide your own copy constructor and assignment
    \noperator for classes with dynamically allocated memory?<\/i> <\/b>
    \nA21.<\/b> If you don’t, the compiler will supply and execute the default
    \nconstructor and the assignment operator, but they will not do the job
    \ncorrectly. The default assignment operator does memberwise assignment
    \nand the default copy constructor does memberwise copy. In both cases you
    \nwill only assign and manipulate pointers to dynamic memory, which will
    \nlead to memory leaks and other abnormalities. You should write your own
    \nassignment operator and copy constructor, which would copy the pointer
    \nto memory so that each object has its own copy.
    \nQ22. Does compiler guarantee that initializers will be executed
    \nin the same order as they appear on the initialization list?<\/i><\/b>
    \nA22.<\/b> No. C++ guarantees that base class subobjects and member
    \nobjects will be destroyed in the opposite order from which they were constructed.
    \nThis means that initializers are executed in the order, which supports
    \nthe above-mentioned guarantee.
    \nQ23. What is function’s signature?<\/i><\/b>
    \nA23.<\/b> Function’s signature is its name plus the number and types
    \nof the parameters it accepts.
    \nQ24. What does extern "C" int func(int *, Foo) accomplish?<\/i><\/b><\/p>\n

    A24.<\/b> It will turn off "name mangling" for this function
    \nso that one can link to code compiled by C compiler.
    \nQ25. Why do C++ compilers need name mangling?<\/i><\/b>
    \nA25.<\/b> Name mangling is the rule according to which C++ changes
    \nfunction’s name into function signature before passing that function to
    \na linker. This is how the linker differentiates between different functions
    \nwith the same name.
    \nQ26. What is the difference between a pointer and a reference?<\/i><\/b><\/p>\n

    A26.<\/b> A reference must always refer to some object and, therefore,
    \nmust always be initialized; pointers do not have such restrictions. A
    \npointer can be reassigned to point to different objects while a reference
    \nalways refers to an object with which it was initialized.
    \nQ27.<\/b> How can you access the static member of a class?<\/i><\/b><\/p>\n

    A27.<\/b> <ClassName>::<StaticMemberName>.
    \nQ28. How are prefix and postfix versions of operator++() differentiated?<\/i>
    \n<\/b>
    \nA28.<\/b> The postfix version of operator++() has a dummy parameter
    \nof type int. The prefix version does not have dummy parameter.
    \nQ29. What functions does C++ silently write and call?<\/i><\/b>
    \nA29.<\/b> Constructors, destructors, copy constructors, assignment
    \noperators, and address-of operators.
    \nQ30. What is the difference between new\/delete and malloc\/free?<\/i><\/b>
    \nA30.<\/b> Malloc\/free do not know about constructors and destructors.
    \nNew and delete create and destroy objects, while malloc and free allocate
    \nand deallocate memory.
    \nQ31. What is the difference between delete and delete[ ]?<\/i><\/b><\/p>\n

    A31.<\/b> Delete deletes one object; delete[ ] deletes an array of
    \nobjects.
    \nQ32. Name two cases where you MUST use initialization list as opposed
    \nto assignment in constructors.<\/i><\/b>
    \nA32.<\/b> Both non-static const data members and reference data members
    \ncannot be assigned values; instead, you should use initialization list
    \nto initialize them.
    \nQ33. What is the difference between const char *myPointer and char
    \n*const myPointer?<\/i><\/b>
    \nA33.<\/b> Const char *myPointer is a non constant pointer to constant
    \ndata; while char *const myPointer is a constant pointer to non constant
    \ndata.
    \nQ34. Suppose that objects A, B, and C are instances of class MyClass
    \n(MyClass A, B, C;). How should you design an assignment operator so that
    \nthe "A=B=C;" statement would be allowed by a compiler but "(A=B)=C;"
    \nwould not be allowed by a compiler?<\/i> <\/b>
    \nA34.<\/b> Make operator=return a reference to a const object.
    \nQ35. Is there any problem with the following: char *a=NULL; char&
    \np = *a;?<\/i> <\/b>
    \nA35.<\/b> The result is undefined. You should never do this. A reference
    \nmust always refer to some object.
    \nQ36. Class B is derived from class A. Function f is A’s friend.
    \nIs f B’s friend as well?<\/i><\/b>
    \nA36.<\/b> No. Friendship cannot be inherited.
    \nQ37. What issue do auto_ptr objects address?<\/i><\/b>
    \nA37.<\/b> If you use auto_ptr objects you would not have to be concerned
    \nwith heap objects not being deleted even if the exception is thrown.
    \nQ38. What happens when a function throws an exception that was
    \nnot specified by an exception specification for this function?<\/i><\/b><\/p>\n

    A38.<\/b> Unexpected() is called, which, by default, will eventually
    \ntrigger abort().
    \nQ39. Why should you prefer throw\/catch mechanism to setjmp\/longjmp?<\/i><\/b><\/p>\n

    A39.<\/b> The main problem with longjmp() is that it does not destroy
    \nlocal objects properly.
    \nQ40. Can you think of a situation where your program would crash
    \nwithout reaching the breakpoint which you set at the beginning of main()?<\/i><\/b>
    \nA40.<\/b> C++ allows for dynamic initialization of global variables
    \nbefore main() is invoked. It is possible that initialization of global
    \nwill invoke some function. If this function crashes the crash will occur
    \nbefore main() is entered.
    \nIf you feel comfortable answering these questions, then rest assured
    \nthat your chances of impressing any interviewer are very high. Be prepared
    \nto know basic computer science concepts such as data structures, search
    \nand sort algorithms, basic database concepts, etc. The client’s needs
    \nwill determine what particular branch of computer science you have to
    \nbe familiar with, but you should always be ready to implement the stock,
    \nthe queue, and the linked list data structures with either C or C++ programming
    \nlanguages. And know how to write your own version of strcpy (string copy)
    \nin C programming language since very often they ask you to do that.<\/li>\n","protected":false},"excerpt":{"rendered":"
    \n

    The C++ Interview<\/h2>\n

    These 40 questions and answers will help you land the assignment<\/h3>\n

    by Alex Bykov<\/i><\/p>\n

    How do you rank your C++ skills on a scale of 1 to 10?<\/b> <\/p>\n

    This is often the first question you will hear on an interview for a
    \n C++ contract. You will be tempted to rate yourself high, and you should.
    \n This is your chance to convince the client that you are just what he is
    \n looking for–an assertive and knowledgeable professional who will be productive
    \n either working on a team or on your own. Naturally, though, you should
    \n be able to support the ranking you gave yourself by doing well on the
    \n interview. This article will help you prepare for your C++ interview.\n <\/p>\n

    I put together a list of 40 questions that I have had to answer during
    \n numerous technical interviews in the past few years. You, too, will have
    \n to answer at least some of them during an interview. Even if you use C++
    \n on a daily basis, it pays to go through the questions. Most of us, no
    \n matter how experienced, use only a segment of the language that we are
    \n most comfortable with. Brief answers are included, but you can find more
    \n information in the     references<\/a> listed. <\/p>\n

    Q1.<\/b> Is there anything you can do in C++ that you cannot
    \n do in C?<\/b><\/i> <\/p>\n

    A1.<\/b> No. There is nothing you can do in C++ that you cannot do
    \n in C. After all you can write a C++ compiler in C. <\/p>\n

    Q2.<\/b> What is the difference between C++ structure and C++
    \n class?<\/i><\/b> <\/p>\n

    A2.<\/b> The default access level assigned to members of struct is
    \n public while the default access level assigned to a class is private.\n <\/p>\n

    Q3.<\/b> What is encapsulation?<\/i> <\/b><\/p>\n

    A3.<\/b> Encapsulation is welding of code and data together into objects.<\/p>\n

    Q4.<\/b> What is inheritance?<\/i><\/b> <\/p>\n

    A4.<\/b> Inheritance is a mechanism through which a subclass inherits
    \n the properties and behavior of its superclass. <\/p>\n

    Q5. What is polymorphism?<\/i><\/b> <\/p>\n

    A5.<\/b> In Greek this means "many shapes." As a consequence
    \n of inheritance and virtual functions, a single task (for example, drawing
    \n a geometrical shape) can be implemented using the same name (like draw())
    \n and implemented differently (via virtual functions) as each type in object
    \n hierarchy requires(circle.draw() or rectangle.draw()). Later, when a polymorphic
    \n object (whose type is not known at compile time) executes the draw() virtual
    \n function, the correct implementation is chosen and executed at run time.\n <\/p>\n

    Q6. What would you say if you saw "delete this" while
    \n reviewing your peer’s code?<\/i><\/b> <\/p>\n

    A6.<\/b> You should never do this. Since compiler does not know whether
    \n the object was allocated on the stack or on the heap, "delete this"
    \n could cause a disaster. <\/p>\n

    Q7. What is the difference between public, protected, and private
    \n members of a class?<\/i><\/b> <\/p>\n

    A7.<\/b> Private members are accessible only by members and friends
    \n of the class. Protected members are accessible by members and friends
    \n of the class and by members and friends of derived classes. Public members
    \n are accessible by everyone. <\/p>\n

    Q8. What is the difference between non-virtual and virtual functions?<\/i><\/b>\n <\/p>\n

    A8.<\/b> The behavior of a non-virtual function is known at compile
    \n time while the behavior of a virtual function is not known until the run
    \n time. <\/p>\n

    Q9. What is a pure virtual function?<\/i><\/b> <\/p>\n

    A9.<\/b> “A pure virtual function is a function declared in a base
    \n class that has no definition relative to the base.”<\/p>\n

    Q10. What is an abstract base class?<\/i><\/b> <\/p>\n

    A10.<\/b> It is a class that has one or more pure virtual functions.\n <\/p>\n

    Q11. What is the difference between MyClass p; and MyClass p();?<\/i><\/b>\n <\/p>\n

    A11.<\/b> MyClass p; creates an instance of class MyClass by calling
    \n a constructor for MyClass. MyClass p(); declares function p which takes
    \n no parameters and returns an object of class MyClass by value. <\/p>\n

    Q12. How do you know that your class needs a virtual destructor?<\/i><\/b>\n <\/p>\n

    A12.<\/b> If your class has at least one virtual function, you should
    \n make a destructor for this class virtual. This will allow you to delete
    \n a dynamic object through a pointer to a base class object. If the destructor
    \n is non-virtual, then wrong destructor will be invoked during deletion
    \n of the dynamic object. <\/p>\n

    Q13. Why were the templates introduced?<\/i><\/b> <\/p>\n

    A13.<\/b> Many data structures and algorithms can be defined independently
    \n of the type of data they work with. You can increase the amount of shared
    \n code by separating data-dependent portions from data-independent portions,
    \n and templates were introduced to help you do that. <\/p>\n

    Q14. What is a static member of a class?<\/i><\/b> <\/p>\n

    A14.<\/b> Static data members exist once for the entire class, as opposed
    \n to non-static data members, which exist individually in each instance
    \n of a class. <\/p>\n

    Q15.<\/b> What feature of C++ would you use if you wanted to
    \n design a member function that guarantees to leave "this\u00c3\u0192\u00e2\u20ac\u0153 object unchanged?<\/i><\/b>\n <\/p>\n

    A15.<\/b> It is "const" as in: "int MyFunc (int test)
    \n const;" <\/p>\n

    Q16. Can you overload a function based only on whether a parameter
    \n is a value or a reference?<\/i><\/b> <\/p>\n

    A16.<\/b> No. Passing by value and by reference looks identical to
    \n the caller. <\/p>\n

    Q17. What is the difference between function overloading and function
    \n overriding?<\/i><\/b> <\/p>\n

    A17.<\/b> Overloading is a method that allows defining multiple member
    \n functions with the same name but different signatures. The compiler will
    \n pick the correct function based on the signature. Overriding is a method
    \n that allows the derived class to redefine the behavior of member functions
    \n which the derived class inherits from a base class. The signatures of
    \n both base class member function and derived class member function are
    \n the same; however, the implementation and, therefore, the behavior will
    \n differ. <\/p>\n

    Q18. Can derived class override some but not all of a set of overloaded
    \n virtual member functions inherited from the base class?<\/i><\/b> <\/p>\n

    A18.<\/b> Compiler will allow this, but it is a bad practice since
    \n overridden member functions will hide all of the inherited overloads from
    \n the base class. You should really override all of them. <\/p>\n

    Q19. What is the difference between assignment and initialization
    \n in C++?<\/i><\/b> <\/p>\n

    A19.<\/b> Assignment changes the value of the object that has already
    \n been constructed. Initialization constructs a new object and gives it
    \n a value at the same time. <\/p>\n

    Q20. When are copy constructors called?<\/i><\/b> <\/p>\n

    A20.<\/b> Copy constructors are called in three cases: when a function
    \n returns an object of that class by value, when the object of that class
    \n is passed by value as an argument to a function, and, finally, when you
    \n construct an object based on another object of the same class (Circle
    \n c1=c2;). <\/p>\n

    Q21. Why do you have to provide your own copy constructor and assignment
    \n operator for classes with dynamically allocated memory?<\/i> <\/b><\/p>\n

    A21.<\/b> If you don’t, the compiler will supply and execute the default
    \n constructor and the assignment operator, but they will not do the job
    \n correctly. The default assignment operator does memberwise assignment
    \n and the default copy constructor does memberwise copy. In both cases you
    \n will only assign and manipulate pointers to dynamic memory, which will
    \n lead to memory leaks and other abnormalities. You should write your own
    \n assignment operator and copy constructor, which would copy the pointer
    \n to memory so that each object has its own copy. <\/p>\n

    Q22. Does compiler guarantee that initializers will be executed
    \n in the same order as they appear on the initialization list?<\/i><\/b> <\/p>\n

    A22.<\/b> No. C++ guarantees that base class subobjects and member
    \n objects will be destroyed in the opposite order from which they were constructed.
    \n This means that initializers are executed in the order, which supports
    \n the above-mentioned guarantee. <\/p>\n

    Q23. What is function’s signature?<\/i><\/b> <\/p>\n

    A23.<\/b> Function’s signature is its name plus the number and types
    \n of the parameters it accepts.<\/p>\n

    Q24. What does extern "C" int func(int *, Foo) accomplish?<\/i><\/b>\n <\/p>\n

    A24.<\/b> It will turn off "name mangling" for this function
    \n so that one can link to code compiled by C compiler. <\/p>\n

    Q25. Why do C++ compilers need name mangling?<\/i><\/b> <\/p>\n

    A25.<\/b> Name mangling is the rule according to which C++ changes
    \n function’s name into function signature before passing that function to
    \n a linker. This is how the linker differentiates between different functions
    \n with the same name. <\/p>\n

    Q26. What is the difference between a pointer and a reference?<\/i><\/b>\n <\/p>\n

    A26.<\/b> A reference must always refer to some object and, therefore,
    \n must always be initialized; pointers do not have such restrictions. A
    \n pointer can be reassigned to point to different objects while a reference
    \n always refers to an object with which it was initialized.<\/p>\n

    Q27.<\/b> How can you access the static member of a class?<\/i><\/b>\n <\/p>\n

    A27.<\/b> <ClassName>::<StaticMemberName>. <\/p>\n

    Q28. How are prefix and postfix versions of operator++() differentiated?<\/i>
    \n <\/b> <\/p>\n

    A28.<\/b> The postfix version of operator++() has a dummy parameter
    \n of type int. The prefix version does not have dummy parameter. <\/p>\n

    Q29. What functions does C++ silently write and call?<\/i><\/b> <\/p>\n

    A29.<\/b> Constructors, destructors, copy constructors, assignment
    \n operators, and address-of operators. <\/p>\n

    Q30. What is the difference between new\/delete and malloc\/free?<\/i><\/b><\/p>\n

    A30.<\/b> Malloc\/free do not know about constructors and destructors.
    \n New and delete create and destroy objects, while malloc and free allocate
    \n and deallocate memory. <\/p>\n

    Q31. What is the difference between delete and delete[ ]?<\/i><\/b>\n <\/p>\n

    A31.<\/b> Delete deletes one object; delete[ ] deletes an array of
    \n objects. <\/p>\n

    Q32. Name two cases where you MUST use initialization list as opposed
    \n to assignment in constructors.<\/i><\/b> <\/p>\n

    A32.<\/b> Both non-static const data members and reference data members
    \n cannot be assigned values; instead, you should use initialization list
    \n to initialize them. <\/p>\n

    Q33. What is the difference between const char *myPointer and char
    \n *const myPointer?<\/i><\/b> <\/p>\n

    A33.<\/b> Const char *myPointer is a non constant pointer to constant
    \n data; while char *const myPointer is a constant pointer to non constant
    \n data. <\/p>\n

    Q34. Suppose that objects A, B, and C are instances of class MyClass
    \n (MyClass A, B, C;). How should you design an assignment operator so that
    \n the "A=B=C;" statement would be allowed by a compiler but "(A=B)=C;"
    \n would not be allowed by a compiler?<\/i> <\/b><\/p>\n

    A34.<\/b> Make operator=return a reference to a const object. <\/p>\n

    Q35. Is there any problem with the following: char *a=NULL; char&
    \n p = *a;?<\/i> <\/b><\/p>\n

    A35.<\/b> The result is undefined. You should never do this. A reference
    \n must always refer to some object. <\/p>\n

    Q36. Class B is derived from class A. Function f is A’s friend.
    \n Is f B’s friend as well?<\/i><\/b> <\/p>\n

    A36.<\/b> No. Friendship cannot be inherited.<\/p>\n

    Q37. What issue do auto_ptr objects address?<\/i><\/b> <\/p>\n

    A37.<\/b> If you use auto_ptr objects you would not have to be concerned
    \n with heap objects not being deleted even if the exception is thrown. <\/p>\n

    Q38. What happens when a function throws an exception that was
    \n not specified by an exception specification for this function?<\/i><\/b>\n <\/p>\n

    A38.<\/b> Unexpected() is called, which, by default, will eventually
    \n trigger abort(). <\/p>\n

    Q39. Why should you prefer throw\/catch mechanism to setjmp\/longjmp?<\/i><\/b>\n <\/p>\n

    A39.<\/b> The main problem with longjmp() is that it does not destroy
    \n local objects properly. <\/p>\n

    Q40. Can you think of a situation where your program would crash
    \n without reaching the breakpoint which you set at the beginning of main()?<\/i><\/b><\/p>\n

    A40.<\/b> C++ allows for dynamic initialization of global variables
    \n before main() is invoked. It is possible that initialization of global
    \n will invoke some function. If this function crashes the crash will occur
    \n before main() is entered. <\/p>\n

    If you feel comfortable answering these questions, then rest assured
    \n that your chances of impressing any interviewer are very high. Be prepared
    \n to know basic computer science concepts such as data structures, search
    \n and sort algorithms, basic database concepts, etc. The client’s needs
    \n will determine what particular branch of computer science you have to
    \n be familiar with, but you should always be ready to implement the stock,
    \n the queue, and the linked list data structures with either C or C++ programming
    \n languages. And know how to write your own version of strcpy (string copy)
    \n in C programming language since very often they ask you to do that. <\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[10],"tags":[],"class_list":["post-37","post","type-post","status-publish","format-standard","hentry","category-tricks-tips-tools"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t