0

好吧，我在问自己是否有办法直接在参数中传递向量，我的意思是，像这样：

int xPOS = 5, yPOS = 6, zPOS = 2;
//^this is actually a struct but 
//I simplified the code to this

std::vector <std::vector<int>>  NodePoints;
NodePoints.push_back(
    std::vector<int> {xPOS,yPOS,zPOS}
);

该代码当然会出错；不允许使用类型名，并且需要一个 ')'

我会使用一个结构，但我必须将数据传递给一个抽象虚拟机，我需要在其中访问节点位置，Array[index][index]如下所示：

public GPS_WhenRouteIsCalculated(...)
{
    for(new i = 0; i < amount_of_nodes; ++i)
    {
        printf("Point(%d)=NodeID(%d), Position(X;Y;Z):{%f;%f;%f}",i,node_id_array[i],NodePosition[i][0],NodePosition[i][1],NodePosition[i][2]); 
    }
    return 1;
}

当然我可以这样做：

std::vector <std::vector<int>>  NodePoints;//global
std::vector<int> x;//local
x.push_back(xPOS);
x.push_back(yPOS);
x.push_back(zPOS);
NodePoints.push_back(x);

或这个：

std::vector <std::vector<int>>  NodePoints;//global
std::vector<int> x;//global
x.push_back(xPOS);
x.push_back(yPOS);
x.push_back(zPOS);
NodePoints.push_back(x);
x.clear()

但后来我想知道两者中哪一个会更快/更高效/更好？或者有没有办法让我的初始代码工作（第一个片段）？

4

3 回答 3

2

使用 C++11 或来自 boost 的东西（你也可以使用 simple v.push_back({1,2,3})，vector 将从 initializer_list 构造）。

http://liveworkspace.org/code/m4kRJ $0

如果你没有 C++11，你也可以使用 boost::assign。

#include <vector>
#include <boost/assign/list_of.hpp>

using namespace boost::assign;

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

http://liveworkspace.org/code/m4kRJ 5 美元

当然你可以使用旧变种

int ptr[1,2,3];
v.push_back(std::vector<int>(ptr, ptr + sizeof(ptr) / sizeof(*ptr));
于 2013-01-25T09:54:59.190 回答
1

如果您的主要目标是避免不必要的副本，vector<>那么您应该如何处理它。

C++03

将一个空向量插入嵌套向量（例如Nodepoints），然后在其上使用std::swap()or std::vector::swap()。

NodePoints.push_back(std::vector<int>());  // add an empty vector
std::swap(x, NodePoints.back()); // swaps contents of `x` and last element of `NodePoints`

所以在 之后swap()， 的内容x将被转移到NodePoints.back()没有任何复制。

C++11

用于std::move()避免额外的副本

NodePoints.push_back(std::move(x));  // #include<utility>

这里是解释，std::move这里是一个例子。

上述两种解决方案的效果都有些相似。

于 2013-01-25T10:48:42.223 回答
1

如果您无法访问 Boost 或 C++11，那么您可以考虑一个非常简单的基于类的解决方案。通过使用一些简单的访问控制包装一个向量以将您的三个点存储在一个类中，您可以创建所需的灵活性。首先创建类：

class NodePoint
{
public:
    NodePoint( int a, int b, int c )
    {
        dim_.push_back( a );
        dim_.push_back( b );
        dim_.push_back( c );
    }

    int& operator[]( size_t i ){ return dim_[i]; }

private:
    vector<int> dim_;
};

这里重要的是将向量封装为对象的聚合。NodePoint只能通过提供三个点来初始化。我还提供operator[]了允许对对象进行索引访问。它可以按如下方式使用：

NodePoint a(5, 6, 2);
cout << a[0] << " " << a[1] << " " << a[2] << endl;

哪个打印：

5 6 2

请注意，如果尝试访问越界索引点，这当然会抛出，但这仍然比最有可能出现段错误的固定数组好。我不认为这是一个完美的解决方案，但它应该能让你合理安全地到达你想去的地方。

于 2013-01-25T10:27:55.740 回答