class abc
{
   public:
      double length;   // Length of a box
      double breadth;  // Breadth of a box
      double height;   // Height of a box
};

A class can be used with 3 keywords:

1) public-This means the attributed included in that class can be used even outside that class

2) private-This means attributes of a class are used within that class only 

3) protected-used basically in inheritance

OBJECTS:

Objects are the physical representation of classes. Classes cant be implemented without the help of the 

objects.Classes are the blueprints for objects.

Syntax for creating object:

classname objectname;

for example:

box box1;

here box is a classname whereas box1 is an objectname.

PRINCIPLES OF OOPS:

1)Encapsulation

Encapsulation is the process of hiding of data implementation by restricting access to accessors and 

mutators. Mutators are open ways that are used to update the state of an object, whereas concealing 

the implementation of exactly how the data gets revised. 

An accessor is a technique which is used to request an object about itself. In
OOP, they are generally in the form of properties, that have, under standard conditions, a get method, 

that is an accessor method.However, accessor methods are not confined to properties and can be any

kind of public method that offers information about the state of the object. 

2)Abstraction

Data abstraction is the easiest of principles to figure out. Data
abstraction and encapsulation are directly tied together, because a
plain definition of data abstraction is the growth and development of classes,
objects, types in terms of their interfaces and functionality, instead
of their implementation details. Abstraction denotes a model, a view,
or various other focused representation for an actual item. Its the
development of a software object to symbolize an object we can find in
the real world. Encapsulation hides the details of that implementation.

Abstraction is employed to manage complexity. Software developers use abstraction to
decompose complex models into smaller elements. As development
progress, software engineers know the overall performance they can expect from as
yet undeveloped subsystems. Thus, programmers are not burdened by
thinking about the ways in which the execution of later on subsystem
will influence the model of previous development.

3)Inheritance

Inheritance as the name suggests implies inheriting properties from one class to another.Let us take an

example,In a family child inherits properties/genes of his parents,his/her parents inherits properties/genes 

of their parents and so on.The same happens in the case of classes.A class can inherit certain properties 

from some other class.The class which inherits the properties  from some other class is referred to as 

child and the class from which the properties are inherited is referred to as base class or super-class.

4)Polymorphism

Polymorphism means a single name, numerous types. Polymorphism
manifests itself by having multiple ways all with similar name, but
slightly dissimilar functionality.

There are actually two basic types of polymorphism. Overriding, additionally
known as run-time polymorphism, and overloading, that is referred to as
compile-time polymorphism. This dissimilarity is, for method
overloading, the compiler decides which method will be
executed, and this choice is done when the code gets compiled.
Which method is going to be used for method overriding is determined at
run-time depending on the dynamic nature of an object.