std::size_t与size_type作为参数和函数返回类型

Question

假设我有这个代码。哪种方法更好？

// Method 1
std::size_t size()
{
// m_myVector is of type std::vector<MyClass*> in all examples
return m_myVector.size();
}
// Method 2
std::vector<MyClass*>::size_type size()
{
// m_myVector is of type std::vector<MyClass*> in all examples
return m_myVector.size();
}

第一种方法在99%的情况下都有效，但当然也有可能矢量的大小不是std::size_t类型。也就是说，我们可以仅仅依靠软件分析工具来告诉我们向量大小的返回类型已经改变。

第二种方式向调用方公开向量的实现细节。这会破坏封装吗？我不知道，你告诉我！

这是另一个更复杂的例子。哪种方法更好？

void doFoo(const SomeClass& someObject)
{
// These could be ints or size_types... Feel free to use your imagination
std::size_t firstCount = someObject.getFirstCount();
for (std::size_t i = 0U; i < firstCount; ++i)
{
foo(firstCount);
}
}
void doFoo2(const SomeClass& someObject)
{
// I thought I'd provide another example to help your imagination :)
std::vector<MyClass*>::size_type secondCount = someObject.getSecondCount();
for (std::vector<MyClass*>::size_type i = 0U; i < secondCount; ++i)
{
foo(secondCount);
}
}
void doFoo3(const SomeClass& someObject)
{
// The correct styling would be: NotMyClass*
// But I really wanted to emphasize this was different from above, so I ALL CAPPED IT
std::vector<NOTMYCLASS*>::size_type thirdCount = someObject.getThirdCount();
for (std::vector<NOTMYCLASS*>::size_type i = 0U; i < thirdCount; ++i)
{
foo(thirdCount);
}
}
// Method 1
void foo(std::size_t index)
{
// m_myVector is of type std::vector<MyClass*> in all examples
m_myVector.at(index)->doLotsOfStuff();
}
// Method 2
void foo(std::vector<MyClass*>::size_type index)
{
// m_myVector is of type std::vector<MyClass*> in all examples
m_myVector.at(index)->doLotsOfStuff();
}

好吧，这是一个很长的例子，所以我将解释发生了什么。doFoo()、doFoo2()和doFoo3()都调用foo()，在第一个实现中接受std::size_t，在第二个实现中接收std::vector<MyClass*>::size_type。

doFoo()正在将std::size_t传递给foo()，因此foo()的第一个实现在这里更有意义，但随后我们对期望std::vector<MyClass*>::size_type的std::vector<MyClass*>进行索引。如果CCD_ 14没有被定义为CCD_。

doFoo2()将std::vector<MyClass*>::size_type传递给foo()，因此foo()的第二个实现在这里工作得非常好。除了向调用者公开私有向量的实现细节之外，没有其他抱怨。最后，我想我们需要为MyClass包含一个单独的头。

CCD_ 21正在从CCD_ 22传递到CCD_ 23。。。foo()的两个实现都没有预料到这一点，因为foo()关心的唯一向量是包含MyClass*类型元素的向量。现在，作为一个学术问题，std::vector<NOTMYCLASS*>::size_type总是和std::vector<MyClass*>::size_type一样吗？事实上，我不知道这个问题的答案，但我一直听到"是"one_answers"否"。最后，再次出现封装问题(如果这是一个问题的话(。

不管怎样，谢谢你对我的宽容。有什么想法吗？

Answer 1

，但向量的大小当然不可能是std:：size_t 类型

在这种情况下，这种机会实际上并不存在，因为std::vector<MyClass*>::size_type是(间接保证并要求是(std::size_t类型的。在这种情况下，使用std::size_t是很好的，它不会泄露不必要的实现细节。

---

在标准容器的情况下，Container::size_type是直接根据使用的分配器来定义的。因此，通常只有当分配器类型或容器类型本身被模板化时，才需要使用size_type。在分配器的情况下，可以使用分配器特征而不是容器成员类型，这样可以隐藏容器类型。如果容器类型本身是模板化的，那么隐藏它是没有意义的，因为只有了解容器的人才能首先实例化模板。

此外，您可以通过创建一个类型别名成员来隐藏——或者更确切地说是模糊(以一种积极的封装方式(——函数声明，就像std::vector有一个基于其分配器的类型别名成员一样。

示例：

template<class Alloc>
class Foo
{
// could be hidden with PIMPL if desired
std::vector<MyClass*, Alloc> m_myVector;
public:
// Since C++11
using size_type = typename std::allocator_traits<Alloc>::size_type;
// Prior to C++11
typedef typename Alloc::size_type size_type;

size_type size();
};

Answer 2

std::size_t是一种能够容纳任何数组大小的类型，包括通过分配器分配的数组。

这意味着std::size_t将始终能够存储std::vector<T>::size()的结果，因此方法1永远不会导致溢出，并且是完全可读的。

不能保证std::vector<T>::size_type对所有T都是相同的，但您很难找到std::vector的实现，其中size_type并不总是std::size_t。