DUMB DEV Community: Mattia Bonicelli

Virtual functions in C++

Mattia Bonicelli — Mon, 16 Aug 2021 15:00:54 +0000

A virtual function in C++ is a function declared in a base class that allows overriding by its derived classes.

The main benefit of using virtual functions is the ability to achieve runtime polymorphism.

Without declaring a virtual function, if we were to try and override a regular function

class Animal {
public:
    void describe_self() const {
        std::cout << "I'm an animal" << std::endl;
    }
};

class Dog : public Animal {
public:
    void describe_self() const {
        std::cout << "I'm a dog" << std::endl;
    }
};

class Cat : public Animal {
public:
    void describe_self() const {
        std::cout << "I'm a cat" << std::endl;
    }
};

and then we were to assign an object of class Dog to an Animal's pointer

int main()
{
    Animal* doug = new Dog();
    doug->describe_self();
}

since the C++ compiler can only determine the type of the pointer at compile time it will bind the Animal pointer's describe_self function call to the method inside our base Animal class.

As such the following will print to console.

I'm an animal

This is because memory addresses of the Animal pointer and the Dog object are only resolved at runtime. This behaviour is known as early binding.

To prevent this from happening, and instead execute the most derived version of the called class, we can use a virtual function by adding the keyword virtual inside our base class method.

class Animal {
public:
    virtual void describe_self() const {
        std::cout << "I'm an animal" << std::endl;
    }
};

This will correctly print

I'm a dog

It is also a good idea to add the C++11 keyword override in the derived classes methods for clarity and to prevent typos.

class Dog : public Animal {
public:
    void describe_self() const override {
        std::cout << "I'm a dog" << std::endl;
    }
};

class Cat : public Animal {
public:
    void describe_self() const override {
        std::cout << "I'm a cat" << std::endl;
    }
};

Runtime polymorphism can be used for example in scenarios where you would want all of your objects from derived classes to execute the same method.

int main()
{
    Animal* doug = new Dog();
    Animal* kat = new Cat();

    Animal* pets[2] = { doug, kat };

    for (int i = 0; i < 2; i++) {
        pets[i]->describe_self();
    }
}

This will print

I'm a dog
I'm a cat

Here we create an array of Animal pointers mapped to different Animal derived classes' objects, and we call their own describe_self method in a succint and scalable way.

There are also pure virtual functions that declare a placeholder method.

class PureVirtual {
public:
    virtual void function() const = 0;
};

This abstract class forces any derived class to implement its own version of that function.

When a virtual function is declared and an object is instantiated from a class implementing it, the compiler will add a virtual pointer to the class object's data members and map it to a virtual table.

This virtual table is usually added at the class level, and it is an array containing pointers mapped to each virtual function.

To determine which function to call the runtime will follow these virtual pointers to the virtual table and finally to the function meant to be invoked.

In the above code our Dog and Cat class will each have a virtual table each containing an entry pointing to the describe_self method and our doug and kat objects will have a virtual pointer mapped to respectively our Dog and Cat's virtual tables.

Due to these extra steps virtual functions come at an extra cost, both in size and in speed.

The virtual tables in the classes, and the virtual pointers in the objects will take up extra memory, and for each function call at runtime we will have to follow the virtual pointers to the virtual table before reaching the correct address.

In short, virtual functions are a way to keep the code base more readable and more compact, but they incur a small cost that may be a factor when run on low-power embedded chips that can't sacrifice CPU cycles or other similar scenarios.

Build a nodeJS server without using express.

Mattia Bonicelli — Sun, 09 May 2021 20:30:18 +0000

Ever wondered how to build a server without using express?

Well, look no further...

Introduction

While a very convenient framework express is not necessary to get up and running with a server built on nodeJS.

Looking at how express operates you'll realize that under the hood it utilizes the http module, and as such you can think of express as a wrapper for http.

With this in mind we shall attempt to spin up a server using the http module alone.

Getting started

The amount of code we need to write to achieve this is minimal.

const http = require('http');

const requestListener = function (req, res) {
  res.writeHead(200);
  res.end("I'm a server");
}

const server = http.createServer(requestListener);
server.listen(8080);

Yep, that's all you need.

Assuming you name this file server.js all you need to do is run node server.js and go to http://localhost:8080/ and you will be greeted by this.

You may notice that the code to achieve this looks eerily similar to how you would do it with express...that's no coincidence.

This really reinforces the concept that Express really is just a functional layer built on top of the http module.

Dissecting the code

Let's take a closer look at what we've written.

const http = require('http');

First we require, the http module so that we may use it, this should be already provided with most nodeJS installations so you should need to worry about installing it yourself.

const requestListener = function (req, res) {
      ⋮
}

We then make a function called requestListener and expect it to take two arguments, a req (short for request) object and a res (short for response) object.

In this simple scenario we don't do anything with the request object.

  res.writeHead(200);

In the response object that we send back we have a header containing the http status code 200, which marks a successful request.

  res.end('Hello, World!');

When we end the request we also send back a text body containing our message.

const server = http.createServer(requestListener);

After this we create a server that calls requestListener when a request is received.

server.listen(8080);

And finally we tell our server to listen to port 8080 of our localhost for requests.

Summary

At the end of the day if you are just trying to build something simple, using express is not a necessity and you can achieve the same basic functionality by utilizing the http module.

If however you're building an API server or an app that has a database and some complexity to it, you'd likely benefit from the abstractions and quality of life improvements that express brings to the table.