C ++使用find_first_not_of（char *）删除矢量元素

Question

I'm making a chess game and trying to add valid positions to a vector. The specific piece I'm working on is the knight, and some of the positions I've hardcoded are off the board, depending on the knight's position on the board. My coordinate system uses AH for rows and 0-8 for columns.

I have defined a character array of valid characters (AH and 0-8) and I'm using find_first_not_of to identify, and remove coordinate pairs that are invalid. For example:

Valid: A1

Invalid: ?3 - remove this

Question: Why is it that my function removes some coordinate pairs that are invalid and don't fit the pattern, but not others? For example, using position A2 as input, @4 and @0 are successfully removed. However the remaining available positions are C3, C1, B4, ?3, B0, ?1.

If the input is H2, then F3, F1, G0, G4 are available positions and J3, J1, I4, I0 are successfully removed, giving the desired result of only valid positions.

Problem: My output is correct some of the time and incorrect other times given the same method of removing invalid positions.

Parent class Piece.cpp:

char Piece::valids[16] = {
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
    '0', '1', '2', '3', '4', '5', '6', '7'
 };

void Piece::removeInvalids(vector<string>& v)
{
    for (short i = 0; i < v.size(); i++)
    {
        string s = v.at(i);
        size_t found = s.find_first_not_of(valids);
        if (found != string::npos)
        {
            cout << v.at(i) << endl;
            swap(v.at(i), v.back());
            v.pop_back();
        }
    }
}

Child class Knight.h:

vector<string> getAvailPositions(Piece **all)
{
    vector<string> v;
    stringstream ss;
    ss << static_cast<char>(position[0] + 2)
            << static_cast<char>(position[1] + 1);
    v.push_back(ss.str());
    stringstream ss2;
    ss2 << static_cast<char>(position[0] + 2)
            << static_cast<char>(position[1] - 1);
    v.push_back(ss2.str());
    stringstream ss3;
    ss3 << static_cast<char>(position[0] + 1)
            << static_cast<char>(position[1] + 2);
    v.push_back(ss3.str());
    stringstream ss4;
    ss4 << static_cast<char>(position[0] - 1)
            << static_cast<char>(position[1] + 2);
    v.push_back(ss4.str());
    stringstream ss5;
    ss5 << static_cast<char>(position[0] + 1)
            << static_cast<char>(position[1] - 2);
    v.push_back(ss5.str());
    stringstream ss6;
    ss6 << static_cast<char>(position[0] - 1)
            << static_cast<char>(position[1] - 2);
    v.push_back(ss6.str());
    stringstream ss7;
    ss7 << static_cast<char>(position[0] - 2)
            << static_cast<char>(position[1] - 1);
    v.push_back(ss7.str());
    stringstream ss8;
    ss8 << static_cast<char>(position[0] - 2)
            << static_cast<char>(position[1] + 1);
    v.push_back(ss8.str());
    removeInvalids(v);
    return v;
}

Please let me know if any changes to this post should be made for you to better assist me, thank you.

Answer 1

You should rethink your design--it's complicated and inefficient. How about this:

typedef std::array<char, 2> Position;

vector<Position> Knight::getAvailPositions() const
{
    vector<Position> v;
    v.reserve(8);
    for (char a : {2, -2}) {
        for (char b : {1, -1}) {
            v.emplace_back(position[0] + a, position[1] + b);
            v.emplace_back(position[0] + b, position[1] + a);
        }
    }
    removeInvalids(v);
    return v;
}

bool invalid(Position p)
{
    return p[0] < 'A' || p[0] > 'H' || p[1] < '0' || p[1] > '7';
}

void Piece::removeInvalids(vector<Position>& v)
{
    v.erase(std::remove_if(v.begin(), v.end(), invalid), v.end());
}

This avoids an absolute ton of dynamic memory allocations that were hiding inside all those strings & stringstreams. Now you have just one per getAvailPositions() call. Plus it's less code.

Answer 2

The reason it's only correct sometimes is because you're swapping the current vector element with the element at the end and then moving on to the next element. If the element at the end of the vector was invalid, you were just slipping an invalid into the middle of your vector and skipping it.

In your example, when it removes @4, it pulls ?3 into the middle of the vector and then moves on to looking at b0, without ever even questioning ?3. You will want to rework your logic of removing the element from the middle of the vector if you want to keep using the code the way you are now.

Although, as has been pointed out by other answers, there are more efficient ways of writing this code.

Answer 3

DR you are correct about my code, this seems to solve the problem by adding this one line:

void Piece::removeInvalids(vector<string>& v)
{
    for (short i = 0; i < v.size(); i++)
    {
        string s = v.at(i);
        size_t found = s.find_first_not_of(valids);
        if (found != string::npos)
        {
            cout << v.at(i) << endl;
            swap(v.at(i), v.back());
            v.pop_back();
            i = 0;
        }
    }
}

to make it restart the loop. I'm going to keep it this way for now because I have until June 2nd to finish this project and document it lol. I'm sure my teacher will explain as a learning experience to the class how awful it is, but we have not talked in much depth about performance yet, that will be the focus of the next course I take on C++. I can modify this program when I take CSC-17C and tune the performance.

Thank you all for your quick responses!