NxN queen

#include <iostream>
#include <vector>

using namespace std;
const int BSIZE = 8;
char chessBoard[BSIZE][BSIZE];

struct qPos
{
    qPos() : h(0), v(0), found(true) {}
    int h; //horizontal pos
    int v; //vertical pos
    bool found; //if position is available
};

qPos findNextQPos(vector<qPos> Qs);
void fillBoard(vector<qPos> Qs);
void print();
vector<qPos> generateDisallowed(vector<qPos> Qs);
bool isDisallowed(qPos nextPos, vector<qPos> disallowedPos);

int main(int argc, char **argv[]){
    vector<qPos> QsOnBoard; //Position of all the queens on board
    qPos nextQ; //next possible position
    while (nextQ.found)
    {
        nextQ = findNextQPos(QsOnBoard);
        if (nextQ.found)
        {
            QsOnBoard.push_back(nextQ); //If the nextQ is available i.e. not disallowed, add it to the queens vector
        }
    }
    fillBoard(QsOnBoard); //Fill the board with queens positions
    print(); // print the board
    return 0;
}

qPos findNextQPos(vector<qPos> Qs) {
    // Generate disallowed positions based on all the queens on board
    vector <qPos> disallowedPos = generateDisallowed(Qs);
    qPos nextQ;
    for (size_t i = 0; i < BSIZE; i++)
    {
        for (size_t j = 0; j < BSIZE; j++)
        {
            nextQ.h = i;
            nextQ.v = j;
            if (!isDisallowed(nextQ, disallowedPos)) { //Check if next possible position is a disallowed position
                //cout << "Next available:\n" << nextQ.h << ", " << nextQ.v << endl;
                return nextQ; // if it is avaible return the position, break the loop
            }
        }
    }
    nextQ.found = false; // No available position is found to return, found is set to false, return the position
    return nextQ;
}

/**
*   Generate a vector of positions which are not allowed based on
*   a set of Queens on board
**/
vector<qPos> generateDisallowed(vector<qPos> Qs) {
    vector <qPos> disallowedPos;
    qPos tmpPos;
    // Loop through all the queens positions on board
    for (size_t i = 0; i < Qs.size(); i++)
    {
        // The queen positions is not allowed for next position
        disallowedPos.push_back(Qs.at(i));
        // All the positions with the same horizontal position are disallowed
        tmpPos.h = Qs.at(i).h;
        for (size_t k = 0; k < BSIZE; k++)
        {
            tmpPos.v = k;
            disallowedPos.push_back(tmpPos);
        }
        // All the positions with the same vertical position are disallowed
        tmpPos.v = Qs.at(i).v;
        for (size_t k = 0; k < BSIZE; k++)
        {
            tmpPos.h = k;
            disallowedPos.push_back(tmpPos);
        }
        for (size_t k = 0; k < Qs.at(i).h + Qs.at(i).v; k++)
        {
            tmpPos.h = 0 + k;
            tmpPos.v = Qs.at(i).h + Qs.at(i).v - k;
            disallowedPos.push_back(tmpPos);
        }
        // Diagonal positions are disallowed
        //Sweep forwards, adding higher cells to diag1 and lower cells
        for (int k = 1; Qs.at(i).h + k < BSIZE; k++) {
            if (Qs.at(i).v - k >= 0) {
                tmpPos.h = Qs.at(i).h + k;
                tmpPos.v = Qs.at(i).v - k;
                disallowedPos.push_back(tmpPos);
            }
            if (Qs.at(i).v + k < BSIZE) {
                tmpPos.h = Qs.at(i).h + k;
                tmpPos.v = Qs.at(i).v + k;
                disallowedPos.push_back(tmpPos);
            }
        }
        //Sweep backwards, adding higher cells to diag2 and lower cells to diag1
        for (int k = 1; Qs.at(i).h - k >= 0; k++) {
            if (Qs.at(i).v - k >= 0) {
                tmpPos.h = Qs.at(i).h - k;
                tmpPos.v = Qs.at(i).v - k;
                disallowedPos.push_back(tmpPos);
            }
            if (Qs.at(i).v + k < BSIZE) {
                tmpPos.h = Qs.at(i).h - k;
                tmpPos.v = Qs.at(i).v + k;
                disallowedPos.push_back(tmpPos);
            }
        }
    }
    return disallowedPos;
}

/**
*   check if the nextpos is disallowed
**/
bool isDisallowed(qPos nextPos, vector<qPos> disallowedPos) {
    for (size_t i = 0; i < disallowedPos.size(); i++)
    {
        if (disallowedPos.at(i).h == nextPos.h &&
            disallowedPos.at(i).v == nextPos.v)
        {
            return true;
        }
    }
    return false;
}

/**
*   Fill the board with _ and Q for empty and queen positions
**/
void fillBoard(vector<qPos> Qs) {
    for (size_t i = 0; i < BSIZE; i++)
    {
        for (size_t j = 0; j < BSIZE; j++)
        {
            chessBoard[i][j] = '_';
        }
    }
    for (size_t i = 0; i < Qs.size(); i++)
    {
        chessBoard[Qs.at(i).v][Qs.at(i).h] = 'Q';
    }
    vector <qPos> disallowedPos = generateDisallowed(Qs);
}

/**
*   Print the board on the command line
**/
void print() {
    cout << ' ';
    for (size_t i = 0; i < BSIZE; i++)
    {
        cout << ' ' << i;
    }
    cout << endl;
    for (size_t i = 0; i < BSIZE; i++)
    {
        cout << i << ' ';
        for (size_t j = 0; j < BSIZE; j++)
        {
            cout << chessBoard[i][j] << ' ';
        }
        cout << '\n';
    }
}