类和成员变量

发布于 2024-10-10 12:55:35 字数 522 浏览 3 评论 0原文

假设我有一个名为 myList 的容器类。这个容器类有一个名为capacity的私有成员变量，它保存实例中值的数量。

对于该类的用户来说，访问容量可能是有益的，例如，在循环遍历每个值时知道他们何时到达末尾。因此，容量应该是公开的。

然而，这也将允许该类的用户修改容量，这显然会把事情搞砸。

myList myInstance;
myInstance.capacity = 123;

如果公共成员函数只返回capacity的值（这是一个私有变量），这会被认为是不好的做法吗？例如：

unsigned int getCapacity()
{
    return capacity;
}

每当 capacity 的值发生变化时，“克隆”变量就会更新为 capacity 的值，这又如何呢？该类的用户将访问公共“克隆”而不是私有变量本身。

原文

Let's say I have a container class called myList. This container class has a private member variable called capacity that holds the number of values in the instance.

It might be beneficial for users of the class to have access to capacity for, say, knowing when they've reached the end while going through each value in a loop. Therefore, capacity should be public.

However, that would also allow users of the class to modify capacity, which would obviously screw things up.

myList myInstance;
myInstance.capacity = 123;

Would it be considered bad practice to have a public member function that just returns the value of capacity, which would be a private variable? For example:

unsigned int getCapacity()
{
    return capacity;
}

What about a "clone" variable that's updated to the value of capacity whenever the value of capacity changes? Users of the class would access the public "clone" rather than the private variable itself.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

等风来 2024-10-17 12:55:35

有一个容量吸气剂。
但将其标记为 const 成员：

unsigned int getCapacity()  const
{                        //^^^^^^^ 
    return capacity;
}

第二种解决方案不起作用。
因为它不可靠（一个用户可能会更新它，然后下一个用户在读取它时会得到无效值）。

不过您应该考虑您班级的用户是否确实需要此信息。
他们能用它做什么？

如果容量不够，你想预先分配内存吗？

MyList   x;
// I am going to add 10 items make sure there is enough room.
if (x.size() + 10 < x.capacity())
{    x.resize(x.size() + 10);
}

在这种情况下，只需重新调整大小即可。然后，如果容器已经有空间，则不执行任何操作。

x.resize(x.size() + 10);  // If the container has enough space do nothing. 
                          // Otherwise make sure there is enough room for 10 more items.

通常，对象最好管理它自己，而不是提供对其内部状态的访问以允许其他对象间接管理它。即使您将实现与实际变量解耦，您仍然将自己耦合到具有容量的接口，并且它并没有真正为您提供有意义的好处。

因此，方法（通常）应该是对对象执行操作的操作（动词）。这些动作操纵对象的状态。让操作成为对象的接口。请注意，一旦定义了对象的接口，更改该接口（删除功能）就非常困难。

Have a capacity getter.
But mark it as a const member:

unsigned int getCapacity()  const
{                        //^^^^^^^ 
    return capacity;
}

The second solution does not work.
As it is not reliable (one user may update it then the next user would get an invalid value when they read it).

Though you should consider if the user of your class really neads this information.
What can they do with it?

So you want to pre-allocate memeory if the capacity is not enough?

MyList   x;
// I am going to add 10 items make sure there is enough room.
if (x.size() + 10 < x.capacity())
{    x.resize(x.size() + 10);
}

In this situation just always re-size. Then make your container do nothing if it aleady has the space.

x.resize(x.size() + 10);  // If the container has enough space do nothing. 
                          // Otherwise make sure there is enough room for 10 more items.

It is usually better for an object to manage it's self, rather than provide access to its internal state to allow other objects to manage it indirectly. Even though you are de-coupling the implementation from the actual variable you are still coupling yourself to the interface of having a capacity and it does not really provide you with a meaningful benefit.

So methods should (generally) be actions (verbs) that perform actions on the object. These actions manipulate the state of the object. Let the actions be the interface to your object. Note that once you define the interface to an object changing that interface (removing functionality) is very hard.

回复收藏 0 原文