如何定义运算符以便将用户定义类型数组转换为基本类型数组？

Question

我给出以下代码来说明我的问题：

#include <vector>

struct Complex
{
     int a, b, c;

     Complex() : a(3), b(4), c(10) {}

     operator int() const {  return a+b+c; }
};

int main()
{
   Complex abc;
   int value = (abc);
   Complex def;
   def.a = 20;
   int value2 = (def);

   std::vector<Complex> ar;
   ar.push_back(abc);
   ar.push_back(def);

   std::vector<int> ar2;
   ar2.push_back(abc);
   ar2.push_back(def);

   std::vector<int> ar3;
   ar3 = (ar);
}

由于表达式 ar3 = (ar)，这将无法编译。我已经声明了一个转换运算符，以便 Complex class 可以用在需要 int 的地方。我是否也可以将 Complex 对象数组分配给 int 数组？

我试图为 Complex 的数组声明一个非成员转换运算符，但这是不允许的：

void std::vector<int> operator = (std::vector<Complex> complexArray)
{
    std::vector<int> abc;
    for(int i=0; i<complexArray.size(); i++)
     abc.push_back(complexArray[i]);
    return abc;
}

Answer 1

每当你想转换一些东西时，std::transform 函数可能会很好用。

在你的情况下你可以做类似的事情

// Create the new vector with the same size as the complex vector
std::vector<int> abc(complexArray.size());

std::transform(std::begin(complexVector), std::end(complexVector),
               std::begin(abc),
               [](Complex const& complex)
               {
                   int result;

                   // Code here that converts the complex structure to an integer
                   // and stores the integer in the variable result

                   return result;
               });

在上面的 std::transform 调用之后（一旦您使用实际进行结构转换的代码完成它）向量 abc 将包含来自 Complex 结构的所有转换后的整数在源向量中 complexVector.

Answer 2

你可以考虑std::vector的范围构造函数。

std::vector<int> ar3(begin(ar), end(ar));

Answer 3

忘记自动隐式转换（至少对于标准库容器而言）。但是，如果您愿意接受如下例所示的显式转换

 const std::vector<int> vi {1, 2, 3, 4, 5};
 const std::vector<double> vd = container_cast(vi);

然后是 container_cast() 实用程序的实现。请注意，它不仅可以在不同元素类型的同一模板容器的实例化之间进行转换（即 std::vector<int> 到 std::vector<double>），而且还可以在不同的容器之间进行转换（例如 std::vector 到 std::list).

#include <iostream>
#include <vector>
#include <list>

template<class SourceContainer>
class ContainerConverter
{
    const SourceContainer& s_;
public:
    explicit ContainerConverter(const SourceContainer& s) : s_(s) {}

    template<class TargetContainer>
    operator TargetContainer() const
    {
        return TargetContainer(s_.begin(), s_.end());
    }
};

template<class C>
ContainerConverter<C> container_cast(const C& c)
{
    return ContainerConverter<C>(c);
}

template<class C>
void printContainer(const C& c)
{
    std::cout << "{ ";
    for( auto x : c )
        std::cout << x << ' ';
    std::cout << "}" << std::endl;
}

int main()
{
    const std::vector<double> vd {2.2, 7.7, 5.5, 1.1, -4.4};
    printContainer(vd);

    const std::vector<int> vi = container_cast(vd);
    printContainer(vi);

    const std::list<float> lf = container_cast(vd);
    printContainer(lf);
    return 0;
}

如何定义运算符以便将用户定义类型数组转换为基本类型数组？

How can I define operators so that a array of user-defined types can be transformed into an array of primitive types?

c++

containers

implicit-conversion