I'm doing an c++ assignment and I'm a complete newbie to c++.
The idea of the assignment is to create an 11 players team form 22 available players. You've to choose 1 from 3 available goalkeepers, 4 from 7 defense players, 4 from 8 middle field players and 2 from 4 attackers (this is a soccer team).
Now the possible combinations for all of that are 44100.
It's a requirement that I used enumerations for the mentioned team parts and I've to give a unique output each time. I'd tried many approaches, but ended up using vectors to do the job. The logic seems to be write to me and the debugging doesn't really help as I get segmentation fault. It would be great if someone could give a hand. I hope the description is clear enough. Here is the code:

#include <string>

#include <vector>

#include <ctime>

#include <iostream>



  enum goal {

        Neuer, terStegen, Trapp

    };



    enum def {

        Boateng, Ginter, Hector, Hummels, Ruediger, Schulz, Suele

    };



    enum mid {

        Brandt, Can, Draxler, Goretzka, Guendogan, Kroos, Mueller, Rudy

    };



    enum att {

        Gnabry, Reus, Sane, Werner

    };



    std::string chooseGoal(int x) {

        switch (x) {

        case 0: return "Neuer";

        case 1: return "ter Stegen";

        case 2: return "Trapp";

        }

    }



    std::string chooseDef(int x) {

        switch (x) {

        case 0: return "Boateng";

        case 1: return "Ginter";

        case 2: return "Hector";

        case 3: return "Hummels";

        case 4: return "Ruediger";

        case 5: return "Schulz";

        case 6: return "Suele";

        }

    }



    std::string chooseMid(int x) {

        switch (x) {

        case 0:return"Brandt";

        case 1:return "Can";

        case 2:return "Draxler";

        case 3:return "Goretzka";

        case 4:return "Guendogan";

        case 5:return "Kroos";

        case 6:return "Mueller";

        case 7:return "Rudy";

        }

    }



    std::string chooseAtt(int x) {

        switch (x) {

        case 0: return "Gnabry";

        case 1: return"Reus";

        case 2: return "Sane";

        case 3: return "Werner";

        }

    }



    std::vector<std::string> createVectorDef() {

        std::vector<std::string> v;

        std::srand(std::time(NULL));

        for (int i = 0; i < 4; i++) {

            int x = rand()%7;

            v.push_back(chooseDef(x));

        }

        return v;

    }



    std::vector<std::string> createVectorMid() {

        std::vector<std::string> v;

        std::srand(std::time(NULL));

        for (int i = 0; i < 4; i++) {

            int x = rand() % 8;

            v.push_back(chooseMid(x));

        }

        return v;

    }



    std::vector<std::string> createVectorAtt() {

        std::vector<std::string> v;

        std::srand(std::time(NULL));

        for (int i = 0; i < 2; i++) {

            int x = rand() % 4;

            v.push_back(chooseAtt(x));

        }

        return v;

    }



    std::vector<std::string> makeUniqueDef(std::vector<std::string> v) {

        for (int i = 0; i < v.size()-1; i++) {

            for (int j = i + 1; j < v.size(); j++) {

                if (v[i] == v[j]) {

                   // v.clear();

                    v = createVectorDef();

                    makeUniqueDef(v);

                } else {

                    continue;

                }

            }

        }

        return v;

    }



    std::vector<std::string> makeUniqueMid(std::vector<std::string> v) {

        for (int i = 0; i < v.size()-1; i++) {

            for (int j = i + 1; j < v.size(); j++) {

                if (v[i] == v[j]) {

                    v = createVectorMid();

                    makeUniqueMid(v);

                } else {

                    continue;

                }

            }

        }

        return v;

    }



    std::vector<std::string> makeUniqueAtt(std::vector<std::string> v) {

        for (int i = 0; i < v.size()-1; i++) {

            for (int j = i + 1; j < v.size(); j++) {

                if (v[i] == v[j]) {

                    v = createVectorAtt();

                    makeUniqueAtt(v);

                } else {

                    continue;

                }

            }

        }

        return v;

    }



    void displayVector(std::vector<std::string> v) {

        for (int i = 0; i < v.size(); i++) {

            if (i == v.size() - 1) {

                std::cout << v[i] << '.' << std::endl;

                break;

            }

            std::cout << ' ' << v[i] << ',';

        }



    }



    int main() {

        // Random Gen

        std::srand(std::time(NULL));

        std::cout << "Tor: " << chooseGoal(rand() % 3) << std::endl;

        //Vector for defence and display

        std::vector<std::string> def = createVectorDef();

        def = makeUniqueDef(def);

        std::cout << "Abwehr:";

        displayVector(def);

        // Vector for mid and display

        std::vector<std::string> mid = createVectorMid();

        mid = makeUniqueMid(mid);

        displayVector(mid);

        std::cout << "Mittelfeld:";

        displayVector(mid);

        // Vector for atta and display;

        std::vector<std::string> att = createVectorAtt();

        att = makeUniqueAtt(att);

        //    std::cout << "Angriff:";

        displayVector(att);







    }

Problem 1

Recursion with an exit case that depends on probability. This always runs the risk of getting unlucky and not exiting before the recursion consumes all Automatic storage.

Problem 2

Repeated calling of srand. Why this is bad is covered here: srand() — why call it only once?

Solution

Don't recurse.

Place players into vectors and use standard library tools to shuffle the vectors and ensure no one can ever be selected twice by removing them from the vector after they are selected.

Here is an example demonstrating only the defenders with comments added where I felt explanation was required.

#include <string>

#include <vector>

#include <ctime>

#include <iostream>

#include <algorithm>

#include <stdexcept>

enum def {

    Boateng, Ginter, Hector, Hummels, Ruediger, Schulz, Suele

};



std::string chooseDef(def x) // use the type, not int. Compiler can help trap errors

{

    // There are better ways to do this. If you put all of the players

    // into one enum you can have one mapping function

    switch (x) {

        // using enumerated value rather than magic numbers

        case Boateng:  return "Boateng";

        case Ginter:   return "Ginter";

        case Hector:   return "Hector";

        case Hummels:  return "Hummels";

        case Ruediger: return "Ruediger";

        case Schulz:   return "Schulz";

        case Suele:    return "Suele";

        default: throw std::runtime_error("Invalid input in chooseDef");

        // added to trap error if called with bad value

    }

}



std::vector<def> makeUniqueDef(std::vector<def> & defenders) {

    // add first four players in vector to vector to be returned. Probably should have a 

    // test here to make sure there are four player in the vector.

    std::vector<def> players(defenders.begin(), defenders.begin() +4);



    // remove players from source vector so they can't be reselected 

    defenders.erase(defenders.begin(), defenders.begin()+4);

    return players;

}



void displayVector(std::vector<def> v) {

    for (size_t i = 0; i < v.size(); i++) {

        // note only converting from enum to string on display

        // this is likely closer to what your instructor wants.

        std::cout << chooseDef(v[i]) << '.' << std::endl;

    }

}



int main() {

    // Random Gen call once and only once.

    // if you need to call it more than once, rand is probably not the tool you need

    std::srand(std::time(NULL));



    // put all defenders in vector

    std::vector<def> defenders = {Boateng, Ginter, Hector, Hummels, Ruediger, Schulz, Suele};



    // mix them up to make for fair selection

    std::random_shuffle (defenders.begin(), defenders.end());

    // random_shuffle is obsolete, but used because it's closer to rand/srand

    // prefer modern C++'s std::shuffle and random library



    // select defenders

    std::vector<def> team1def = makeUniqueDef(defenders);





    // print defenders

    displayVector(team1def);

}

Sample output:

Team 1

Hummels.

Boateng.

Ginter.

Hector.

Team 2

Suele.

Ruediger.

Schulz.

Kimmich.