C++ Basics #4: Namespaces, Structs, Classes

Namespaces

When a program grows big, there are so many functions and variables that it's almost certain some of them will end up having the same name. In order to avoid name collisions, C++ introduces namespaces. A namespace is a region of code that allows you to declare names without them colliding with identical names in other namespaces. To access something inside a namespace, you have to prefix it with namespace_name::. For example:

namespace A
{
    int myvar;
}

int myvar;

Here there are no name collisions, because one is myvar, whereas the one inside the namespace is A::myvar. You can also nest namespaces inside other namespaces:

namespace A
{
    namespace B
    {
        // This is A::B::myvar
        int myvar;
    }
}

For example, everything that belongs to the C++ Standard Library is inside the std namespace, so you access it like std::vector, std::cin,...

To avoid writing :: all the time, there's an instruction that "removes" the namespace scope. using namespace A;, where A is the namespace name, means you won't have to write A:: all the time, C++ will assume it. However, this must be used carefully: think that it's defeating the reason namespaces were added in the first place. If this instruction is put inside a function, it will only affect inside that function.

Structs

Quite often a single variable is not enough to represent an object. Imagine you want to represent an employee: you might need to save its ID, its wage, its age,...

int joeAge;
int joeID;
float joeWage;

// What if we need another employee?
int kateAge;
int kateID;
float kateWage;

For situations like this, C++ introduces structs (short for structures). Structs let us create a new type with variables inside:

struct Employee
{
    int age;
    int id;
    float wage;
};

With that code we have created a new type, Employee, with those three variables; variables inside a structure are usually called members or fields. Note that Employee is a type, like int or string, but it's not an object yet. We can create employee objects just like we would with any other type:

Employee joe;
Employee kate;

When we create a variable of an struct we call that an instance of the struct. We can access the members of a struct by using . and the member name:

Employee joe;
joe.age = 27;
joe.id = 183902;
joe.wage = 1250.8;

Having to initialize each value line per line can be too long. We can use uniform initialization, which allows us to assign all the values in order:

Employee joe = { 27, 183902, 1250.8 };

Classes

More advanced C++, such as in the ModAPI SDK, uses a coding technique known as object-oriented programming. It basically consists in representing everything as objects, with an object being a collection of attributes (for object Person, age, height, gender,...) and behaviours it can exhibit (walk, dance, talk,...).

In C++, we can represent those objects as a class:

class Date
{
public:
    int day;
    int month;
    int year;
};

Notice that the difference with structs is only in the public: line; if you want to know more about what it means, check this learncpp.com tutorial. Generally you will use classes, and structs only for very simple structures.

Classes can also have functions. A member function (a function inside of a class), sometimes also called method, has access to the variables of the class.

class Date
{
public:
    int day;
    int month;
    int year;
    
    void print() {
        printf("%d/%d/%d", day, month, year);
    }
};

Just as you can access member by using .member_name, you can call methods by using .method_name(parameters):

Date date = { 02, 02, 2020 };
Date date2 = { 25, 11, 1975 };

// This prints "2/2/2020"
date.print();

// This prints "25/11/1975"
date2.print();

class Color
{
public:
    int red;
    int green;
    int blue;
    
    // constructor
    Color() {
        red = 255;
        green = 255;
        blue = 255;
    }
};

class Color
{
public:
    int red;
    int green;
    int blue;
    
    // constructor
    Color()
        : red(255)
        , green(255)
        , blue(255)
    {
    }
};

class Color
{
public:
    int red;
    int green;
    int blue;
    
    // constructor
    Color()
        : red(255)
        , green(255)
        , blue(255)
    {
    }
    
    Color(int value)
        : red(value)
        , green(value)
        , blue(value)
    {
    }
};

Color color();
Color color = Color();

Color color(128);
Color color = Color(128);

class Date
{
public:
    static string CLASS_NAME = "Date";

    int day;
    int month;
    int year;
    
    void print() {
        printf("%d/%d/%d", day, month, year);
    }
};

#pragma once

class Date
{
public:
    int day;
    int month;
    int year;
    
    Date();
    Date(int d, int m, int y);
    
    void print();
    
    static string CLASS_NAME;
};

#include "Date.h"

string Date::CLASS_NAME = "Date";

Date::Date()
    : day(0)
    , month(0)
    , year(0)
{
}

Date::Date(int d, int m, int y)
    : day(d)
    , month(m)
    , year(y)
{
}

void Date::print() {
    printf("%d/%d/%d", day, month, year);
}

Polymorphism

Imagine you create a class for Employer, and another for Employee. They have different attributes and behaviours, yes, but they also have some of them in common: they both have an age, a name, etc as they both are a person. Polymorphism allows us to define a hierarchy between classes that helps us deal with this kind of situations.

Polymorphism consists in class inheritance: classes can inherit (aka implement or extend) from other classes, automatically gaining all itrs attributes and behaviours. Following the previous example, we would create a Person class, and then the Employer and Employee classes would inherit from Person:

class Person {
public:
    string name;
    int age;
};

class Employee
    : public Person  // this means inherit from Person
{
public:
    float wage;
}

If we declare an instance of employee, we will also be able to access the person fields; but if we declare a person, we won't be able to access the wage, as that is a field for only certain types of person.

Employee emp;
emp.name = "Mike";
emp.wage = 1576.0;

Person person;
person.wage = 10;  // ERROR!

It's possible to extend more than one class. The extended classes are called base classes.

class A {
public:
    virtual void print() {
        printf("This is class A");
    }
};

class B : public A {
public:
    virtual void print() override {
        printf("This is class B");
    }
};

A a;
// prints "This is class A"
a.print();

B b;
// prints "This is class B"
b.print();

class A {
public:
    virtual void print() = 0;  // pure virtual
};

class B : public A {

}

B b;  // ERROR! you haven't implemented print()