You might be wondering – what is a class and why do we need them? In this article I'll go over some basics to help you understand how classes work in C++.

How Classes Work in C++

C++ has various built in types (like bool, int, floats, and so on). Each of these types has various features (for example, the size of their memory occupancy). Operators have different meanings for each different type.

For example: The '+' operator adds ints, floats, and doubles:

int x = 5;
int y = 6;

int z= x+y;//z==11

However if we use the '+' operator with strings, it concatenates those strings.

string s1 = "abhilekh";
string s2 = "gautam";

string s3=s1+s2;//s3 will be abhilekhgautam

Here, x, y, and z represent an integer, while s1, s2, and s3 represent strings. So x, y, and z are objects of type int. Meanwhile s1, s2, and s3 are objects of type string.

Note: don't confuse this with the word 'Object'. An object is anything that occupies memory.

But what if we want to have a type that represents objects in our daily life? How could you represent a house, a car, books, animals, and so on? This is why we need Classes.

A class is a user defined type. This means that you can define your own types. You can make your own types like ints, floats, and chars. You can define operators for your types and set various properties for your own types.

Classes are really a powerful feature. Let's see how they work:

class Book{
string author_name,title;
int no_of_pages,edition_no;
//...
};

Here we have created a class named Book. The keyword class is enough for us to understand that.

A book must have an author, a title, and pages – these are the members of our class. Here, book represents an entity which has those features.

But creating our own type won't be useful until we have an object of that type. So how do we do that?

int x;//x is an object of type x.

Book y;//y is an object of type Book

The only difference here is that x is an object of a built-in type (that is, int) and y is an object of the type Book (Book is a user-defined type, defined by you).

So now let's discuss the basics of defining a class, how to create objects of that class, and ways we can use those objects.

What Are Member Functions in C++?

Functions declared in a class are member functions. They can only be invoked by the object of the class in which the function is defined.

Let's now update our Book class a little bit:

class Book{
//..
public:
void update_edition(int edition);
//..
};

Thats it – update_edition is a member function of our class book. We can define our function in two ways: inside the class, and outside the class.

Let's see how each of them works:

/*Inside class declaration*/
class Book{
//..
public:
void update_edition(int edition){
//Define your function 
edition_no = edition;
}
};

/* Outside Class declaration*/
void Book::update_edition(int edition){
//Define your function here
//..
}

So what about calling the function?

Book y;//y is an object of type Book

y.update_edition(5);

Remember that only the objects of type Book can invoke the function. A call from objects of any other type will result in a syntactical error.

A (non-static) member function always knows the object for which it was invoked and can refer to it like this:

void Book::update_edition(int edition){
this->edition_no = edition;
}

Types of Member Functions in C++

There are a number of types of member functions in C++. Let's look at each one in more detail here.

Constant Member Functions

class Book{
//..
public:
//..
int display_edition() const{
return edition_no;
}
//..
};

The const keyword indicates that this function does not change the state of the function.

Changing the state of the function from constant member function will result in an error.

int Book::book_edition() const{
edition_no = edition_no + 1;//error:cannot change value in constant function
}

Static Member Functions

If you have a member function that needs access to the members of the class but does not need to be invoked by each and every object of that class, you should declare it as static.

Such functions will be part of the class but will not be part of the object.

class Book{
//..
public:
static void my_static_func();
};

A static member can be referred to without using an object.

void Book::my_static_func(){
//define here.
}

The static keyword should not be repeated in the function declaration. Static member functions do not have access to the this pointer.

Friend Functions

Friend functions are not within the scope of a class and don't have any access to this.

class Book{
//..
public:
//..
void check();
void display();
//..
};

class E_book{
//..
public:
//..
friend void Book::check();
};

Here, the member function check of class Book is a friend of class E_book.

If we want all the member functions of a class to be the friend of another class, we can use the following syntax:

class E_book{
//...
public:
//..
friend class Book;
};

Now all the functions of class Book are now friends to class E-book.

Access Specifiers

If you have a background in C, you might remember creating your own type using the struct keyword.

struct Book{
char author_name[20];
char title[20];
int no_of_page,edition_no;
};

Book b1;//b1 is an object of type Book

Structure is a user defined type. In fact, structure is a type of class that has all its members public by default. Confused?

Do you remember the public: label we used in one of our previous code snippets above? That is what we call an access specifier.

So what's the difference between private and public access specifiers?

Members after a private label are said to be private members. This means that they can only accessed by the member function of that class. If no label is provided, it is private by default.

On the other hand, members after public label are accessible everywhere.

These specifiers are used for the purpose of data hiding, data abstraction, and data encapsulation.

Constructors

A constructor is a member function which is used to initialize an object. A constructor is run whenever an object of that class type is created.

The name of the constructor function is the same as the name of the class and it does not have any return type, either.

class Book{
//..
public:
//Constructor

Book(){  //no return type and name same as the class name

//define constructor here

}
};

There can be multiple constructor of a class because there can be multiple functions with the same name reffered as function overloading.

Destructors

The destructor releases the memory occupied by the object. It simply destroys the object. The ~ (tilde) symbol denotes a destructor.

class Book{
//..
public:
//constructor
//..
//destructor
~Book(){
//destroy object here
}
};

That's it!

By using these various class concepts in c++, you can easily create new types (your own types) which you can conveniently use as built in types.

You can read my other articles here.

For example, say you have a class Vehicle which defines the basic functionality (methods) and components (object variables) that vehicles have in common.

You cannot create an object of Vehicle because a vehicle is itself an abstract, general concept. Vehicles have wheels and motors, but the number of wheels and the size of motors can differ greatly.

You can, however, extend the functionality of the vehicle class to create a Car or a Motorcycle:

abstract class Vehicle
{
  //variable that is used to declare the no. of wheels in a vehicle
  private int wheels;

  //Variable to define the type of motor used
  private Motor motor;

  //an abstract method that only declares, but does not define the start 
  //functionality because each vehicle uses a different starting mechanism
  abstract void start();
}

public class Car extends Vehicle
{
  ...
}

public class Motorcycle extends Vehicle
{
  ...
}

Remember, you cannot instantiate a Vehicle anywhere in your program – instead, you can use the Car and Motorcycle classes you declared earlier and create instances of those:

Vehicle newVehicle = new Vehicle();    // Invalid
Vehicle car = new Car();  // valid
Vehicle mBike = new Motorcycle();  // valid

Car carObj = new Car();  // valid
Motorcycle mBikeObj = new Motorcycle();  // valid

More information:

• Learn Functional Programming in Java - Full Course
• Getters and Setters in Java Explained
• Inheritance in Java Explained

Class Components

Class components are JavaScript ES2015 classes that extend a base class from React called Component.

class App extends Component {
    render () {
        return (
            <Text>Hello World!</Text>
        )
    }
}

This gives the class App access to the React lifecycle methods like render as well as state/props functionality from the parent.

Functional Components

Functional components are simpler. They don’t manage their own state or have access to the lifecycle methods provided by React Native. They are literally plain old JavaScript functions, and are sometimes called stateless components.

const PageOne = () => {
    return (
        <h1>Page One</h1>
    );
}

Summary

Class components are used as container components to handle state management and wrap child components.

Functional components generally are just used for display purposes - these components call functions from parent components to handle user interactions or state updates.

More info about component state

Component State

In Class components, there is a way to store and manage state built in to React Native.

class App extends Component {
  constructor () {
    super();
    this.state = {
      counter: 0
    };
  }
  incrementCount () {
    this.setState({
      counter: this.state.counter + 1
    });
  }
  decrementCount () {
    this.setState({
      counter: this.state.counter - 1
    });
  }
  render () {
    return (
      <View>
        <Text>Count: {this.state.counter}</Text>
        <Button onPress={this.decrementCount.bind(this)}>-</Button>
        <Button onPress={this.incrementCount.bind(this)}>+</Button>
      </View>
    );
  }
}

State is similar to props, but it is private and fully controlled by the component. Here, the constructor() method is calling the parent class’ constructor with super(); - Component is the parent class of App because we are using the extends keyword. The constructor() method also initializes the component’s state object:

this.state = {
  counter: 0
};

The state can be displayed within the component:

{this.state.counter}

Or updated by calling:

this.setState({});

Note: Aside from its initial creation in your component’s constructor() method, you should never directly modify the component’s state with this.state =. You must use this.setState as can be seen in the incrementCount and decrementCount functions above.

The count is incremented and decremented by calling the functions passed to the onPress handlers just like they would be if you called a click handler from JavaScript on the web.

ASIDE: In the first example, <Button> is a custom component; it’s a combination of <TouchableOpacity> and <Text> from the React Native API:

const Button = ({ onPress, children, buttonProps, textProps }) => {
  const { buttonStyle, textStyle } = styles;
  return (
    <TouchableOpacity onPress={onPress} style={[buttonStyle, buttonProps]}>
      <Text style={[textStyle, textProps]}>
        {children}
      </Text>
    </TouchableOpacity>
  );
};

More info on React Native:

• React Native Guide

In object-oriented computer languages such as Python, classes are basically a template to create your own objects. Objects are an encapsulation of variables and functions into a single entity. Objects get their variables and functions from classes.

Say what?

Here are some examples that will help you understand — read on. There is also an interactive code shell, simply press the “Run” button at the top of the specific window.

The simplest way to describe classes and how to use them is this:

Imagine you have great powers. You create a species (“class”).

Then you create attributes for that species (“properties”) — height, weight, limbs, color, powers, and so on.

Then you create an instance of that species — Fido the dog, Drogon from Game of Thrones, and so on. Then you work with these instances:

• In a game, for instance, they would engage in action, interact, using their attributes.
• In a banking app, they would be the different transactions.
• In a vehicle buy/sell/trade/lease app, the vehicle class could then spawn sub-classes such as cars. Each would have attributes such as mileage, options, features, color, and trim.

You can already see why this is useful. You are creating, re-using, adapting, and enhancing items in a very efficient, logical, and useful way.

By now, you have probably realized that this is a way to classify and group, one that that is similar to how humans learn:

• Animals are living things that are not human or trees, in a basic sense
• then you move on to different types of animals — dogs, cats are probably the first animals most of us learnt about
• then you move to different attributes of animals — shapes, sizes, sounds, appendages and so on.

For instance, when you were a child, your first understanding of a dog was probably something with four legs that barked. Then you learnt to distinguish that some were real dogs, others were toys. That this “dog” concept contained many types.

Creating and using classes is basically:

• building a template to put “things” in — a classification
• which can then be operated on. For example, pulling up all the people with dogs that you could request to link to a blog on pets, or all bank clients who might be good prospects for a new credit card.

The main point here is classes are objects that can produce instances of those templates, on which operations and methods can be applied. It is an excellent way to conceptualize, organize, and build a hierarchy for any organization or process.

As our world gets more complex, this is a way to mimic that complexity from a hierarchical perspective. It also builds a deeper understanding of the processes and interactions for business, technical, and social settings from a virtual information technology point.

An example might be a video game you create. Each character could be a “class”, with its own attributes, that interacts with instances of other classes. King George of the “King” class might interact with Court Jester Funnyman of the “Clown” class, and so on. A King might have a royal “servant” class, and a “servant” class would always have a “King” class, for example.

This is what we will do:

• create a class and use it
• create a module and move the class creation and initiation to the module
• call the module in a new program to use the class

The code is available in GitHub here.

#TSB - Create Class in Python - rocket positions (x,y) and graph

#some items and comments bolded to call attention to processimport matplotlib.pyplot as plt

class Rocket():  def __init__(self, x=0, y=0):    #each rocket has (x,y) position; user or calling function has choice    #of passing in x and y values, or by default they are set at 0    self.x = x    self.y = y      def move_up(self):    self.y += 1      def move_down(self):    self.y -= 1      def move_right(self):    self.x += 1      def move_left(self):    self.x -= 1

#Make a series of rockets - x,y positions, I am calling it rocketrockets=[]rockets.append(Rocket())rockets.append(Rocket(0,2))rockets.append(Rocket(1,4))rockets.append(Rocket(2,6))rockets.append(Rocket(3,7))rockets.append(Rocket(5,9))rockets.append(Rocket(8, 15))  #Show on a graph where each rocket is

for index, rocket in enumerate(rockets):  #original position of rockets  print("Rocket %d is at (%d, %d)." % (index, rocket.x, rocket.y))  plt.plot(rocket.x, rocket.y, 'ro', linewidth=2, linestyle='dashed', markersize=12)  #move the 'rocket' one up  rocket.move_up()  print("New Rocket position %d is at (%d, %d)." % (index, rocket.x, rocket.y))  #plot the new position  plt.plot(rocket.x, rocket.y, 'bo', linewidth=2, linestyle='dashed', markersize=12)  #move the rocket left, then plot the new position  rocket.move_left()  plt.plot(rocket.x, rocket.y, 'yo', linewidth=2, linestyle='dashed', markersize=12)

#show graph legend to match colors with positionplt.gca().legend(('original position','^ - Moved up', '< - Moved left'))plt.show()#plt.legend(loc='upper left')

Output from code above, using Python class

Now let us create a module and move some of the code above to the module. Any time we need to create this simple set of x,y coordinates in any program, we can use the module to do so.

What is a module and why do we need it?

A module is a file containing Python definitions and statements. Module is Python code that can be called from other programs for commonly used tasks, without having to type them in each and every program that uses them.

For example, when you call “matplotlib.plot”, you are calling a package module. If you didn’t have this module you would have to define the plot functionality in every program that used a plot graph.

From the Python documentation:

If you quit from the Python interpreter and enter it again, the definitions you have made (functions and variables) are lost. Therefore, if you want to write a somewhat longer program, you are better off using a text editor to prepare the input for the interpreter and running it with that file as input instead.This is known as creating a script. As your program gets longer, you may want to split it into several files for easier maintenance. You may also want to use a handy function that you’ve written in several programs without copying its definition into each program.

To support this, Python has a way to put definitions in a file and use them in a script or in an interactive instance of the interpreter. Such a file is called a module; definitions from a module can be imported into other modules or into the main module (the collection of variables that you have access to in a script executed at the top level and in calculator mode).

Here’s our simple module. It takes the class creation and the functions to move an instance of that class from the program above and into its own class. We will then use this in a new program simply by calling and referencing this module:

Notice what we did above:

• created and initialized the class
• created a function to move an instance of the class in the four major directions (up, down, right, left) and the increments — as parameters, or arguments to the function
• created another function to calculate the distance between two instances of the class, using the graph distance formula

Here’s how we will use the new module to re-write the same program from the first part. Notice in the import section at the beginning, we now import the simple_module1 module that we just created:

Here’s the output from the code using our module. Note that they are the same, except for the chart title and the shape of the position markers, which I changed for comparative purposes.

Output from code from creating and calling our own module!

Comparison of the original file-left(create class, use it) and same functionality using a module, right

Comparison of the output. On the right side, I change the marker shape for distinction, but the positions are unchanged.

That’s great, you may say — what are some other uses for this? One classic example is a bank account. A customer class might contain the name and contact details and — more importantly — the account class would have deposit and withdrawal elements.

This is grossly oversimplified but, for illustrative purposes, it is useful. That’s it — create a template, then define instances of that template with details (properties), and add value by adding, subtracting, modifying, moving, and using these instances for your program objectives.

Still wondering about classes? Ok, let’s get “classy” — here’s another simple illustration. We will call this class “Person”. It has only two properties — name and age. We will then add an instance of this with a person’s name and age, and print it. Depending on what your objective is, you can imagine all the other details you might add — for example, marital status and location preferences for a social networking app, job experience in years and industry specialization for a career related app. Press the little triangle below to see it work.

So there you have it. You can create many different classes, with parent classes, sub-classes and so on. Thanks for reading — please clap if you liked it. Here are some other references if you would like to learn more:

• Python documentation — Classes
• Python Object Oriented — Tutorials Point
• Classes and Objects — learnpython.org