Question

我正在尝试将一个对象和一个类对象或两个对象的向量传递给两个名为checkPosition的重载模板函数。
无论我尝试什么，将我的功能改为传递值/ reference / pointer / const / not const，它都会给我错误;
错误：没有重载函数的实例“Room :: checkPosition”匹配参数列表
参数类型是：（const Player，const std :: vector＆lt; Monster，std :: allocator＆lt; Monster＆gt;＆gt;）
对象类型是：const Room。

来自Room.h：

class Room
{
    public:
        Player player;
        std::vector<Monster> monster;
        std::vector<Wall> wall;
        std::vector<Exit> exit;

        template<class T1> void xSet( T1 &object, const int &input );
        template<class T2> void ySet( T2 &object, const int &input );
        template<class T3> int x( T3 &object );
        template<class T4> int y( T4 &object );
        template<class T5> bool checkPosition( const T5 &object1, const T5 &object2 );
        template<class T6> bool checkPosition( const T6 &object1, const std::vector<T6> &object2 );
        void objectIconSet( );

        void lengthSet( const int &input );
        void widthSet( const int &input );
        int length( );
        int width( );
        void staticDataMap( );
        void completeDataMap( );
        char staticDataMap( int x, int y );
        char completeDataMap( int x, int y );

    private:
        int _length;
        int _width;
        std::vector< std::vector<char> > _staticDataMap;
        std::vector< std::vector<char> > _completeDataMap;
};

来自Room.cpp

template<class T5> bool Room::checkPosition( const T5 &object1, const T5 &object2 )
{
    if( object1.position.x == object2.position.x &&
        object1.position.y == object2.position.y )
    {
        return true
    }

    return false;
}
template<class T6> bool Room::checkPosition( const T6 &object1, const std::vector<T6> &object2 )
{
    for( int i = 0; i < object2.size( ); i++ )
    {
        if( object1.position.x == object2[i].position.x &&
            object1.position.y == object2[i].position.y )
        {
            return true
        }
    }

    return false;
}

main.cpp中函数使用的例子：

bool checkWinCondition( const Room &room )
{
    if( room.checkPosition( room.player, room.exit ) == true )
    {
        std::cout << "\nYou win!";
        return true;
    }

    return false;
}
bool checkLoseCondition( const Room &room )
{
    if( room.checkPosition( room.player, room.monster ) == true )
    {
        std::cout << "\nYou lose!";
        return true;
    }

    return false;
}

void SetRoomOuterWalls( Room &room )
{
    Position tempPosition;
    Wall tempWall;

    for( int y = 0; y < room.length( ); y++ )
    {
        for( int x = 0; x < room.width( ); x++ )
        {
            tempPosition.x = x;
            tempPosition.y = y;
            if( room.checkPosition( tempPosition, room.exit ) == true )
            {
                continue;
            }
            else if( x == 0 || x == room.width( ) - 1 ||
                     y == 0 || y == room.length( ) - 1 )
            {
                room.wall.push_back( tempWall );
                room.xSet( room.wall, x );
                room.xSet( room.wall, y );
            }
        }
    }
}

Answer 1

您使用两个不同的参数调用函数，但您的函数被模板化为一种类型

template<class T6> bool checkPosition( const T6 &object1, const std::vector<T6> &object2 );

表示您需要对象和相同类型的对象矢量。您正在传递函数player和vector<monster>不匹配的函数。您可以做的是将模板更改为：

template<class T, class Y> bool checkPosition( const T &object1, const std::vector<Y> &object2 );

这将允许您获取某个对象和相同类型或其他类型的矢量。

传递单个或矢量对象时没有重载函数的实例

1 个答案: