Why pointer to pointer was used in the code?

Question

Why pointer to pointer has been used rather than single pointer in the code? Also do you think the destructor was written wrong if it is how can i make it correct?

pointer to pointer: employee** _arr;

You can see the code below:

#include<iostream>


class employee {
private:
    std::string _name;
    std::string _surname;
    int _year;
    double _salary;
    static int numberOfEmployees;
public:

    employee() {
        _name = "not-set";
        _surname = "not-set";
        _year = 0;
        _salary = 0;

        numberOfEmployees++;
    }
    employee(int year, std::string name, std::string surname) {
        _name = name;
        _surname = surname;
        _year = year;

        numberOfEmployees++;
        calculateSalary();
    }
    void calculateSalary() {

        //salary = 2310 + 2310 * year * 12/100.0
        _salary = 2310 + (2310 * (double)_year) * (12 / 100.0);
    }
    void printInfo() {
        std::cout << _name << " " << _surname << " " << _year << " " << " " << _salary << " TL/month" << std::endl;
    }

    static int getEmployeeCount() {
        return numberOfEmployees;
    }
};

class employeeList {
private:
    int _size;
    int _lenght;
    employee** _arr;
public:
    employeeList() :_size(1), _lenght(0), _arr(NULL) {}
    employeeList(int size) :_size(size) {
        _arr = new employee * [_size];
        _lenght = 0;
    }
    int listLength() {
        return _lenght;
    }
    employee retrieve_employeeFromIndex(int index) {
        if (index >= 0 && index < _size) {
            return *_arr[index];
        }
    }
    void addToList(employee* item) {
        _lenght++;
        if (_lenght <= _size) {
            _arr[_lenght - 1] = item;
        }
        else {
            std::cout << "you cannot add another employee!";
        }
    }
    static void printEmployees(employeeList el) {
        for (int i = 0; i < el._lenght; i++) {
            el._arr[i]->printInfo();
        }
    }
    ~employeeList() {
        delete[]  _arr;
    }
};
int employee::numberOfEmployees = 0;


int main() {


    employee a;
    employee b(5, "John", " Doe");
    employee c(3, "Sue", "Doe");



    employeeList empList(employee::getEmployeeCount());


    empList.addToList(&a);
    empList.addToList(&b);
    empList.addToList(&c);



    employeeList::printEmployees(empList);
    std::cout << empList.listLength() << std::endl;



    return 0;
}

you can see the output:

Why pointer to pointer has been used rather than single pointer in the code? Also do you think the destructor was written wrong if it is how can i make it correct?

Answer 1

Why pointer to pointer was used in the code?

This is known only by the author who wrote the code. We can make a reasonable guess that their intention may have been to:

1. Allocate a dynamic array of objects, using a bare pointer to the first element of that array.
2. Indirectly point to objects stored elsewhere, hence they wanted to use an array of pointers, thus a pointer to first element of the array is a pointer to a pointer.

Their choice 1. to use an owning bare pointer is unnecessary, and there are better choices available which do not require an owning bare pointer. Most commonly, std::vector would be used to create a dynamic array.

Their choice 2. to indirectly point to objects that aren't owned by the class instance is not quite as safe as having the class instance own the objects, but regardless that may have been a reasonable choice depending on the reasons they chose this design. It is impossible to tell whether the choice was good without documentation of what the program is supposed to do. Based on the generic name of the class, I suspect that it wasn't a good choice.

do you think the destructor was written wrong

It can be considered correct. There are other issues with the class though.

The entire employeeList class seems pointless, and can easily be replaced by a std::vector. printEmployees is the only member function that wouldn't be directly provided by a vector. You can use a non-member function for that instead.