Revisions to Sorting polymorphic classes - Code Review Stack Exchange

added override to overrwritten virtual interface class

Source Link

edited Jun 17, 2020 at 14:21

121
4

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> //std::swap()
#include <random>

using my_engine = std::random_device;


class Comparable
{
private:

public:
    virtual int getNumber() = 0;
    virtual std::string getName() = 0;
//rule of three
    Comparable() = default;
    virtual    Comparable &operator=(const Comparable& other) = default;
    virtual ~Comparable() = default;

    int compare(Comparable& other);
};

class HighScoreElement : public Comparable
{
private:
    std::vector<Comparable*> _p_Vector;
    std::string _player{};
    int _score{};

public:
    std::string getName() override {return _player;}
    int getNumber() override {return _score;}
//rule of three
    virtual HighScoreElement &operator=(const HighScoreElement& other) = default;
    HighScoreElement(std::vector<Comparable*> p_Vector):_p_Vector(p_Vector){}
    HighScoreElement(std::string player, int score): _player(player), _score(score){}
    virtual ~HighScoreElement() = default;

    void setVector(std::vector<Comparable*>& p_Vector){_p_Vector = p_Vector;}
    std::vector<Comparable*>& getVector(){return _p_Vector;}
    void setNewElement(std::string name, int number);
    void getAllElements();

    std::string randomNames();
    int randomNumber(int size);
};

void sort(HighScoreElement &team);
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index);

int main()
{

    std::vector<Comparable*> p_Vector;
    HighScoreElement *team1 = new HighScoreElement(p_Vector);
    int teamplayer{team1->randomNumber(20)};

    for(int i = 0; i < teamplayer; ++i){
    team1->setNewElement(team1->randomNames(), team1->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team1->getAllElements();
    sort(*team1);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team1->getAllElements();

    HighScoreElement *team2 = new HighScoreElement(p_Vector);
    for(int i = 0; i < teamplayer; ++i){
    team2->setNewElement(team2->randomNames(), team2->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team2->getAllElements();
    sort(*team2);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team2->getAllElements();

    delete team1;
    delete team2;

    return 0;
}

void sort(HighScoreElement &team)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   for(size_t i = 0; i < p_Vector.size(); ++i){
       int index = findSmallestRemainingElement(team, i);
       std::swap(p_Vector[i], p_Vector[index]);
       team.setVector(p_Vector);
   }
}
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   int result{};

    size_t index_of_smallest_value = index;
    for(size_t i = index +1; i < p_Vector.size(); ++i){
        result = p_Vector[i]->compare(*p_Vector[index_of_smallest_value]);
        if(result == -1){
            index_of_smallest_value = i;
            team.setVector(p_Vector);
        }
    }
    return index_of_smallest_value;
}

void HighScoreElement::setNewElement(std::string name, int number)
{
    _p_Vector.push_back(new HighScoreElement(name, number));
}

void HighScoreElement::getAllElements()
{
    for(size_t i = 0; i < _p_Vector.size(); i++){
        std::cout << _p_Vector[i]->getNumber() << " <-- ";
        std::cout << _p_Vector[i]->getName() << std::endl;
    }
}

std::string HighScoreElement::randomNames()
{
    std::string firstName[10]={"Jenny", "Sarah", "Belinda", "Mary", "Mark", "John", "Jack", "Jeff", "Peter", "Betty"};
    std::string lastName[10]={"Cunningham", "Johnson", "Stuard", "Furgeson", "Meyer", "Brown", "Brackston", "Harrison", "McCartney", "Harrington"};
    std::string name = firstName[randomNumber(9)] + " " + lastName[randomNumber(9)];
    return name;
}

int HighScoreElement::randomNumber(int size)
{
    my_engine engnSize;
    std::uniform_int_distribution<int> distSize(0,size);
    int number = distSize(engnSize);
    return number;
}

int Comparable::compare(Comparable &other)
{
    //    std::cout << this->getNumber() << std::endl;
    //    std::cout << other.getNumber() << std::endl;
    int Number1 = this->getNumber(), Number2 = other.getNumber();
    std::string Name1 = this->getName(), Name2 = other.getName();

    //same as other return 0;1
    if(Number1 == Number2){
        //If same as check name
        if(Name1 == Name2){
            return 0;
        }else if(Name1 > Name2){
            return 1;
        }else if(Name1 < Name2){
            return -1;
        }else{
            return 99;
        }
        //grater than other return 1;
    } else if(Number1 >= Number2){
        return 1;
        //less than other return -1;
    } else if(Number1 <= Number2){
        return -1;
    }else{
        std::cout << "Invalid Comparision" << std::endl;
        return 99;
    }
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> //std::swap()
#include <random>

using my_engine = std::random_device;


class Comparable
{
private:

public:
    virtual int getNumber() = 0;
    virtual std::string getName() = 0;
//rule of three
    Comparable() = default;
    virtual    Comparable &operator=(const Comparable& other) = default;
    virtual ~Comparable() = default;

    int compare(Comparable& other);
};

class HighScoreElement : public Comparable
{
private:
    std::vector<Comparable*> _p_Vector;
    std::string _player{};
    int _score{};

public:
    std::string getName(){return _player;}
    int getNumber(){return _score;}
//rule of three
    virtual HighScoreElement &operator=(const HighScoreElement& other) = default;
    HighScoreElement(std::vector<Comparable*> p_Vector):_p_Vector(p_Vector){}
    HighScoreElement(std::string player, int score): _player(player), _score(score){}
    virtual ~HighScoreElement() = default;

    void setVector(std::vector<Comparable*>& p_Vector){_p_Vector = p_Vector;}
    std::vector<Comparable*>& getVector(){return _p_Vector;}
    void setNewElement(std::string name, int number);
    void getAllElements();

    std::string randomNames();
    int randomNumber(int size);
};

void sort(HighScoreElement &team);
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index);

int main()
{

    std::vector<Comparable*> p_Vector;
    HighScoreElement *team1 = new HighScoreElement(p_Vector);
    int teamplayer{team1->randomNumber(20)};

    for(int i = 0; i < teamplayer; ++i){
    team1->setNewElement(team1->randomNames(), team1->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team1->getAllElements();
    sort(*team1);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team1->getAllElements();

    HighScoreElement *team2 = new HighScoreElement(p_Vector);
    for(int i = 0; i < teamplayer; ++i){
    team2->setNewElement(team2->randomNames(), team2->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team2->getAllElements();
    sort(*team2);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team2->getAllElements();

    delete team1;
    delete team2;

    return 0;
}

void sort(HighScoreElement &team)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   for(size_t i = 0; i < p_Vector.size(); ++i){
       int index = findSmallestRemainingElement(team, i);
       std::swap(p_Vector[i], p_Vector[index]);
       team.setVector(p_Vector);
   }
}
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   int result{};

    size_t index_of_smallest_value = index;
    for(size_t i = index +1; i < p_Vector.size(); ++i){
        result = p_Vector[i]->compare(*p_Vector[index_of_smallest_value]);
        if(result == -1){
            index_of_smallest_value = i;
            team.setVector(p_Vector);
        }
    }
    return index_of_smallest_value;
}

void HighScoreElement::setNewElement(std::string name, int number)
{
    _p_Vector.push_back(new HighScoreElement(name, number));
}

void HighScoreElement::getAllElements()
{
    for(size_t i = 0; i < _p_Vector.size(); i++){
        std::cout << _p_Vector[i]->getNumber() << " <-- ";
        std::cout << _p_Vector[i]->getName() << std::endl;
    }
}

std::string HighScoreElement::randomNames()
{
    std::string firstName[10]={"Jenny", "Sarah", "Belinda", "Mary", "Mark", "John", "Jack", "Jeff", "Peter", "Betty"};
    std::string lastName[10]={"Cunningham", "Johnson", "Stuard", "Furgeson", "Meyer", "Brown", "Brackston", "Harrison", "McCartney", "Harrington"};
    std::string name = firstName[randomNumber(9)] + " " + lastName[randomNumber(9)];
    return name;
}

int HighScoreElement::randomNumber(int size)
{
    my_engine engnSize;
    std::uniform_int_distribution<int> distSize(0,size);
    int number = distSize(engnSize);
    return number;
}

int Comparable::compare(Comparable &other)
{
    //    std::cout << this->getNumber() << std::endl;
    //    std::cout << other.getNumber() << std::endl;
    int Number1 = this->getNumber(), Number2 = other.getNumber();
    std::string Name1 = this->getName(), Name2 = other.getName();

    //same as other return 0;1
    if(Number1 == Number2){
        //If same as check name
        if(Name1 == Name2){
            return 0;
        }else if(Name1 > Name2){
            return 1;
        }else if(Name1 < Name2){
            return -1;
        }else{
            return 99;
        }
        //grater than other return 1;
    } else if(Number1 >= Number2){
        return 1;
        //less than other return -1;
    } else if(Number1 <= Number2){
        return -1;
    }else{
        std::cout << "Invalid Comparision" << std::endl;
        return 99;
    }
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> //std::swap()
#include <random>

using my_engine = std::random_device;


class Comparable
{
private:

public:
    virtual int getNumber() = 0;
    virtual std::string getName() = 0;
//rule of three
    Comparable() = default;
    virtual    Comparable &operator=(const Comparable& other) = default;
    virtual ~Comparable() = default;

    int compare(Comparable& other);
};

class HighScoreElement : public Comparable
{
private:
    std::vector<Comparable*> _p_Vector;
    std::string _player{};
    int _score{};

public:
    std::string getName() override {return _player;}
    int getNumber() override {return _score;}
//rule of three
    virtual HighScoreElement &operator=(const HighScoreElement& other) = default;
    HighScoreElement(std::vector<Comparable*> p_Vector):_p_Vector(p_Vector){}
    HighScoreElement(std::string player, int score): _player(player), _score(score){}
    virtual ~HighScoreElement() = default;

    void setVector(std::vector<Comparable*>& p_Vector){_p_Vector = p_Vector;}
    std::vector<Comparable*>& getVector(){return _p_Vector;}
    void setNewElement(std::string name, int number);
    void getAllElements();

    std::string randomNames();
    int randomNumber(int size);
};

void sort(HighScoreElement &team);
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index);

int main()
{

    std::vector<Comparable*> p_Vector;
    HighScoreElement *team1 = new HighScoreElement(p_Vector);
    int teamplayer{team1->randomNumber(20)};

    for(int i = 0; i < teamplayer; ++i){
    team1->setNewElement(team1->randomNames(), team1->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team1->getAllElements();
    sort(*team1);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team1->getAllElements();

    HighScoreElement *team2 = new HighScoreElement(p_Vector);
    for(int i = 0; i < teamplayer; ++i){
    team2->setNewElement(team2->randomNames(), team2->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team2->getAllElements();
    sort(*team2);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team2->getAllElements();

    delete team1;
    delete team2;

    return 0;
}

void sort(HighScoreElement &team)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   for(size_t i = 0; i < p_Vector.size(); ++i){
       int index = findSmallestRemainingElement(team, i);
       std::swap(p_Vector[i], p_Vector[index]);
       team.setVector(p_Vector);
   }
}
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   int result{};

    size_t index_of_smallest_value = index;
    for(size_t i = index +1; i < p_Vector.size(); ++i){
        result = p_Vector[i]->compare(*p_Vector[index_of_smallest_value]);
        if(result == -1){
            index_of_smallest_value = i;
            team.setVector(p_Vector);
        }
    }
    return index_of_smallest_value;
}

void HighScoreElement::setNewElement(std::string name, int number)
{
    _p_Vector.push_back(new HighScoreElement(name, number));
}

void HighScoreElement::getAllElements()
{
    for(size_t i = 0; i < _p_Vector.size(); i++){
        std::cout << _p_Vector[i]->getNumber() << " <-- ";
        std::cout << _p_Vector[i]->getName() << std::endl;
    }
}

std::string HighScoreElement::randomNames()
{
    std::string firstName[10]={"Jenny", "Sarah", "Belinda", "Mary", "Mark", "John", "Jack", "Jeff", "Peter", "Betty"};
    std::string lastName[10]={"Cunningham", "Johnson", "Stuard", "Furgeson", "Meyer", "Brown", "Brackston", "Harrison", "McCartney", "Harrington"};
    std::string name = firstName[randomNumber(9)] + " " + lastName[randomNumber(9)];
    return name;
}

int HighScoreElement::randomNumber(int size)
{
    my_engine engnSize;
    std::uniform_int_distribution<int> distSize(0,size);
    int number = distSize(engnSize);
    return number;
}

int Comparable::compare(Comparable &other)
{
    //    std::cout << this->getNumber() << std::endl;
    //    std::cout << other.getNumber() << std::endl;
    int Number1 = this->getNumber(), Number2 = other.getNumber();
    std::string Name1 = this->getName(), Name2 = other.getName();

    //same as other return 0;1
    if(Number1 == Number2){
        //If same as check name
        if(Name1 == Name2){
            return 0;
        }else if(Name1 > Name2){
            return 1;
        }else if(Name1 < Name2){
            return -1;
        }else{
            return 99;
        }
        //grater than other return 1;
    } else if(Number1 >= Number2){
        return 1;
        //less than other return -1;
    } else if(Number1 <= Number2){
        return -1;
    }else{
        std::cout << "Invalid Comparision" << std::endl;
        return 99;
    }
}

syntax highlighting broken - tried to fix it

Source Link

edited Jun 17, 2020 at 12:23

Ingo Mi

121
4


 #include <iostream>
#include <vector>
#include <string>
#include <algorithm> //std::swap()
#include <random>

using my_engine = std::random_device;


class Comparable
{
private:

public:
    virtual int getNumber() = 0;
    virtual std::string getName() = 0;
//rule of three
    Comparable() = default;
    virtual    Comparable &operator=(const Comparable& other) = default;
    virtual ~Comparable() = default;

    int compare(Comparable& other);
};

class HighScoreElement : public Comparable
{
private:
    std::vector<Comparable*> _p_Vector;
    std::string _player{};
    int _score{};

public:
    std::string getName(){return _player;}
    int getNumber(){return _score;}
//rule of three
    virtual HighScoreElement &operator=(const HighScoreElement& other) = default;
    HighScoreElement(std::vector<Comparable*> p_Vector):_p_Vector(p_Vector){}
    HighScoreElement(std::string player, int score): _player(player), _score(score){}
    virtual ~HighScoreElement() = default;

    void setVector(std::vector<Comparable*>& p_Vector){_p_Vector = p_Vector;}
    std::vector<Comparable*>& getVector(){return _p_Vector;}
    void setNewElement(std::string name, int number);
    void getAllElements();

    std::string randomNames();
    int randomNumber(int size);
};

void sort(HighScoreElement &team);
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index);

int main()
{

    std::vector<Comparable*> p_Vector;
    HighScoreElement *team1 = new HighScoreElement(p_Vector);
    int teamplayer{team1->randomNumber(20)};

    for(int i = 0; i < teamplayer; ++i){
    team1->setNewElement(team1->randomNames(), team1->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team1->getAllElements();
    sort(*team1);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team1->getAllElements();

    HighScoreElement *team2 = new HighScoreElement(p_Vector);
    for(int i = 0; i < teamplayer; ++i){
    team2->setNewElement(team2->randomNames(), team2->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team2->getAllElements();
    sort(*team2);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team2->getAllElements();

    delete team1;
    delete team2;

    return 0;
}

void sort(HighScoreElement &team)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   for(size_t i = 0; i < p_Vector.size(); ++i){
       int index = findSmallestRemainingElement(team, i);
       std::swap(p_Vector[i], p_Vector[index]);
       team.setVector(p_Vector);
   }
}
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   int result{};

    size_t index_of_smallest_value = index;
    for(size_t i = index +1; i < p_Vector.size(); ++i){
        result = p_Vector[i]->compare(*p_Vector[index_of_smallest_value]);
        if(result == -1){
            index_of_smallest_value = i;
            team.setVector(p_Vector);
        }
    }
    return index_of_smallest_value;
}

void HighScoreElement::setNewElement(std::string name, int number)
{
    _p_Vector.push_back(new HighScoreElement(name, number));
}

void HighScoreElement::getAllElements()
{
    for(size_t i = 0; i < _p_Vector.size(); i++){
        std::cout << _p_Vector[i]->getNumber() << " <-- ";
        std::cout << _p_Vector[i]->getName() << std::endl;
    }
}

std::string HighScoreElement::randomNames()
{
    std::string firstName[10]={"Jenny", "Sarah", "Belinda", "Mary", "Mark", "John", "Jack", "Jeff", "Peter", "Betty"};
    std::string lastName[10]={"Cunningham", "Johnson", "Stuard", "Furgeson", "Meyer", "Brown", "Brackston", "Harrison", "McCartney", "Harrington"};
    std::string name = firstName[randomNumber(9)] + " " + lastName[randomNumber(9)];
    return name;
}

int HighScoreElement::randomNumber(int size)
{
    my_engine engnSize;
    std::uniform_int_distribution<int> distSize(0,size);
    int number = distSize(engnSize);
    return number;
}

int Comparable::compare(Comparable &other)
{
    //    std::cout << this->getNumber() << std::endl;
    //    std::cout << other.getNumber() << std::endl;
    int Number1 = this->getNumber(), Number2 = other.getNumber();
    std::string Name1 = this->getName(), Name2 = other.getName();

    //same as other return 0;1
    if(Number1 == Number2){
        //If same as check name
        if(Name1 == Name2){
            return 0;
        }else if(Name1 > Name2){
            return 1;
        }else if(Name1 < Name2){
            return -1;
        }else{
            return 99;
        }
        //grater than other return 1;
    } else if(Number1 >= Number2){
        return 1;
        //less than other return -1;
    } else if(Number1 <= Number2){
        return -1;
    }else{
        std::cout << "Invalid Comparision" << std::endl;
        return 99;
    }
}

```


 #include <iostream>
#include <vector>
#include <string>
#include <algorithm> //std::swap()
#include <random>

using my_engine = std::random_device;


class Comparable
{
private:

public:
    virtual int getNumber() = 0;
    virtual std::string getName() = 0;
//rule of three
    Comparable() = default;
    virtual    Comparable &operator=(const Comparable& other) = default;
    virtual ~Comparable() = default;

    int compare(Comparable& other);
};

class HighScoreElement : public Comparable
{
private:
    std::vector<Comparable*> _p_Vector;
    std::string _player{};
    int _score{};

public:
    std::string getName(){return _player;}
    int getNumber(){return _score;}
//rule of three
    virtual HighScoreElement &operator=(const HighScoreElement& other) = default;
    HighScoreElement(std::vector<Comparable*> p_Vector):_p_Vector(p_Vector){}
    HighScoreElement(std::string player, int score): _player(player), _score(score){}
    virtual ~HighScoreElement() = default;

    void setVector(std::vector<Comparable*>& p_Vector){_p_Vector = p_Vector;}
    std::vector<Comparable*>& getVector(){return _p_Vector;}
    void setNewElement(std::string name, int number);
    void getAllElements();

    std::string randomNames();
    int randomNumber(int size);
};

void sort(HighScoreElement &team);
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index);

int main()
{

    std::vector<Comparable*> p_Vector;
    HighScoreElement *team1 = new HighScoreElement(p_Vector);
    int teamplayer{team1->randomNumber(20)};

    for(int i = 0; i < teamplayer; ++i){
    team1->setNewElement(team1->randomNames(), team1->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team1->getAllElements();
    sort(*team1);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team1->getAllElements();

    HighScoreElement *team2 = new HighScoreElement(p_Vector);
    for(int i = 0; i < teamplayer; ++i){
    team2->setNewElement(team2->randomNames(), team2->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team2->getAllElements();
    sort(*team2);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team2->getAllElements();

    delete team1;
    delete team2;

    return 0;
}

void sort(HighScoreElement &team)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   for(size_t i = 0; i < p_Vector.size(); ++i){
       int index = findSmallestRemainingElement(team, i);
       std::swap(p_Vector[i], p_Vector[index]);
       team.setVector(p_Vector);
   }
}
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   int result{};

    size_t index_of_smallest_value = index;
    for(size_t i = index +1; i < p_Vector.size(); ++i){
        result = p_Vector[i]->compare(*p_Vector[index_of_smallest_value]);
        if(result == -1){
            index_of_smallest_value = i;
            team.setVector(p_Vector);
        }
    }
    return index_of_smallest_value;
}

void HighScoreElement::setNewElement(std::string name, int number)
{
    _p_Vector.push_back(new HighScoreElement(name, number));
}

void HighScoreElement::getAllElements()
{
    for(size_t i = 0; i < _p_Vector.size(); i++){
        std::cout << _p_Vector[i]->getNumber() << " <-- ";
        std::cout << _p_Vector[i]->getName() << std::endl;
    }
}

std::string HighScoreElement::randomNames()
{
    std::string firstName[10]={"Jenny", "Sarah", "Belinda", "Mary", "Mark", "John", "Jack", "Jeff", "Peter", "Betty"};
    std::string lastName[10]={"Cunningham", "Johnson", "Stuard", "Furgeson", "Meyer", "Brown", "Brackston", "Harrison", "McCartney", "Harrington"};
    std::string name = firstName[randomNumber(9)] + " " + lastName[randomNumber(9)];
    return name;
}

int HighScoreElement::randomNumber(int size)
{
    my_engine engnSize;
    std::uniform_int_distribution<int> distSize(0,size);
    int number = distSize(engnSize);
    return number;
}

int Comparable::compare(Comparable &other)
{
    //    std::cout << this->getNumber() << std::endl;
    //    std::cout << other.getNumber() << std::endl;
    int Number1 = this->getNumber(), Number2 = other.getNumber();
    std::string Name1 = this->getName(), Name2 = other.getName();

    //same as other return 0;1
    if(Number1 == Number2){
        //If same as check name
        if(Name1 == Name2){
            return 0;
        }else if(Name1 > Name2){
            return 1;
        }else if(Name1 < Name2){
            return -1;
        }else{
            return 99;
        }
        //grater than other return 1;
    } else if(Number1 >= Number2){
        return 1;
        //less than other return -1;
    } else if(Number1 <= Number2){
        return -1;
    }else{
        std::cout << "Invalid Comparision" << std::endl;
        return 99;
    }
}

```

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> //std::swap()
#include <random>

using my_engine = std::random_device;


class Comparable
{
private:

public:
    virtual int getNumber() = 0;
    virtual std::string getName() = 0;
//rule of three
    Comparable() = default;
    virtual    Comparable &operator=(const Comparable& other) = default;
    virtual ~Comparable() = default;

    int compare(Comparable& other);
};

class HighScoreElement : public Comparable
{
private:
    std::vector<Comparable*> _p_Vector;
    std::string _player{};
    int _score{};

public:
    std::string getName(){return _player;}
    int getNumber(){return _score;}
//rule of three
    virtual HighScoreElement &operator=(const HighScoreElement& other) = default;
    HighScoreElement(std::vector<Comparable*> p_Vector):_p_Vector(p_Vector){}
    HighScoreElement(std::string player, int score): _player(player), _score(score){}
    virtual ~HighScoreElement() = default;

    void setVector(std::vector<Comparable*>& p_Vector){_p_Vector = p_Vector;}
    std::vector<Comparable*>& getVector(){return _p_Vector;}
    void setNewElement(std::string name, int number);
    void getAllElements();

    std::string randomNames();
    int randomNumber(int size);
};

void sort(HighScoreElement &team);
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index);

int main()
{

    std::vector<Comparable*> p_Vector;
    HighScoreElement *team1 = new HighScoreElement(p_Vector);
    int teamplayer{team1->randomNumber(20)};

    for(int i = 0; i < teamplayer; ++i){
    team1->setNewElement(team1->randomNames(), team1->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team1->getAllElements();
    sort(*team1);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team1->getAllElements();

    HighScoreElement *team2 = new HighScoreElement(p_Vector);
    for(int i = 0; i < teamplayer; ++i){
    team2->setNewElement(team2->randomNames(), team2->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team2->getAllElements();
    sort(*team2);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team2->getAllElements();

    delete team1;
    delete team2;

    return 0;
}

void sort(HighScoreElement &team)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   for(size_t i = 0; i < p_Vector.size(); ++i){
       int index = findSmallestRemainingElement(team, i);
       std::swap(p_Vector[i], p_Vector[index]);
       team.setVector(p_Vector);
   }
}
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   int result{};

    size_t index_of_smallest_value = index;
    for(size_t i = index +1; i < p_Vector.size(); ++i){
        result = p_Vector[i]->compare(*p_Vector[index_of_smallest_value]);
        if(result == -1){
            index_of_smallest_value = i;
            team.setVector(p_Vector);
        }
    }
    return index_of_smallest_value;
}

void HighScoreElement::setNewElement(std::string name, int number)
{
    _p_Vector.push_back(new HighScoreElement(name, number));
}

void HighScoreElement::getAllElements()
{
    for(size_t i = 0; i < _p_Vector.size(); i++){
        std::cout << _p_Vector[i]->getNumber() << " <-- ";
        std::cout << _p_Vector[i]->getName() << std::endl;
    }
}

std::string HighScoreElement::randomNames()
{
    std::string firstName[10]={"Jenny", "Sarah", "Belinda", "Mary", "Mark", "John", "Jack", "Jeff", "Peter", "Betty"};
    std::string lastName[10]={"Cunningham", "Johnson", "Stuard", "Furgeson", "Meyer", "Brown", "Brackston", "Harrison", "McCartney", "Harrington"};
    std::string name = firstName[randomNumber(9)] + " " + lastName[randomNumber(9)];
    return name;
}

int HighScoreElement::randomNumber(int size)
{
    my_engine engnSize;
    std::uniform_int_distribution<int> distSize(0,size);
    int number = distSize(engnSize);
    return number;
}

int Comparable::compare(Comparable &other)
{
    //    std::cout << this->getNumber() << std::endl;
    //    std::cout << other.getNumber() << std::endl;
    int Number1 = this->getNumber(), Number2 = other.getNumber();
    std::string Name1 = this->getName(), Name2 = other.getName();

    //same as other return 0;1
    if(Number1 == Number2){
        //If same as check name
        if(Name1 == Name2){
            return 0;
        }else if(Name1 > Name2){
            return 1;
        }else if(Name1 < Name2){
            return -1;
        }else{
            return 99;
        }
        //grater than other return 1;
    } else if(Number1 >= Number2){
        return 1;
        //less than other return -1;
    } else if(Number1 <= Number2){
        return -1;
    }else{
        std::cout << "Invalid Comparision" << std::endl;
        return 99;
    }
}

Source Link

answered Jun 17, 2020 at 12:18

Ingo Mi

121
4

I tackled the book a time ago, skipped this chapter and came back now since this topic is highly/excessive used in the Qt Toolkit - even tho its a while ago.

Anyhow, you asked for:

I'm especially concerned about my use of dynamic_cast, as that isn't covered yet and I suspect there's a better way.

Yes, by declaring the compare in the Comparable class itself, you made it pure virtual - I guess this wouldn't match the requirement since it really matters if you use it that way.

I also rewrote the sort algorithm from the book working very efficient in here.
It is also a good idea to move the whole initialization and random generation into the class itself - probably declared as virtual in the interface class and I red somewhere it would be better to let the class handle the deletion or like recommended using a smart pointer. I just did raw pointers with delete to test the classes.
I also used std::swap to swap vector entries, declared variables with a{}; and <random> even tho the book is intentionally ante c++11 - this code compiles fine with the c++17 compiler flag.
To avoid unnecessary errors it is a good habit not to use using namespace std; because there are hundreds of questions in stackoverflow about it. If you are fed up writing std::cout or std::endl f.e. just declare using std::cout, std::endl; instead of the whole namespace - but that's covered in the following chapter a bit. It's not wrong for small examples but not a good habit in projects.
I added a random test with random names from a list of 10.


#include <iostream>
#include <vector>
#include <string>
#include <algorithm> //std::swap()
#include <random>

using my_engine = std::random_device;


class Comparable
{
private:

public:
    virtual int getNumber() = 0;
    virtual std::string getName() = 0;
//rule of three
    Comparable() = default;
    virtual    Comparable &operator=(const Comparable& other) = default;
    virtual ~Comparable() = default;

    int compare(Comparable& other);
};

class HighScoreElement : public Comparable
{
private:
    std::vector<Comparable*> _p_Vector;
    std::string _player{};
    int _score{};

public:
    std::string getName(){return _player;}
    int getNumber(){return _score;}
//rule of three
    virtual HighScoreElement &operator=(const HighScoreElement& other) = default;
    HighScoreElement(std::vector<Comparable*> p_Vector):_p_Vector(p_Vector){}
    HighScoreElement(std::string player, int score): _player(player), _score(score){}
    virtual ~HighScoreElement() = default;

    void setVector(std::vector<Comparable*>& p_Vector){_p_Vector = p_Vector;}
    std::vector<Comparable*>& getVector(){return _p_Vector;}
    void setNewElement(std::string name, int number);
    void getAllElements();

    std::string randomNames();
    int randomNumber(int size);
};

void sort(HighScoreElement &team);
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index);

int main()
{

    std::vector<Comparable*> p_Vector;
    HighScoreElement *team1 = new HighScoreElement(p_Vector);
    int teamplayer{team1->randomNumber(20)};

    for(int i = 0; i < teamplayer; ++i){
    team1->setNewElement(team1->randomNames(), team1->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team1->getAllElements();
    sort(*team1);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team1->getAllElements();

    HighScoreElement *team2 = new HighScoreElement(p_Vector);
    for(int i = 0; i < teamplayer; ++i){
    team2->setNewElement(team2->randomNames(), team2->randomNumber(10));
    }

    std::cout << "\n\n######## Random order test: ########" << std::endl;
    team2->getAllElements();
    sort(*team2);
    std::cout << "\n######## Sorted order test: ########" << std::endl;
    team2->getAllElements();

    delete team1;
    delete team2;

    return 0;
}

void sort(HighScoreElement &team)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   for(size_t i = 0; i < p_Vector.size(); ++i){
       int index = findSmallestRemainingElement(team, i);
       std::swap(p_Vector[i], p_Vector[index]);
       team.setVector(p_Vector);
   }
}
size_t findSmallestRemainingElement(HighScoreElement &team, size_t index)
{
   std::vector<Comparable*> p_Vector = team.getVector();
   int result{};

    size_t index_of_smallest_value = index;
    for(size_t i = index +1; i < p_Vector.size(); ++i){
        result = p_Vector[i]->compare(*p_Vector[index_of_smallest_value]);
        if(result == -1){
            index_of_smallest_value = i;
            team.setVector(p_Vector);
        }
    }
    return index_of_smallest_value;
}

void HighScoreElement::setNewElement(std::string name, int number)
{
    _p_Vector.push_back(new HighScoreElement(name, number));
}

void HighScoreElement::getAllElements()
{
    for(size_t i = 0; i < _p_Vector.size(); i++){
        std::cout << _p_Vector[i]->getNumber() << " <-- ";
        std::cout << _p_Vector[i]->getName() << std::endl;
    }
}

std::string HighScoreElement::randomNames()
{
    std::string firstName[10]={"Jenny", "Sarah", "Belinda", "Mary", "Mark", "John", "Jack", "Jeff", "Peter", "Betty"};
    std::string lastName[10]={"Cunningham", "Johnson", "Stuard", "Furgeson", "Meyer", "Brown", "Brackston", "Harrison", "McCartney", "Harrington"};
    std::string name = firstName[randomNumber(9)] + " " + lastName[randomNumber(9)];
    return name;
}

int HighScoreElement::randomNumber(int size)
{
    my_engine engnSize;
    std::uniform_int_distribution<int> distSize(0,size);
    int number = distSize(engnSize);
    return number;
}

int Comparable::compare(Comparable &other)
{
    //    std::cout << this->getNumber() << std::endl;
    //    std::cout << other.getNumber() << std::endl;
    int Number1 = this->getNumber(), Number2 = other.getNumber();
    std::string Name1 = this->getName(), Name2 = other.getName();

    //same as other return 0;1
    if(Number1 == Number2){
        //If same as check name
        if(Name1 == Name2){
            return 0;
        }else if(Name1 > Name2){
            return 1;
        }else if(Name1 < Name2){
            return -1;
        }else{
            return 99;
        }
        //grater than other return 1;
    } else if(Number1 >= Number2){
        return 1;
        //less than other return -1;
    } else if(Number1 <= Number2){
        return -1;
    }else{
        std::cout << "Invalid Comparision" << std::endl;
        return 99;
    }
}

```

Stack Exchange Network

Return to Answer