• Primitive Datatype (basic datatype). Examples: char, float, long, short, double, int, bool, etc.
• Derived datatype. Example: array, pointer, etc.
• Enumeration. Example: enum
• User-defined data types. Example: structure, class, etc.

• C programming language is procedure-oriented and C++ programming language is object-oriented.
• C language doesn’t support data hiding whereas C++ language hides the data by encapsulation to ensure that data structures and operators
• C is a subset of C++ and C++ is a superset of C
• C doesn’t support Function and operator overloading whereas C++ does
• C doesn’t have Namespace features whereas C++ uses Namespace to avoid name collisions.
• In C language functions cannot be defined inside structures whereas C++ allows the function to be defined inside structures.

It is a user-defined data type that has data and member functions. Data members manage the data variables and member functions perform operations on these variables.

An object is an instance of a class. As we know that class is a user-defined data type so an object is called a variable of that data type.

A class is defined as-

class A{
Private:
int data;
Public:
void fun(){
}
};

• Members of the structure are public by default whereas Class members are private.
• When you derive a structure, default access specifiers are public whereas in Class the default access specifiers are private.

It is a very important element that runs the operations on user-defined data types. By using operator overloading you can change the default meaning to the operators like +, -, *, /, <=, etc.

For example:

By using operator overloading, Adding two complex numbers:

class complex{
Private:
float r, i;
Public:
complex(float r, float i){
this->r=r;
this->i=i;
}
complex(){}
void displaydata(){
cout«”real part = “«r«endl;
cout«”imaginary part = “«i«endl;
}
complex operator+(complex c){
return complex(r+c.r, i+c.i);
}
};
int main(){
complex a(2,3);
complex b(3,4);
complex c=a+b;
c.displaydata();
return 0;
}

Polymorphism defines having many forms and different situations bring different behavior. And this happens when we have many classes that are co-related by inheritance.

Polymorphism types in C++ are:

• Compile Time Polymorphism
• Runtime Polymorphism

It is a member function that automatically executes when an object is made. Constructors and the class member have the same name so the compiler knows that the specific member function is a constructor. Constructors use no return type.

Example:

class A{
Private:
int val;
Public:
A(int x){ //one argument constructor
val=x;
}
A(){ //zero argument constructor
}
}
int main(){
A a(3);

return 0;
}

A friend class can acquire protected, private, and public members of different classes in which it is claimed as friends. Same as friend class, friend function can also acquire protected, private, and public members but, friend functions are not member functions. For example -

class A{

private:

int data_a;

public:

A(int x){

data_a=x;

}

friend int fun(A, B);

}

class B{

private:

int data_b;

public:

A(int x){

data_b=x;

}

friend int fun(A, B);

}

int fun(A a, B b){

return a.data_a+b.data_b;

}

int main(){

A a(10);

B b(20);

cout«fun(a,b)«endl;

return 0;

}

• Public: All member functions and data members can be accessed outside the class.
• Protected: All member functions and data members can be accessed inside the class and to the derived class.
• Private: All member functions and data members cannot be accessed outside the class.

A reference is another name of an already present variable or like a pointer. Once a reference name is set with a variable, then a variable is accessible by the reference or variable name.

For example-

int x=10;

int &ref=x; //reference variable

If we modify the value of ref it will be replicated in x. Once a reference variable is set it cannot denote to any other variable.

call by reference: Here, we pass the address of the variable through which we are able to access the actual argument used by a function call. So modification in the parameter changes the passing argument.

call by value: Here, we permit a copy of the parameter that is passed to the functions. For the copied values a new memory is allocated and modifications made to these values do not show the variable in the main function.

A constructor is itself called when an object is created. Likewise, when an object demolishes a function, the destructor itself gets called. A constructor and destructor have the same name but are preceded by a tilde.

Example:

class A{

private:

int val;

public:

A(int x){

val=x;

}

A(){

}

~A(){ //destructor

}

}

int main(){

A a(3);

return 0;

}

When a class variable is stated static, then a specific space for it is assigned for the lifetime of the program. There is only one copy of the static member irrelevant of how many objects of that class have been made. So, all the objects of that class can access the static member.

If there is no object in the class then also a static member function can be called and accessed by only using the class name and the scope resolution operator::

If a member function initializes an object by using different objects of the same class then it is called a copy constructor

Example-

class A{

int x,y;

A(int x, int y){

this->x=x;

this->y=y;

}

};

int main(){

A a1(2,3);

A a2=a1; //default copy constructor is called

return 0;

}

• Shallow copy is faster than deep copy
• Shallow copy saves the references of objects to the original memory address whereas deep copy creates a new and separate copy of the object and allocates a unique memory address to it.
• Shallow copy shows changes done to the new/copied object in the original object whereas deep copy doesn’t show the changes there.

Virtual function: It is a base class member function that redefines in a derived class and is declared by using the virtual keyword.

Example-

class base{

public:

virtual void fun(){

}

};

Pure virtual function: A function that has no implementation and is declared by assigning 0 makes a pure virtual function, also it has nobody.

Example-

class base{

public:

virtual void fun()=0;

};

Yes, we are able to call a virtual function from a constructor. But the behavior is a little different in this case. When a virtual function is called, the virtual call is resolved at runtime. It is always the member function of the current class that gets called. That is the virtual machine doesn’t work within the constructor.

For example-

class base{

private:

int value;

public:

base(int x){

value=x;

}

virtual void fun(){

}

}

class derived{

private:

int a;

public:

derived(int x, int y):base(x){

base *b;

b=this;

b->fun(); //calls derived::fun()

}

void fun(){

cout«”fun inside derived class”«endl;

}

}

It is a pointer that has no data type. It can hold addresses of any type.

For example-

void *ptr;

char *str;

p=str; // no error

str=p; // error because of type mismatch

As we know that we can allocate a pointer of any type to a void pointer but the inverse is not true unless you write it as

str=(char*) ptr;

Every object member functions have a pointer that indicates to the object itself. The value is set to the address of the object for which it is called. It can access data in the object it points to.

Example

class A{

private:

int value;

public:

void setvalue(int x){

this->value=x;

}

};

int main(){

A a;

a.setvalue(5);

return 0;

}

A new operator allocates the memory and deletes the operator deallocates the memory in C++.

For example-

int value=new int; //allocates memory for storing 1 integer

delete value; // deallocates memory taken by value

int *arr=new int[10]; //allocates memory for storing 10 int

delete []arr; // deallocates memory occupied by arr

A token is a name provided to the different functions in C++ programs. Examples of tokens can be a keyword, string, symbol, identifier, literal, constant, etc. The token code in C++ other than C, is displayed as.

asm bool catch class

const_cast delete dynamic_cast explicit

export false friend inline

mutable namespace new operator

private protected public reinterpret_cast

static_cast template this throw

true try typeid typename

using virtual wchar_t

The compiler arranges a constructor for every class if a provider is not able to offer the same. This is when the developer gives no particular parameters to the constructor then it is called a default constructor. It is displayed as.

// Cpp program to illustrate the

// concept of Constructors

#include

using namespace std;

class construct {

public:

int a, b;

// Default Constructor

construct()

{

a = 10;

b = 20;

}

};

int main()

{

// Default constructor called automatically

// when the object is created

construct c;

cout « “a: " « c.a « endl

« “b: " « c.b;

return 1;

}

• C++ has destructors, and Java uses automatic garbage collection.
• C++ supports multiple inheritance, pointers, operator overloading, structures, unions, and templates. Java doesn’t have these.
• Java has a Thread class and also creates a new thread. C++ doesn’t have inbuilt support for threads
• C++ has a goto statement to jump from a position to some labeled statement within a function. Java doesn’t have any goto statement.

• The static member function can’t be virtual
• They don’t have ‘this’ pointer
• The static member function doesn’t have const, const volatile, and volatile declaration.

It is the name provided to the present variables. The variable name and reference variable point share a similar memory through which it can update the original variable. The code can give you an example.

#include

using namespace std;

int main()

{

int x = 10;

// ref is a reference to x.

int& ref = x;

// Value of x is now changed to 20

ref = 20;

cout « “x = " « x « endl ;

// Value of x is now changed to 30

x = 30;

cout « “ref = " « ref « endl ;

return 0;

}

• It resolves the scope of various global variables.
• It associates the function with the class when it is defined outside the class.

The code of the scope resolution operator are as follows.

#include

using namespace std;

int my_var = 0;

int main(void) {

int my_var = 0;

::my_var = 1; // set global my_var to 1

my_var = 2; // set local my_var to 2

cout « ::my_var « “, " « my_var;

return 0;

}