C++ file extensions:

• .cpp
• .CC
• .cxx

C++ header file extensions

• .hpp
• .h
• hxx

The recommended extensions are .cpp and .hpp

• The selection of a file extensions usually comes down to preference or versions of software you're using

The output of the compiled code comes out as a .o file

Preproccesed C++ Source Files have a .ii file extension

A class in C++ is a user-defined type or data structure declared with any of the keywords class, struct, or union

• By default access to members of a C++ class declared with the keyword class is private. The private members are not accessible outside the class; they can be accessed only through member functions of the class
• The public members form an interface to the class and are accessible outside the class.

Member functions are the functions, which have their declaration inside the class definition and works on the data members of the class. The definition of member functions can be inside or outside the definition of class.

• if its defined outside the class, use the scope resolution :: operator along with class name along with function name.

defined inside:

class Cube
{
    public:
    int side;
    int getVolume()
    {
        return side*side*side;      //returns volume of cube
    }
};

defined outside:

class Cube
{
    public:
    int side;
    int getVolume();
}

int Cube :: getVolume()
{
    return side*side*side;
}

A constructor in C++ is a special ‘MEMBER FUNCTION’ having the same name as that of its class which is used to initialize some valid values to the data members of an object. It is executed automatically whenever an object of a class is created.

default constructor

class Line
{
 public:
 int size;

Line()
{
 size=30;
}
};
/////////////
int main()
{
 //default constructor called when object is created
 Line l;
}

parameter constructor

class ABC
{
     private:
        int x,y;
     public:
        ABC ()       //constructor 1 with no arguments
       {
            x = y = 0;
        }
        ABC(int a)    //constructor 2 with one argument
       {
             x = y = a;
        }
        ABC(int a,int b)    //constructor 3 with two argument
        {
              x = a; 
              y = b;
        }
};
/////////////////
int main()
{
     ABC cc1; //constructor 1
     ABC cc2(10); //constructor 2
     ABC cc3(10,20); //constructor 3
     return 0:
}

A destructor is a member function that is invoked automatically when the object goes out of scope or is explicitly destroyed by a call to delete or delete[]. A destructor has the same name as the class and is preceded by a ~. Example:….

• the destructor for class String is declared: ~String()

class String
{
    public:
        String(const char* ch);  // Declare the constructor
        ~String();               // Declare the destructor
    private:
        char* _text{nullptr};
};

// Define the destructor.
String::~String()
{
    // Deallocate the memory that was previously reserved for the string.
    delete[] _text;
}