C++ Classes and Objects
The main purpose of C++ programming is to add object orientation to the C programming language and classes are the central feature of C++ that supports object-oriented programming and are often called user-defined types.
A class is used to specify the form of an object and it combines data representation and methods for manipulating that data into one neat package. The data and functions within a class are called members of the class.
C++ Class Definitions
When you define a class, you define a blueprint for a data type. This doesn’t actually define any data, but it does define what the class name means, that is, what an object of the class will consist of and what operations can be performed on such an object.
A class definition starts with the keyword class followed by the class name; and the class body, enclosed by a pair of curly braces. A class definition must be followed either by a semicolon or a list of declarations. For example, we defined the Box data type using the keyword class as follows −
The keyword public determines the access attributes of the members of the class that follows it. A public member can be accessed from outside the class anywhere within the scope of the class object. You can also specify the members of a class as private or protected which we will discuss in a sub-section.
Define C++ Objects
A class provides the blueprints for objects, so basically an object is created from a class. We declare objects of a class with exactly the same sort of declaration that we declare variables of basic types. Following statements declare two objects of class Box −
Box Box1; // Declare Box1 of type Box Box Box2; // Declare Box2 of type Box
Both of the objects Box1 and Box2 will have their own copy of data members.
Accessing the Data Members
The public data members of objects of a class can be accessed using the direct member access operator (.). Let us try the following example to make the things clear −
#include using namespace std; class Box < public: double length; // Length of a box double breadth; // Breadth of a box double height; // Height of a box >; int main() < Box Box1; // Declare Box1 of type Box Box Box2; // Declare Box2 of type Box double volume = 0.0; // Store the volume of a box here // box 1 specification Box1.height = 5.0; Box1.length = 6.0; Box1.breadth = 7.0; // box 2 specification Box2.height = 10.0; Box2.length = 12.0; Box2.breadth = 13.0; // volume of box 1 volume = Box1.height * Box1.length * Box1.breadth; cout << "Volume of Box1 : " << volume <
Volume of Box1 : 210 Volume of Box2 : 1560
It is important to note that private and protected members can not be accessed directly using direct member access operator (.). We will learn how private and protected members can be accessed.
Classes and Objects in Detail
So far, you have got very basic idea about C++ Classes and Objects. There are further interesting concepts related to C++ Classes and Objects which we will discuss in various sub-sections listed below −
A member function of a class is a function that has its definition or its prototype within the class definition like any other variable.
A class member can be defined as public, private or protected. By default members would be assumed as private.
A class constructor is a special function in a class that is called when a new object of the class is created. A destructor is also a special function which is called when created object is deleted.
The copy constructor is a constructor which creates an object by initializing it with an object of the same class, which has been created previously.
A friend function is permitted full access to private and protected members of a class.
With an inline function, the compiler tries to expand the code in the body of the function in place of a call to the function.
Every object has a special pointer this which points to the object itself.
A pointer to a class is done exactly the same way a pointer to a structure is. In fact a class is really just a structure with functions in it.
Both data members and function members of a class can be declared as static.
C++ Classes and Objects
Everything in C++ is associated with classes and objects, along with its attributes and methods. For example: in real life, a car is an object. The car has attributes, such as weight and color, and methods, such as drive and brake.
Attributes and methods are basically variables and functions that belongs to the class. These are often referred to as «class members».
A class is a user-defined data type that we can use in our program, and it works as an object constructor, or a «blueprint» for creating objects.
Create a Class
To create a class, use the class keyword:
Example
Create a class called » MyClass «:
class MyClass < // The class
public: // Access specifier
int myNum; // Attribute (int variable)
string myString; // Attribute (string variable)
>;
Example explained
- The class keyword is used to create a class called MyClass .
- The public keyword is an access specifier, which specifies that members (attributes and methods) of the class are accessible from outside the class. You will learn more about access specifiers later.
- Inside the class, there is an integer variable myNum and a string variable myString . When variables are declared within a class, they are called attributes.
- At last, end the class definition with a semicolon ; .
- Structures are much simpler than objects. Unlike objects, structures cannot do encapsulation, inheritance or polymorphism, which you will learn more about in the next chapters. If all you need is a collection of variables, a structure is easier to use than an object.
Create an Object
In C++, an object is created from a class. We have already created the class named MyClass , so now we can use this to create objects.
To create an object of MyClass , specify the class name, followed by the object name.
To access the class attributes ( myNum and myString ), use the dot syntax ( . ) on the object:
Example
Create an object called » myObj » and access the attributes:
class MyClass < // The class
public: // Access specifier
int myNum; // Attribute (int variable)
string myString; // Attribute (string variable)
>;
int main() MyClass myObj; // Create an object of MyClass
// Access attributes and set values
myObj.myNum = 15;
myObj.myString = «Some text»;
Multiple Objects
You can create multiple objects of one class:
Example
// Create a Car class with some attributes
class Car public:
string brand;
string model;
int year;
>;
int main() // Create an object of Car
Car carObj1;
carObj1.brand = «BMW»;
carObj1.model = «X5»;
carObj1.year = 1999;
// Create another object of Car
Car carObj2;
carObj2.brand = «Ford»;
carObj2.model = «Mustang»;
carObj2.year = 1969;