C++ 什么是更好的实践？通过指针或标识符传递类成员？

假设我有一个类，我想要另一个类或函数来读取它的成员。（例如，用户界面读取球员的分数和其他内容。）

比方说，在很长一段时间内，我经常遇到这种情况，有很多不同的变量

我，A，是否通过指向另一个类的指针传递它，以便它可以从内存中读取

class VariableReader {
public:
    int* read;
    void GiveYourVariableToMe(int* var) {
        read = var; // keep accessing the variable with this "read" member
    };
};

或者I，B，创建一个对象数组和一个对象标识符供其使用

std::map<std::string, int> VariablesToRead;

class VariableReader {
public:
    std::string identity;
    void GiveYourVariableToMe(std::string Identifier) {
        VariablesToRead[identity]; // keep accessing this variable with the through the map
    };
};

我创建了一组文本对象，更新后，这些文本对象会显示分配给它们的变量

void Game() {
    TextObject obj1; // displays var1 when updated
    TextObject obj2; // displays var2 when updated
    TextObject obj3; // displays var3 when updated
    TextObject obj4; // displays var4 when updated
    TextObject obj5; // displays var5 when updated
    // ...
}

---

我不确定我是否理解您的问题，但我认为您要做的是将一个类的实例传递给另一个类

class Player
{
public:

  // your "variables"
  int32_t Score() {.. }
};

class UI
{
public:
  void ShowScores(const Player& player)
  {
    std::cout << player.Score(); 
  }

};

职业玩家
{
公众：
//你的“变量”
int32_t Score（）{..}
};
类用户界面
{
公众：
无效显示分数（常量玩家和玩家）
{
std：：cout我不确定我是否理解您的问题，但我认为您要做的是将一个类的实例传递给另一个类

class Player
{
public:

  // your "variables"
  int32_t Score() {.. }
};

class UI
{
public:
  void ShowScores(const Player& player)
  {
    std::cout << player.Score(); 
  }

};

职业玩家
{
公众：
//你的“变量”
int32_t Score（）{..}
};
类用户界面
{
公众：
无效显示分数（常量玩家和玩家）
{
std:：cout通常，您希望避免这两种情况中的任何一种。如果另一个类，例如某个类X，需要读取类B拥有或已知的某个对象的值，通常您提供提供提供该值的B的某个成员函数，其名称为
GetFoo
。例如，X中的某个函数XF将具有ty的对象
B
pe
B
。可能是通过引用传递的，或者X中的函数构造了它，不管怎样。要从
B
获取
Foo
的值，XF将使用
B.GetFoo（）
。
GetFoo
函数如下所示：

class B
{
private:
    Some declaration of Foo;
…
public:
    TypeOfFoo GetFoo() { return Foo; }
};

这比在
b
中为XF提供指向
Foo
的指针更可取，因为这意味着类b可以自由更改其管理
Foo
的方式
Foo
可以是一个地址不时更改的动态分配对象，也可以是一个计算而不是直接存储的值如果有一个指向
Foo
的指针，那么B的实现就不能改变，因此
Foo
是一种不同的类型，或者以不同的方式进行管理，除非X中的所有代码和
Foo
的其他用法都发生了改变。通常，您希望避免B之外的任何类拥有关于B内部内容的大量信息。它们不应该知道e B内部数据的类型或位置

假设您已经决定类X必须有某种方式访问
Foo
，那么让它有一个指向
常量
Foo
的指针可能比您建议的
映射
和
字符串
版本要好。这会导致运行时查找名称，如果名称是编译时就知道了。即使如此，当
const
指向
Foo
的指针可用时，您需要仔细记录类的义务和行为。一旦
b
对象允许其他类有指向
Foo
的指针，
b
就不能让
Foo
的地址更改，and
b
除非指向其
Foo
的指针持有者使用它，否则不得销毁。此类联锁关系容易出错，应避免

坚持在B中给X一个
GetFoo（）
函数，直到你有了非常的理由去做一些不同的事情。如果你需要从多个要获得的值中进行选择，那么
GetFoo（标识符）
是可以的，其中
标识符
是整数或
枚举
，并且
GetFoo
在数组中查找对象。
通常，您希望避免这两种情况中的任何一种。如果另一个类，例如某个类X，需要读取类B拥有或已知的某个对象的值，通常您提供B的某个成员函数使用诸如
GetFoo
之类的名称提供值。例如，X中的某些函数XF将具有类型为
b
的对象
b
。它可能是通过引用传递的，或者是X中的函数构造的。为了从
b
获取
Foo
的值，XF将使用
b.GetFoo（）
。
GetFoo
函数如下所示：

class B
{
private:
    Some declaration of Foo;
…
public:
    TypeOfFoo GetFoo() { return Foo; }
};

这比在
b
中为XF提供指向
Foo
的指针更可取，因为这意味着类b可以自由更改其管理
Foo
的方式
Foo
可以是一个地址不时更改的动态分配对象，也可以是一个计算而不是直接存储的值如果有一个指向
Foo
的指针，那么B的实现就不能改变，因此
Foo
是一种不同的类型，或者以不同的方式进行管理，除非X中的所有代码和
Foo
的其他用法都发生了改变。通常，您希望避免B之外的任何类拥有关于B内部内容的大量信息。它们不应该知道e B内部数据的类型或位置

假设您已经决定类X必须有某种方式访问
Foo
，那么让它有一个指向
常量
Foo
的指针可能比您建议的
映射
和
字符串
版本要好。这会导致运行时查找名称，如果名称是编译时就知道了。即使如此，当
const
指向
Foo
的指针可用时，您需要仔细记录类的义务和行为。一旦
b
对象允许其他类有指向
Foo
的指针，
b
就不能让
Foo
的地址更改，and
b
除非指向其
Foo
的指针持有者使用它，否则不得销毁。这种连锁关系容易出错