Procedural programming is a programming methodology in which the code of a program is kept as concise as possible. Procedural programming is not suitable for coding complex problems because the code can become very complex as the program grows.

A friend function can only access the members of the class of which it is a friend. It does not have the power of accessing child class members. In inheritance, the derived class can access the members of the parent class, not the other way around.

A constructor is a special function, which has the same name as of the class. It is called implictly when an object is declared. The user is not required to call it explicitly like a normal method. There are three types of constructors - default, parameterized and copy constructor. A class can have more than one constructor, which is called as 'constructor overloading'

To overload a method we must keep some difference in their arguments. The difference in the arguments can be either in their numbers, orders or datatypes. For example, we can have two methods with the name sum(), first with two integer arguments and second with three arguments. If the arguments are same in number, datatype or order the compiler will throw an ambiguity error which will mean that it is not able to differentitate one method with the other. Example: void sum(int); void sum(int,int); void sum(double, int);

Declaring a destructor does not need a constructor to be declared. A destructor can be declared even when there is no constructor.

The (::) Scope Resolution Operator is used in C++ to define a class method, outside the class. Although the method is defined outside the class, it is still a member of the class. The scope resolution operator is used for some other purposes also. To define a method outside the class, we can use the code as given in the following example : class sample { int a=10; public:    void show(); }; void sample :: show() // defining the method outside the class. { cout<

A class has two types of members- variables and methods. To specify the accessibility of a class member, we can use access specifiers. There are three types of access specifiers available in C++ - private, public and protected. If none of the these is specified, the members have by default 'private' accessibility. A private member can be accessed inside the class but cannot be accessed using a class object. A private member cannot be inherited by a derived class also.

If the derived class and the base class contain a member with the same name, it is called 'Member Overriding'. For example, there is a class named 'A', which has a function named 'show()'. If we declare a child class of 'A' named 'B' and declare a function with the same name show () in B, the show() declared in B will hide the show() declared in A. If an object of class B' makes a call of show() , the one defined in the child class(B) will be processed. If an object of the base class makes a call to show(), then the one defined in the base class will be called.

The scope resolution operator (::) has many uses in C++. It is used to define a function outside the class and is used for removing ambiguity in class members. It cannot be overloaded.

An abstract class is a class that cannot be instantiated or in other words, it cannot be used to create an object. Since object declaration of such a class is not allowed, the only way to access its members is through inheritance. We can declare a child class of the abstract class and call the members of the class. To declare a class as abstract, we must declare a 'Pure Virtual Function' in it.

Ambiguity is a state when there are two or more methods with the same prototype, the compile cannot differentiate between them and therefore displays an error. For example, if we have two functions called 'sum(int)' , the compiler will not be able to decide which method to call when the user writes a statement like 'sum(10)'. 

Functions are programs that have names and perform a particular task. They are mostly used to perform a task again and again. They allow the users to reuse the same code without having to rewrite it. They are not considered to save disk space but they do save primary memory (RAM).

 A pure virtual function is a function that is declared as virtual in the base class and redeclared in the child class. In the base class, its declaration ends with the '=0' symbol. It cannot be defined in the base class rather all the child classes must override (provide definition) the pure virtual function as per their requirements. If a derived class fails to override the pure virtual function, the compiler displays an error.

A recursive function is a function that calls itself during execution. This allows the function to repeat itself several times displaying the result after each iteration. Recursive functions are popular among programmers since they allow them to write efficient program using minmal amount of code. 

The scope resolution operator is not used to inherit a class. The syntax for inheritance has a colon (:), not a scope operator. For example, to inherit a class named 'B' from a class named 'A', the syntax will be class B : public A

The constructor and destructor of a class can be invoked (called) only once per object. An object of a class can call a normal method as many times as required but a constructor can be called just once. The same rule applies to the destructor also.

There is no dynamic constructor in C++. The different types of constructors are -- Default, Parameterized and Copy.

A function declared using the static keyword can access only the static variable of a class. If a call to a non- static member variable is made in a static function, the compiler will return an error. The syntax to call a static function is  classname::functionname() A static function is not called using a class object but by using the class name along with the scope resolution operator.

One of the features of C++ is that you can give special meanings to operators, when they are used with user-defined classes. This is called operator overloading. You can implement C++ operator overloads by providing special member-functions on your classes that follow a particular naming convention. For example: To overload the' +' operator for your class, you would provide a member-function named operator+ on your class, similarly to overload the operator '>', the name of the function will be operator>. While overloading an operator, the name of the method must be 'operator'.

Although declared inside the class, a friend function is not a member of the class. Therefore, while calling it, we do not need to use the object name as we do with the class members. A class member is called by using the syntax 

objectname.methodname(); whereas a friend function is called by using the syntax methodname();

A pure virtual function is a function that has no body in the base class. To declare a function as virtual we just have to add 'function() = 0' in the function declaration. A class that contains at least one pure virtual function is called an 'abstract' class and it cannot be instantiated.

In the process of inheritance, if the base class has a parameterized constructor the derived class should also have a parameterized constructor. Therefore, if the parent class of constructor takes an integer value as input, the value must be passed from the child class constructor to the parent class constructor.

The size of the object is the total size of all the variables declared in all the classes, irrespective of their access specifier and the inheritance visibility mode. Therefore, if you calculate the size of all the variables in the three classes with int as 2 bytes, float 4 bytes and char 1 byte, you will see there are 4 integers (4x2 = 8), 1 char (1x1=1) and 2 floats (4x2=8).

The print() is declared as public in the sub class. Therefore, an object of the sub class can easily access the print() method.