Question

我有一个班级：

class Cave 
{
private:
    int no_of_rooms;

public:
    vector<int>rooms;
    Cave(int r);
    Cave(){};
};

Cave的构造函数用随机整数填充向量室：

Cave::Cave(int r)
    :no_of_rooms{ r }
{
    int i = 0;
    while (i<no_of_rooms)
    {
        rooms.push_back(randint(1, no_of_rooms));
        ++i;
    }   
}

我创建了另一个类：

class Player : public Cave
{
public:
    Player(int *plyr) 
        :p_ptr{ plyr }
    { 
        plyr = &rooms[0];
    }

private:
    int* p_ptr = nullptr;

};

这个玩家类似乎很乱。我正试图访问由Cave构造函数填充的相同房间向量。

Answer 1

您可能有拼写错误：

plyr = &rooms[0];

这设置了函数参数，而不是成员。

您的意思是p_ptr = &rooms[0];？

但是为什么要有一个函数参数呢？这毫无意义。

不幸的是，您没有告诉我们您想要做什么，或者您希望这些类做什么，或者您需要向类提供什么输入。所以我不能再回答了。

Answer 2

我认为你真的应该封装Cave而不是继承它。试试这个。

cave.h

#include <vector>
#include <random>

class Cave 
{
private:
    int no_of_rooms;

public:
    std::vector<int>rooms;
    Cave(int r);
    Cave(){};
};

inline int randint(int min, int max) 
{
    std::random_device device;
    std::mt19937 engine(device());
    std::uniform_int_distribution<int> dist(min, max);
    return dist(engine);
}

cave.cpp

#include "cave.h"

Cave::Cave(int r)
    :no_of_rooms{ r }
{
    int i = 0;
    while (i<no_of_rooms)
    {
        rooms.push_back(randint(1, no_of_rooms));
        ++i;
    }   
}

player.h

#include "cave.h"

class Player// : public Cave
{
public:
    Player(int *plyr) 
        :p_ptr{ plyr }
    { 
        cave = Cave(*plyr);
        plyr = &cave.rooms[0];
    }

private:
    Cave cave;
    int* p_ptr = nullptr;

};

我用

尝试了

#include "player.h"

int main(int argc, char* argv[])
{
    int player_count = 2;
    Player p(&player_count);
}

另外，我不确定在你的某些代码中不必要地使用指针。

如何在另一个类构造函数中使用一个类的成员

2 个答案: