Virtual Function

A virtual function is a member function of a class that is declared using the virtual keyword and is meant to be overridden in a derived class. It supports runtime polymorphism, meaning the function that gets executed is determined at runtime based on the object, not the pointer type.

Example (C++)

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base class" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        cout << "Derived class" << endl;
    }
};

int main() {
    Base* ptr;
    Derived obj;
    ptr = &obj;
    ptr->show();  // Calls Derived class function
}

Because the function is virtual, the Derived class version is called even though the pointer type is Base.

Software Testing

Software testing is the process of evaluating and verifying that a software application works correctly according to the specified requirements. It is performed to identify bugs, errors, or defects before the software is delivered to users.

The main objective of software testing is to ensure quality, reliability, performance, and security of the software system.

Copy Constructor

A copy constructor is a special constructor in a class that initializes a new object using another object of the same class. It is mainly used to create a copy of an existing object.

Example (C++):

class Sample {
public:
    int x;
    Sample(int a) { x = a; }
    Sample(const Sample &obj) { x = obj.x; }
};

Static Binding (Early Binding)

Static binding occurs when the function call is resolved at compile time. The compiler determines which function to execute based on the reference type of the object. It does not depend on the actual object at runtime.

Static binding usually happens in function overloading, normal member functions, and when virtual keyword is not used. It is faster because the decision is made during compilation.

Example: If a base class pointer calls a non-virtual function, the base class version will execute even if it points to a derived object.

Dynamic Binding (Late Binding)

Dynamic binding occurs when the function call is resolved at runtime. The decision of which function to execute depends on the actual object, not the reference type.

Dynamic binding happens when virtual functions are used. It supports runtime polymorphism and allows method overriding to work properly.

Example: If a base class pointer calls a virtual function, the derived class version will execute if the object belongs to the derived class.

Primary Key, Super Key and Candidate Key

Super Key

A Super Key is any attribute or set of attributes that can uniquely identify a record in a table. It may contain extra attributes that are not necessary for unique identification.

Example: In a Student table (Student_ID, Email, Name), {Student_ID}, {Email}, and {Student_ID, Name} are Super Keys because they uniquely identify each student.

Candidate Key

A Candidate Key is a minimal Super Key. It contains only the necessary attributes required to uniquely identify a record, without any extra attributes.

Example: In the Student table, {Student_ID} and {Email} are Candidate Keys because both uniquely identify students and have no unnecessary attributes.

Primary Key

A Primary Key is one Candidate Key selected to uniquely identify records in a table. It cannot contain NULL or duplicate values.

Example: If {Student_ID} is chosen among candidate keys, then Student_ID becomes the Primary Key.