如何实现自己的函数到 std::vector？

Question

我想添加一个将 .size() 值作为整数而不是无符号整数返回的函数。

编辑：由于cmets，我解释的更详细：

我有代码：

int something = 3;
if(arr.size() > something) 

这会产生编译器警告，我不喜欢将 (int) 添加到我拥有它的每个地方。 所以，我认为有一个 sizei() 函数会很好的解决方案：

int something = 3;
if(arr.sizei() > something) 

不会产生警告。

所以，我不想创建一个单独的函数，而是在 std::vector 本身中创建一个函数。

编辑：似乎唯一的方法是创建另一个函数，例如：

template <typename T>
inline int sizei(const T &arr){
    return (int)arr.size();
}

积极的一面：这似乎根本不会增加我的可执行文件大小。

Answer 1

首先，您为什么要这样做？我没有看到任何理由或优势：

无论如何，你可以这样做：

template<typename T>
int size(const std::vector<T> &v) { return (int) v.size(); }

//use
std::vector<int> ints;
//...
int count = size(ints);

我仍然认为这样做没有任何意义。你可以简单地写：

int count = (int) ints.size(); 

但我仍然会说它并不比以下更好：

size_t count = ints.size(); //don't prefer anything over this. Always use size_t

建议：避免使用int 作为大小。首选size_t。

---

至于您问题中的编辑。为什么不使用size_t 作为：

size_t something = 3;
if(arr.size() > something) 

没有警告。在我看来，如果您在整个程序中始终如一地选择数据类型，您就不会遇到将 int 与定义为 unsigned 整数类型的 size_t 进行比较的情况.

或者，如果您必须使用一些遗留代码，并且使用 int 来确定大小，那么我认为在需要时使用显式转换更好，而不是在框架本身中添加函数，这隐藏了潜在的问题：

int something = /*some legacy code API call or something */;
if(arr.size() > (size_t) something) 

//or even better;
size_t something = (size_t) /*some legacy code API call or something */;
if(arr.size() > something) 

Answer 2

通常，在 C 和 C++ 中，您永远不应该使用诸如 size_t 之类的无符号类型来限制域。这是因为 (1) 这些语言不提供范围检查，并且 (2) 它们确实提供了不合理的隐式提升。没有范围检查意味着 (1) 没有优势，不合理的隐式促销意味着 (2) 非常不利的劣势，所以这样做很愚蠢：没有优势，非常不利的劣势。

但是，这些语言的标准库可以做到这一点。他们这样做只是出于历史原因，不可逆转地陷入了曾经有意义的早期决策中。这会产生极其愚蠢的后果，例如 C99 需要 17 (!) 位来表示 ptrdiff_t，并且会产生上述极其不良的后果，例如花费大量时间来寻找由隐式提升（等）导致的错误。例如，在 C++ 中，您实际上可以保证 std::string( "bah!" ).length() < -5 - 这很容易让您绊倒，而且无论如何设计都是愚蠢的。

现在，你不能在std::vector 中注入新的成员函数，但你可以添加一个独立的函数。一个好名字是countOf。将其模板化，以便它可以应用于几乎任何东西（原始数组、向量等）。

据我所知，startOf、endOf 和 countOf 三个函数是由 Dietmar Kuehl 首次确定的。 C++0x 将有 std::begin 和 std::end，但 AFAIK 没有对应的 std::size。同时，您可以定义这种支持，它允许您将任何类型的容器和原始数组一视同仁。

my blog 提供了示例实现和进一步讨论。

---

编辑添加一些代码，因为它是在 cmets 中请求的。

检测合适的迭代器类型：

template< typename Type >
struct It
{
    typedef typename Type::iterator T;
};

template< typename Type >
struct It< Type const >
{
    typedef typename Type::const_iterator T;
};

template< typename ElemType, Size N >
struct It< ElemType[N] >
{
    typedef ElemType* T;
};

还有countOf、startOf 和endOf 函数，使用推导的迭代器类型：

template< typename T >
inline Size countOf( T const& c )           { return static_cast<Size>( c.size() ); }

template< typename T, Size N >
inline Size countOf( T (&)[N] )             { return N; }

template< typename T >
inline typename It<T>::T startOf( T& c )    { return c.begin(); }

template< typename T, Size N >
inline T* startOf( T (&a)[N] )              { return a; }

template< typename T >
inline typename It<T>::T endOf( T& c )      { return c.end(); }

template< typename T, Size N >
inline T* endOf( T (&a)[N] )                { return a + N; }

其中Size 是ptrdiff_t 的类型定义。

注意：在 64 位 Windows 中，int（甚至long）是 32 位的。因此，int 通常不足以用于非常大的数组。 ptrdiff_t 保证能够表示任意两个指针之间的差异，前提是该差异已明确定义。

---

干杯&hth。

Answer 3

你可以从向量中导出如下：

template<typename T>
class my_vector : public vector<T>
{
  // missing constructors!

  int size() const
  {
    if (vector<T>::size() > INT_MAX)
      throw std::range_error("too many elements in vector");
    return (int) vector<T>::size();
  }
};

缺点是您必须自己定义和转发构造函数。

Answer 4

我倾向于使用显式转换为 int 而不是函数：static_cast<int> (v.size())。更好的办法是在处理内存大小时始终使用size_t。例如，支持for (size_t i=0; i < v.size(); ++i) 而不是for (int i=0; i < (int) v.size(); ++i)。为工作使用正确的类型。您不应该将 std::vector 大小与有符号类型进行比较。

请参阅以下参考资料，了解为什么您应该更喜欢 size_t 而不是 int：

• Using size_t appropriately can improve the portability, efficiency, or readability of your code. Maybe even all three.
• unsigned int vs. size_t
• Is it good practice to use size_t in C++?
• When should I use std::size_t?

Answer 5

.size() 的快速答案是：不。对于向量，可能是它的存储值和分配方法（默认new/delete，通常不会被覆盖）以及使用InputIterator 的方法。

大多数人会问你为什么想要一个不同的size_t。如果只是烦人的警告，您可以强制转换或使用无符号整数来迭代/检查 size()。 （如果代码很多，您将不得不查找/替换）...如果它正在处理空条件，您可以将向量包装在一个具有一些智能的类中。顺便说一句，由于我不知道您手头的问题，因此寻找想法和已实现功能的好地方是 std 库的算法，例如 sort、for_each、find 等等。

std算法见：http://www.sgi.com/tech/stl/table_of_contents.html

Answer 6

虽然我认为@Nawaz 提供了最合适的答案，但如果您真的想向 std::vector 添加一个额外的成员，那是不可能的。 @zvrba 提供了唯一可以完成的方法，但正如 cmets 中所述，std 容器类型没有虚拟析构函数，因此不打算从中继承。

但是，您可以使用容器适配器实现一种新型矢量，如下所示：

template <class T>
class my_vector
{
public:
   int size_i() const
   {
      return static_cast<int>(container_.size());
   }

private:
   std::vector<T> container_;
};

这里的缺点是您必须显式公开您实际需要支持的容器的功能。如果您在整个代码中通常使用“std::vector”，这可能是一个重大变化。有关容器适配器的实现示例，请参见“std::queue”。