Question

我有一个包含对象的向量：

    public class Product
    {
        public virtual Guid Id { get; set; }
        public virtual string Name { get; set; }
        public virtual string Type { get; set; }
    }

    public class ProductFull : Product
    {
        public override Guid Id { get; set; }
        public override string Name { get; set; }
        public override string Type { get; set; }

        public List<Item1> Item1s { get; set; }

        public List<Item2> Item2s { get; set; }
    }

    public class Item1
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
    }

    public class Item2
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
    }

std::vector<myObjectType> myObjectVector;包含一个名为myObjectType的双成员变量，我可以通过两种方式检索它：

value

现在我可以将myObjectType aObject; double aObjectDouble = aObject(); // possibility 1 (overloaded operator) double aObjectDouble = aObject.get_value(); // possibility 2转换为std::vector<myObjectType> myObjectVector，其中std::vector<double> myObjectVectorDoubles包含每个对象的双精度值，如下所示：

std::vector<double>

或者就是这样

std::vector<double> myObjectVectorDoubles;
myObjectVectorDoubles.push_back(myObjectVector[0].get_value());
myObjectVectorDoubles.push_back(myObjectVector[1].get_value());
...
...

我可以把它放在for循环中，但这是最干净（或最有效）的解决方案吗？

Answer 1

您可以使用std::transform。例如，如果您有class

class Foo {
  double val;
public:
  Foo() = default;
  Foo(double const val_) : val(val_) {}
  double getVal() const { return val; }
};

在你的程序中执行：

std::vector<Foo> v {{1.2}, {2.3}, {5.6}};  
std::vector<double> dv(v.size());
std::transform(v.begin(), v.end(), dv.begin(), [](auto const &f) { return f.getVal(); });

Live Demo

如果您的编译器不支持C ++ 14，则通用lambdas更改为：

std::transform(v.begin(), v.end(), dv.begin(), [](Foo const &f) { return f.getVal(); });

Answer 2

试试这个，但是你的对象：

std::vector<int> ivec({1,2,3,4,5,6,7,8,9});
std::vector<double> dvec;
for(auto&& x : ivec)
    dvec.push_back(double(x));

所以在你的情况下：

std::vector<myObjectType> myObjectVector {...}
std::vector<double> myDoubleVector;
for(auto&& x : myObjectVector)
        myDoubleVector.push_back(x.get_value());

Answer 3

我知道这不是你要求的，但我自己做了一个小实验：

#include <iostream>
#include <vector>

class Foo {
public:
    double value;

    Foo(double v) :
        value{ v } {}

    operator double() {
        return value;
    }
};

int main(int argc, char* argv[]) {
    std::vector<Foo> foos{ 1.0, 3.0, 4.0, 7.0 };
    for(double d : foos) {
        std::cout << d << ", ";
    }
}

它有效。我不了解你的情况，但正如我上面所示，你甚至可能不需要将你的对象矢量转换成双向量。

C ++将包含对象的向量转换为包含双精度的向量

3 个答案: