标签: stdvector

我正在使用gcc 4.6.假设有一个参数向量v我必须传递给一个可变函数f(const char*format,...).

这样做的一种方法是:

        void VectorToVarArgs(vector<int> &v)
        {
            switch(v.size())
            {
                case 1: f("%i",             v[0]);
                case 2: f("%i %i",          v[0], v[1]);
                case 3: f("%i %i %i",       v[0], v[1], v[2]);
                case 4: f("%i %i %i %i",    v[0], v[1], v[2], v[3]);

                // etc...
                default:
                    break;
            }
        }

        // where function f is
        void f(const char* format, ...)
        {
            va_list args;
            va_start (args, format);
            vprintf (format, args);
            va_end (args);
        }

问题当然是它不支持向量v中的任意数量的项.但是,我相信已经理解了va_lists原则上是如何工作的,即通过从最后一个命名的地址开始从栈中读取参数.在"..."之前的参数,现在我认为应该可以将向量项值复制到内存块(例如myMemBlock)并将其地址作为'format'之后的第二个参数传递.显然,这需要myMemBlock按f()的预期结构,即像堆栈一样.

1. 这样的事情可行吗？
2. 或者,是否可以使用一些内联汇编程序魔术推送实际堆栈上的向量项值,调用函数f()并在之后清理堆栈？

最后,我不关心的事情:

1. 代码可能不可移植.好的,我只对gcc感兴趣.
2. 可能还有其他涉及预处理器hackery的方法.
3. 对于C++,不鼓励使用variadic函数进行格式化,如printf().
4. 使用可变参数模板函数.

我相信自从C++ 11以来erase,大多数容器的功能(例如std::vector)接受一个const_iteratoras参数:

iterator erase (const_iterator position);

我的编译器(GCC 4.8和Clang 3.2,都使用GCC libstdc ++)仍然不允许我使用这样的功能,即使在编译时也是如此--std=c++11.

它是编译器/ libstdc ++错误,还是我做了坏事？这是一个示例代码:

#include <vector>

int main( )
{
    std::vector<int> v;
    v.push_back( 1 );
    v.push_back( 2 );
    v.push_back( 3 );

    std::vector<int>::const_iterator i = v.begin();
    while( i != v.end() ) {
        i = v.erase( i );
    }

    return 0;
}

模板类中的许多方法都vector接受value_type对象的const引用,例如:

void push_back (const value_type& val);

while 按值resize获取其value_type参数:

void resize (size_type n, value_type val = value_type());

作为一个非专业的C++程序员,我只能想到这个选择的缺点(例如,如果size_of(value_type)可能发生足够大的堆栈溢出).因此,我想对那些对语言有更深入了解的人提出这样的要求:

这个选择背后的设计理由是什么？

假设我的矢量/列表中有30000个对象.我逐一添加.
我需要他们排序.
是否更快地一次性排序(如std :: sort),或者在逐个添加对象时保持向量/列表的排序？

向量/列表以后不会被修改.

在下面的代码中,函数(foo)参数(std::vector)的大小可以是使函数成为通用函数的任何函数.但是,有时大小容器是已知的,因此可以使用std :: array.问题是转换std::array为std::vector.解决这个问题的最佳方法是什么？std::vector在这种情况下,总是使用总是更好吗？

#include <iostream>
#include <array>
#include <vector>

using namespace std;

// generic function: size of the container can be anything
void foo (vector<int>& vec)
{
    // do something
}

int main()
{
   array<int,3> arr; // size is known. why use std::vector?
   foo (arr); // cannot convert std::array to std::vector

   return 0;
}

我听说Modern C++的一个建议是使用emplace_back而不是push_back在容器中追加(emplace_back接受容器中任何类型存储的构造函数的任何版本的参数).

根据标准草案N3797 23.3.6.5(1),说:

备注:如果新大小大于旧容量,则会导致重新分配.如果没有重新分配,插入点之前的所有迭代器和引用仍然有效.如果除了复制构造函数之外抛出异常,移动构造函数,赋值运算符或T的移动赋值运算符,或者通过任何InputIterator操作都没有效果.如果非CopyInsertable T的移动构造函数抛出异常,则不指定效果.

这指定了在不需要重新分配时会发生什么,但在容器需要增长时保持打开问题.

在这段代码中:

#include <iostream>
#include <vector>

int main() {
    std::vector<unsigned char> buff {1, 2, 3, 4};
    buff.emplace_back(buff[0]);
    buff.push_back(buff[1]);
    for (const auto& c : buff) {
        std::cout << std::hex << static_cast<long>(c) << ", ";
    }
    std::cout << std::endl;
    return 0;
}

编译VC++(Visual Studio的2013更新4)和GCC 4.9.1(MinGW的)在调试在Windows 8.1.

使用VC++编译时,输出为:

1, 2, 3, 4, dd, 2

使用GCC编译时,输出为:

1, 2, 3, 4, 1, …

考虑第三方库中的一个自由函数,它需要一个std::vectoras参数:void foo( std::vector<sometype>& );

现在,我在这个类型周围编写一个包装器,这样我就可以添加成员函数了.为了能够使用foo()该类型,我添加了一个访问功能.

class Wrapper
{
   private:
      std::vector<sometype> _data;
   public:
       std::vector<sometype>& data() { return _data; }
       const std::vector<sometype>& data() const { return _data; }
       //... other stuff
};

这样,我仍然可以使用foo():

Wrapper a;
foo( a.data() );

但现在考虑另一个函数,它需要一个矢量向量sometype(编辑:并将元素添加到该向量中):

void bar( std::vector<std::vector<sometype>>& );

但我的数据类型是 std::vector<Wrapper> vec;

有没有办法使用我的包装类型来调用bar()？ 我想要做的是:

 std::vector<Wrapper> vec;
 bar( ??? );

我想避免的一点是先调用bar()所需的类型,然后逐个将元素复制到我的中vector<Wrapper>.

起初,我会说"不",但也许有一些聪明的解决方案？

编辑2:举个例子,考虑以下玩具实现bar()的introot数据类型:

void bar( std::vector<std::vector<int>>& vv …

我目前正在研究Vector如何在C++中工作.我已经很好地阅读并理解了他们的功能.

我正在寻找使用10,000 int排序矢量对象的不同方法,我使用了std :: sort方法和shell排序.

我注意到,向量的shell排序比排序简单的C样式数组要慢.我了解到这是因为"不支持在容器中间插入或移除快速元素"(http://www.cppreference.com/wiki/container/vector/start).所以很明显,一个包含大量随机访问的shell排序会很慢.

我想知道在任何人体验到一个更好的手动排序方法对于一个10,000 英寸的矢量？这是你看到的学习练习!:)

给定以下向量：

std::vector<int> foo{1,2,3,4,5,6,7};
std::vector<int> bar{10,20,30,40,50,60,70};

最后，我想foo包含{ 10, 2, 30, 4, 50, 6, 70 }表示替换所有奇数的值。

我已经尝试过 std::replace_if 算法，但是如何访问条形对应的值？

// replace_copy_if example
#include <iostream>     // std::cout
#include <algorithm>    // std::replace_copy_if
#include <vector>       // std::vector

bool IsOdd (int i) { return ((i%2)==1); }

int main () {
  std::vector<int> foo{1,2,3,4,5,6,7};
  std::vector<int> bar{10,20,30,40,50,60,70};

  std::replace_if (foo.begin(), foo.end(), IsOdd, 0);

  std::cout << "foo contains:";
  for (auto i: foo){ std::cout << ' ' << i; }
  std::cout << '\n';

  return 0;
}

// output …

我想将指向Object类的共享指针存储在向量中：

测试代码：

#include <vector>
#include <iostream>
#include <memory>

using namespace std;   // only for brevity

class Object
{
public:
  int n;
  Object(int n) : n(n) { cout << "Object("  << n <<")\n"; }
  ~Object() { cout << "~Object(" << n << "))\n"; n = 0xdddddddd; }

};

void Test()
{
  std::shared_ptr<Object> p1(make_shared<Object>(Object(123)));
  std::vector<shared_ptr<Object>> v;

  cout << "before push_back\n";
  v.push_back(std::make_shared<Object>(Object(2)));
  v.push_back(p1);
  cout << "after push_back\n";

  cout << "Vector content:\n";
  for (auto& p : v)
    cout << "  " << …