In this tutorial, we will explore advanced object-oriented programming in C++.

Prerequisites

• You have completed this tutorial: How to Generate Doxygen Comments for C++ Code.

Using Getters and Setters

Let’s explore the use of getter and setter functions in C++ and how they can be applied to robotics projects.

Getter and setter functions, also known as accessor and mutator functions, are used to control access to the private data members of a class. 

Setter functions allow you to modify the values of private data members, while getter functions allow you to retrieve their values.

Let’s create an example to demonstrate the use of setter and getter functions in a robotics context.

Open a terminal window, and type this:

cd ~/Documents/cpp_tutorial

code .

Create a new C++ file and name it setter_getter_example.cpp.

Type the following code into the editor:

#include <iostream>

class RobotArm {
public:
    void set_position(int x, int y, int z) {
        x_ = x;
        y_ = y;
        z_ = z;
    }

    int get_x() const {
        return x_;
    }

    int get_y() const {
        return y_;
    }

    int get_z() const {
        return z_;
    }

private:
    int x_, y_, z_;
};

int main() {
    RobotArm arm;
    arm.set_position(10, 20, 30);
    std::cout << "Robot arm position: ("
              << arm.get_x() << ", "
              << arm.get_y() << ", "
              << arm.get_z() << ")" << std::endl;
    return 0;
}

In this code, we define a RobotArm class with private data members x_, y_, and z_ representing the position of the robot arm in 3D space.

We provide a setter function set_position() that allows us to set the values of x_, y_, and z_ simultaneously.

We also provide getter functions get_x(), get_y(), and get_z() that allow us to retrieve the individual values of x_, y_, and z_, respectively. These getter functions are marked as const to indicate that they do not modify the object’s state.

In the main() function, we create a RobotArm object named arm, set its position using the set_position() function, and then retrieve and print the position using the getter functions.

Run the code.

You should see the robot arm’s position printed in the terminal, demonstrating the use of setter and getter functions.

This example illustrates how setter and getter functions can be used in robotics projects to control access to the private data members of a class. By providing setter and getter functions, you can ensure that the object’s state is modified and accessed in a controlled manner, maintaining the integrity of your robotics system.

Employing Static Methods

Let’s learn about static methods in C++ and how they can be employed in robotics projects.

Static methods, also known as class methods, are functions that belong to the class itself rather than any specific instance of the class. They can be called directly on the class without the need to create an object of the class.

Static methods are “static” because they are initialized and loaded into memory when the class itself is loaded, remaining fixed at the class level rather than being created with each object instance. 

Unlike instance methods which are initialized separately for each object instance, static methods stay in one fixed memory location that’s shared across all instances of the class.

Create a new C++ file and name it static_method_example.cpp.

Type the following code into the editor:

#include <iostream>
#include <cmath>

class RobotUtils {
public:
    static double calculate_distance(double x1, double y1, double x2, double y2) {
        double dx = x2 - x1;
        double dy = y2 - y1;
        return std::sqrt(dx * dx + dy * dy);
    }
};

int main() {
    double robot1_x = 0.0, robot1_y = 0.0;
    double robot2_x = 3.0, robot2_y = 4.0;

    double distance = RobotUtils::calculate_distance(robot1_x, robot1_y, robot2_x, robot2_y);
    std::cout << "Distance between robots: " << distance << std::endl;

    return 0;
}

In this code, we define a RobotUtils class with a static method calculate_distance(). This method takes four parameters representing the x and y coordinates of two points and calculates the Euclidean distance between them.

The calculate_distance() method is marked as static, which means it can be called directly on the RobotUtils class without the need to create an instance of the class.

In the main() function, we define the coordinates of two robots, robot1 and robot2. We then call the calculate_distance() method directly on the RobotUtils class, passing the coordinates of the two robots as arguments. 

Finally, we print the calculated distance.

Run the code.

You should see the distance between the two robots printed in the terminal.

By using static methods, you can organize your code more effectively and make certain functions accessible without the need to create objects, leading to cleaner and more maintainable code in your robotics projects.

Implementing Virtual Functions

Let’s explore virtual functions in C++ and how they can be implemented in robotics projects.

Virtual functions are a key concept in object-oriented programming that enables polymorphism. They allow derived classes to provide their own implementation of a function that is already defined in the base class.

Create a new C++ file and name it virtual_function_example.cpp.

Type the following code into the editor:

#include <iostream>

class Robot {
public:
    virtual void move() {
        std::cout << "Robot is moving" << std::endl;
    }
};

class WheeledRobot : public Robot {
public:
    void move() override {
        std::cout << "Wheeled robot is rolling" << std::endl;
    }
};

class LeggedRobot : public Robot {
public:
    void move() override {
        std::cout << "Legged robot is walking" << std::endl;
    }
};

int main() {
    Robot* robot1 = new WheeledRobot();
    Robot* robot2 = new LeggedRobot();

    robot1->move();
    robot2->move();

    delete robot1;
    delete robot2;

    return 0;
}

In this code, we define a base class Robot with a virtual function move(). The move() function in the Robot class provides a default implementation that prints “Robot is moving”.

We then define two derived classes, WheeledRobot and LeggedRobot, which inherit from the Robot class. Both derived classes override the move() function to provide their own specific implementation. 

The WheeledRobot class prints “Wheeled robot is rolling”, while the LeggedRobot class prints “Legged robot is walking”.

In the main() function, we create pointers to the base class Robot, but we assign them objects of the derived classes WheeledRobot and LeggedRobot. We then call the move() function using these pointers.

Run the code.

You will see the output of the move() function for each robot, demonstrating polymorphism through virtual functions.

Virtual functions are particularly useful when working with different types of robots or robot components that share a common interface but have varying behaviors. They allow you to write more modular and extensible code, making your robotics projects easier to maintain and expand.

Understanding this Pointer

Let’s dive into understanding the “this” pointer in C++, which is important for managing object-oriented programming in robotics applications. The this pointer is an implicit parameter to all nonstatic member functions, giving a method access to the invoking object’s address.

Let’s start by creating an example that demonstrates how the “this” pointer can be used to access object members and ensure clarity in the code, especially when parameter names are the same as data member names.

Let’s create a new C++ file and name it robot_coordinates.cpp.

Type the following code into the editor:

#include <iostream>

class Robot {
public:
    int x, y;
    Robot(int x, int y) {
        this->x = x;
        this->y = y;
    }
    void print_coordinates() {
        std::cout << "Coordinates: (" << this->x << ", " << this->y << ")" << std::endl;
    }
};

int main() {
    Robot my_robot(3, 7);
    my_robot.print_coordinates();
    return 0;
}

In this code, we define a class Robot with two integer data members x and y. 

The constructor takes two parameters with the same names as the data members. We use this->x and this->y to assign the value of the parameters to the object’s data members, making it clear which variables are being referenced.

Run the code.

You should see the output “Coordinates: (3, 7)” in the terminal.

This simple example illustrates how the this pointer helps in referring to the calling object’s members, especially in scenarios where local variables or parameters may shadow member names. This is particularly useful in larger robotics projects where such conflicts might arise more frequently.

Using Pointer Operators

Let’s cover the basics of using pointer operators in C++. Understanding pointers is essential for developing efficient robotics applications, where you often need to manipulate memory directly for performance and flexibility.

Let’s get started by creating a practical example that demonstrates the use of pointer operators to handle data effectively.

Create a new C++ file and name it sensor_data_pointers.cpp.

Type the following code into the editor:

#include <iostream>

int main() {
    int sensor_value = 100;
    int* ptr = &sensor_value;

    std::cout << "Sensor Value: " << *ptr << std::endl;  // Dereferencing ptr to get the value of sensor_value
    std::cout << "Memory Address: " << ptr << std::endl; // Displaying the memory address stored in ptr

    *ptr = 200; // Changing the value of sensor_value using the pointer
    std::cout << "Updated Sensor Value: " << sensor_value << std::endl;

    return 0;
}

In this code, we define an integer sensor_value and a pointer ptr which holds the address of sensor_value. 

We use the dereference operator * to access and modify the value stored at the memory address the pointer is pointing to.

Run the code.

You should see the initial sensor value, its memory address, and the updated sensor value displayed in the terminal.

A pointer is like giving multiple parts of your program a map to where a single piece of data lives in memory, instead of making copies – imagine copying a huge video feed multiple times versus just pointing to where it exists once. 

This is important in robotics where you’re often working with massive amounts of real-time data (like video feeds, sensor arrays, or 3D maps) and need to be efficient with your limited RAM, especially on embedded systems that don’t have much memory to begin with.

Demonstrating Polymorphism

Let’s explore polymorphism in C++, a core concept in object-oriented programming that is important for building flexible and scalable robotic systems. Polymorphism enables us to interact with different types of objects through a common interface, allowing for more generalized and reusable code.

Create a new C++ file and name it robot_actuators.cpp.

Type the following code into the editor:

#include <iostream>

// Base class
class Actuator {
public:
    virtual void activate() = 0; // Pure virtual function making Actuator an abstract class
};

// Derived class
class Motor : public Actuator {
public:
    void activate() override {
        std::cout << "Motor is running." << std::endl;
    }
};

// Another derived class
class Servo : public Actuator {
public:
    void activate() override {
        std::cout << "Servo is adjusting position." << std::endl;
    }
};

// Function that demonstrates polymorphism
void test_actuator(Actuator& actuator) {
    actuator.activate(); // Calling the activate function polymorphically
}

int main() {
    Motor motor;
    Servo servo;

    test_actuator(motor);
    test_actuator(servo);

    return 0;
}

Here, the test_actuator function takes a reference (Actuator&) to an Actuator object. Using a reference ensures that no copying of the object occurs, which enhances efficiency by saving memory and processing time. It also guarantees that the passed object is valid since references cannot be null, adding a layer of safety to our function. 

Run the code.

You should see “Motor is running.” followed by “Servo is adjusting position.” in the terminal, demonstrating polymorphic behavior.

By using polymorphism, you can manage various types of robotic components through a unified interface, simplifying complex software architectures.

Thanks, and I’ll see you in the next tutorial.

Keep building!

In this tutorial, we will learn how to generate Doxygen comments in C++ code using Visual Studio Code. Doxygen comments are essential for creating clear, professional documentation for your robotics code.

Prerequisites

• You have completed this tutorial: How to Implement Object-Oriented Programming Basics in C++.
• I am assuming you are using Visual Studio Code, but you can use any code editor.

Directions

Open a terminal window, and type this:

cd ~/Documents/cpp_tutorial

code .

Click the Extensions icon in the sidebar.

Search for “Doxygen Documentation Generator“.

Install the extension by Christoph Schlosser.

Create a new file, and save it as robot_controller_doxygen.cpp. This will be our working file for this tutorial.

Type the following code into the editor:

#include <string>

class RobotController {
    private:
        double maxSpeed;
        std::string robotName;

    public:
        RobotController(std::string name, double speed);
        void moveForward(double distance);
};

To generate Doxygen comments, place your cursor above the class or function you want to document and type /** followed by Enter. The extension will automatically generate a comment template. Fill it in like this:

#include <string>

/**
 * @brief Controller class for robot movement
 * @details Handles basic movement operations and speed control for the robot
 */
class RobotController {
    private:
        double maxSpeed;
        std::string robotName;

    public:
        /**
         * @brief Construct a new Robot Controller object
         * @param name The name identifier for the robot
         * @param speed The maximum speed in meters per second
         */
        RobotController(std::string name, double speed);

        /**
         * @brief Moves the robot forward by the specified distance
         * @param distance The distance to move in meters
         * @return void
         */
        void moveForward(double distance);
};

Understanding the Code

Doxygen comments use special tags that begin with @ or \:

• @brief provides a short description
• @details gives a more detailed explanation
• @param documents a parameter
• @return describes the return value

The extension automatically generates the appropriate tags based on the code it’s documenting. You just need to fill in the descriptions.

Thanks, and I’ll see you in the next tutorial.

Keep building!

In this tutorial, we will explore object-oriented programming basics in C++.

Prerequisites

• You have completed this tutorial: How to Use Functions and Pointers in C++.
• I am assuming you are using Visual Studio Code, but you can use any code editor.

Implementing Classes and Objects

In this tutorial, we’re going to enhance our understanding of object-oriented programming in C++ by creating a class to represent a robotic distance sensor. Sensors are pivotal in robotics, providing the ability to perceive and interact with the environment.

Open a terminal window, and type this:

cd ~/Documents/cpp_tutorial

code .

Let’s begin by creating a new C++ file and naming it distance_sensor.cpp.

Type the following code into the editor:

#include <iostream>
using namespace std;

// Definition of the DistanceSensor class
class DistanceSensor {
private:
    double range;  // Maximum range of the sensor in meters

public:
    // Constructor that initializes the sensor's range
    DistanceSensor(double max_range) : range(max_range) {}

    // Method to display the maximum range of the sensor
    void displayRange() {
        cout << "Sensor maximum range: " << range << " meters" << endl;
    }
};

int main() {
    // Creating an instance of DistanceSensor with a range of 1.5 meters
    DistanceSensor front_sensor(1.5);
    front_sensor.displayRange();  // Calling the display method
    return 0;
}

Here’s a breakdown of what we just wrote:

#include <iostream> allows us to use input and output operations, specifically cout for displaying text.

We declare a class named DistanceSensor that models a distance sensor in a robotic system. It includes:

• A private data member range, which is not accessible outside the class. This encapsulation is a key principle of object-oriented programming, protecting the integrity of the data.
• A public constructor that initializes the range when a new object is created. The initializer list (: range(max_range)) directly sets the range member variable.
• A public method displayRange() that outputs the range to the console. This method demonstrates how objects can have behaviors through functions.

Run the code.

This example shows how to define a class with private data and public methods, encapsulating the functionality in a way that’s easy to manage and expand for larger robotic systems. Using classes like this helps keep your robot’s code organized and modular.

Using Header Files

Let’s learn how to use header files in C++ to organize our code. Whether you’re building a small project or a complex robotics system, understanding header files is important.

Header files (typically ending in .hpp or .h) serve as a “contract” or “interface” for your code. They declare what functionality is available without specifying how that functionality is implemented. This separation between declaration and implementation is a key principle in C++ programming.

Let’s create a minimal example with two files:

1. robot.hpp – Our header file containing the class declaration
2. robot.cpp – Our implementation file containing the actual code and main function

Type the following code into robot.hpp:

#ifndef ROBOT_HPP_
#define ROBOT_HPP_

class Robot {
public:
    void greet();
};

#endif

Let’s break down what’s happening here:

• #ifndef, #define, and #endif are called “include guards”. They prevent multiple inclusions of the same header file, which could cause compilation errors.
• The class Robot is declared with a single public method greet().
• Notice we only declare what the class can do, not how it does it.

Now type the following code into robot.cpp:

#include "robot.hpp"
#include <iostream>

void Robot::greet() {
    std::cout << "Hello, I am a robot." << std::endl;
}

int main() {
    Robot my_robot;
    my_robot.greet();
    return 0;
}

Here’s what’s happening in our implementation file:

• #include “robot.hpp” tells the compiler to insert the contents of our header file here.
• #include <iostream> gives us access to input/output functionality.
• We implement the greet() method using Robot::greet() syntax to specify it belongs to the Robot class.
• The main() function creates a robot object and calls its method.

When you use #include, the compiler looks for the specified file in different locations depending on how you include it:

• #include “file.hpp” (with quotes): Searches first in the current directory, then in compiler-specified include paths
• #include <file.hpp> (with angles): Searches only in compiler-specified system include paths (e.g. /usr/include)

Run the robot.cpp code using Code Runner.

You could also run the code as follows…

Open a terminal in Visual Studio Code by navigating to ‘Terminal’ in the top menu and clicking on ‘New Terminal’. Type the following command to compile:

g++ robot.cpp -o robot

This command compiles robot.cpp, and because robot.hpp is in the same directory and included in robot.cpp, the compiler finds it without issue. 

If robot.hpp were in another directory, you would need to tell the compiler where to find it using the -I option followed by the path to the directory.

Run the program with:

./robot

Defining Access Specifiers: Private, Protected, and Public

Let’s explore access specifiers in C++, which are important for object-oriented programming in robotics applications. Access specifiers determine the visibility and accessibility of class members, ensuring proper encapsulation and data protection.

Let’s create a new C++ file and name it access_specifiers.cpp.

Type the following code into the editor:

#include <iostream>

class Robot {
private:
    int battery_level_; // Only accessible within the class

protected:
    int max_speed_; // Accessible within the class and derived classes

public:
    Robot(int battery, int speed) {
        battery_level_ = battery;
        max_speed_ = speed;
    }

    void print_status() {
        std::cout << "Battery Level: " << battery_level_ << std::endl;
        std::cout << "Max Speed: " << max_speed_ << std::endl;
    }
};

int main() {
    Robot my_robot(75, 10);
    my_robot.print_status(); // Allowed as print_status() is public
    return 0;
}

In this example, we define a Robot class with three members:

• battery_level_ (private): Only accessible within the Robot class itself.
• max_speed_ (protected): Accessible within the Robot class and any classes derived from it.
• print_status() (public): Accessible from anywhere, including outside the class.

The private specifier ensures that the battery_level_ variable cannot be accessed or modified directly from outside the class, promoting data encapsulation and preventing unintended modifications.

The protected specifier allows the max_speed_ variable to be accessed by the Robot class and any classes derived from it, facilitating code reuse and inheritance in robotics applications.

The public specifier makes the print_status() function accessible from anywhere, allowing other parts of the program to retrieve and display the robot’s status.

Run the code.

You should see the robot’s battery level and max speed printed in the terminal.

Employing the static Keyword

Let’s explore the static keyword in C++ and how it can be useful in robotics projects.

The static keyword in C++ has two primary uses:

1. Static variables: When a variable is declared as static inside a function, it retains its value between function calls.
2. Static member variables and functions: When a member variable or function is declared as static in a class, it belongs to the class itself rather than any specific instance of the class.

Create a new C++ file and name it static_example.cpp.

Type the following code into the editor:

#include <iostream>

void increment_counter() {
    static int count = 0;
    count++;
    std::cout << "Counter: " << count << std::endl;
}

int main() {
    for (int i = 0; i < 5; i++) {
        increment_counter();
    }
    return 0;
}

In this code, we define a function called increment_counter() that increments a static variable count each time it is called. The count variable is initialized to 0 only once, and its value persists between function calls.

In the main() function, we call increment_counter() five times using a for loop.

Run the code.

You should see the value of count increasing with each function call, demonstrating that the static variable retains its value between calls.

This example illustrates how static variables can be useful in robotics projects. For instance, you might use a static variable to keep track of the total distance traveled by a robot or to count the number of objects a robot has picked up.

Static member variables and functions are also valuable in robotics, as they allow you to define properties and behaviors that are shared by all instances of a class, such as a robot’s maximum speed or a function that calculates the inverse kinematics for a robotic arm.

Implementing Constructors

Let’s learn about constructors in C++ and how they can be used in robotics projects.

Constructors are special member functions in C++ that are automatically called when an object of a class is created. They are used to initialize the object’s data members and perform any necessary setup.

Create a new C++ file and name it constructor_example.cpp.

Type the following code into the editor:

#include <iostream>
#include <string>

class Robot {
public:
    Robot(std::string name, int x, int y) {
        name_ = name;
        x_ = x;
        y_ = y;
        std::cout << "Robot " << name_ << " created at position (" << x_ << ", " << y_ << ")" << std::endl;
    }

private:
    std::string name_;
    int x_;
    int y_;
};

int main() {
    Robot robot1("AutomaticAddisonBot1", 0, 0);
    Robot robot2("AutomaticAddisonBot2", 10, 20);
    return 0;
}

In this code, we define a Robot class with a constructor that takes three parameters: name, x, and y. The constructor initializes the name_, x_, and y_ data members of the class and prints a message indicating the robot’s name and initial position.

In the main() function, we create two Robot objects, robot1 and robot2, with different names and initial positions.

Run the code.

You should see messages in the terminal indicating the creation of the two robots with their respective names and initial positions.

This example demonstrates how constructors can be used to initialize objects in a robotics project. You can use constructors to set up a robot’s initial state, such as its position, orientation, or any other relevant parameters.

Overloading Functions

Let’s explore function overloading in C++ and how you can apply it in your robotics projects.

Function overloading is a feature in C++ that allows you to define multiple functions with the same name but different parameter lists. The compiler distinguishes between the overloaded functions based on the number, types, and order of the arguments passed when the function is called.

Create a new C++ file and name it overloading_example.cpp.

Type the following code into the editor:

#include <iostream>

void move_robot(int distance) {
    std::cout << "Moving robot forward by " << distance << " units" << std::endl;
}

void move_robot(int x, int y) {
    std::cout << "Moving robot to position (" << x << ", " << y << ")" << std::endl;
}

int main() {
    move_robot(10);
    move_robot(5, 7);
    return 0;
}

In this code, we define two functions named move_robot. The first function takes a single integer parameter distance, while the second function takes two integer parameters x and y.

The first move_robot function simulates moving the robot forward by a specified distance, while the second move_robot function simulates moving the robot to a specific position on a 2D plane.

In the main() function, we call both overloaded move_robot functions with different arguments.

Run the code.

You should see messages in the terminal indicating the robot’s movement based on the arguments passed to the overloaded move_robot functions.

Function overloading is particularly useful when you want to provide multiple ways to perform a similar action, such as moving a robot, but with different parameters or units of measurement.

Implementing Destructors

Let’s learn about destructors in C++ and how you can use them in robotics projects.

Destructors are special member functions in C++ that are automatically called when an object of a class is destroyed. They are used to clean up any resources allocated by the object during its lifetime, such as memory, file handles, or network connections.

Create a new C++ file, and name it destructor_example.cpp.

Type the following code into the editor:

#include <iostream>

class RobotController {
public:
    RobotController() {
        std::cout << "Robot controller initialized" << std::endl;
    }

    ~RobotController() {
        std::cout << "Robot controller shutting down" << std::endl;
        // Clean up resources, e.g., close connections, release memory
    }

    void control_robot() {
        std::cout << "Controlling robot..." << std::endl;
    }
};

int main() {
    RobotController controller;
    controller.control_robot();
    return 0;
}

In this code, we define a RobotController class with a constructor and a destructor. The constructor is called when a RobotController object is created, and it prints a message indicating that the controller has been initialized.

The destructor is prefixed with a tilde (~) and has the same name as the class. It is called when the RobotController object goes out of scope or is explicitly deleted. 

In this example, the destructor prints a message indicating that the controller is shutting down. In a real-world scenario, the destructor would also clean up any resources allocated by the controller.

The control_robot() function simulates the controller performing some robot control tasks.

In the main() function, we create a RobotController object named controller and call its control_robot() function.

Run the code.

You should see messages in the terminal indicating the initialization of the robot controller, the control of the robot, and finally, the shutting down of the controller when the object is destroyed.

This example demonstrates how destructors can be used in robotics projects to ensure proper cleanup and resource management. Destructors are particularly important when working with limited resources or when managing external connections, such as communication with hardware or other systems.

Thanks, and I’ll see you in the next tutorial.

Keep building!