C++ 向量从一种类型到另一种类型的隐式转换c++；

是否可以隐式地将一种类型的向量转换为另一种类型

i、 e一些使代码工作的方法（显然，这是我试图做的一个简化问题）

std:：vector intVec；
intVec.推回（1）；
std:：vector doubleVec=intVec；
std:：vectorDoublevec2；
doubleVec2=intVec；

否，不同向量类型之间没有转换（隐式或其他转换）

您可以从迭代器范围初始化它：

std::vector<double> doubleVec(intVec.begin(), intVec.end());

std:：vector doubleVec（intVec.begin（），intVec.end（））； 也许将其包装在函数中：

template <typename To, typename From>
To container_cast(From && from) {
    using std::begin; using std::end; // Koenig lookup enabled
    return To(begin(from), end(from));
}

auto doubleVec = container_cast<std::vector<double>>(intVec);

模板
到容器\u转换（从和从）{
使用std:：begin；使用std:：end；//启用Koenig查找
返回（开始（从），结束（从））；
}
auto doubleVec=容器的浇铸（intVec）；

一种方法是创建转换函数。它允许您在呼叫站点表达意图：

#include <iostream>
#include <vector>

template<class To, class From, class Allocator>
std::vector<To, typename Allocator::template rebind<To>::other>
implicit_convert(const std::vector<From, Allocator>& vf)
{
    return { std::begin(vf), std::end(vf) };
}

template<class To, class ToA, class From, class FromA>
void implicit_overwrite(std::vector<To, ToA>& to, const std::vector<From, FromA>& from)
{
    to.clear();
    std::copy(begin(from), end(from), back_inserter(to));
}

int main(int argc, const char * argv[]) {
    using namespace std;
    std::vector<int> vi { 1, 2 , 3 };
    auto vd = implicit_convert<double>(vi);

    cout << "after conversion\n";
    for (const auto& i : vd) {
        cout << i << endl;
    }

    vi.push_back(4);
    implicit_overwrite(vd, vi);
    cout << "after copy\n";
    for (const auto& i : vd) {
        cout << i << endl;
    }


    return 0;
}

模板
结构magic_向量：std:：vector{
使用base=std:：vector；
使用base：：base；
magic_vector（magic_vector const&）=默认值；
魔术向量（魔术向量&&）=默认值；
幻方向量和运算符=（幻方向量常量&）=默认值；
幻方向量和运算符=（幻方向量和运算符）=默认值；
magic_vector（）=默认值；
模板
幻方向量（幻方向量常量（&o）：
基础（o.begin（），o.end（））
{}
模板：：类型
>
幻方向量（幻方向量（&o）：
基地(
std:：make_move_迭代器（o.begin（）），
std:：make_move_迭代器（o.end（））
)
{}
};

magic_向量

s是从其他

magic_向量

s自动转换的向量

如果您有一个指向

magic_vector

的指针，并将其转换为指向

vector

的指针，然后将其作为

vector

删除，则结果是未定义的行为。（但是实际上，在我检查过的每个C++实现中都不会有任何危害）。然而，这是一种处理

vector

s的奇怪方式

用

magic_vector

替换

vector

的使用。只要您的代码中没有对容器的确切类型进行专门化，它就应该是一个替代品，除非现在它将在它们之间自动转换

---

可以使用

magic_vector

s来自动转换

vector

s，而不仅仅是

magic_vector

s。您可以这样做（假设myclass是您的类，可以从

std:：pair

构建）：

#包括
#包括
#包括
使用std：：cout；
使用std：：endl；
类myclass
{
公众：
myclass（const std:：pair&p）：第一（p.first），第二（p.second）{
int first（）{return first；}
int second（）{return second；}
私人：
int第一；
int秒；
};
模板
类myvector:public std:：vector
{
使用base=std:：vector；
使用base：：base；
};
模板
类myvector:public std:：vector
{
公众：
myvector（常量std:：vector和vp）：
std:：vector（vp.begin（），vp.end（））{}
};
int main（）
{
向量vp{{12,3}，{1,7}；
myvector mm=vp；
但这对我来说不起作用。基本上我有一个带有vector类型的大型代码，现在我不想使用vector，而是想使用vector。我知道如何隐式地将pair转换为myClass，但当它们在vector中时，这会变得很棘手。@death\u relic0如果
myClass
可以从
pair
构造，这会起作用。如果不是，t嗯……我不知道你会期望什么工作。@ DeasyReliC0:如果从<代码>配对转换为<代码> MyCype < /Cord>是隐式的，那么这将起作用。范围构造函数将隐式地转换每一个元素。有条件地使用移动迭代器来撕碎每个元素的内脏，如果移动没有异常？@Yakk：如果我们正在编写一个超泛型库，试图覆盖所有可以想象的用例，可能。如果我们正在为OP的用例编写一个简单的帮助器，可能不会。
#include <iostream>
#include <vector>

template<class To, class From, class Allocator>
std::vector<To, typename Allocator::template rebind<To>::other>
implicit_convert(const std::vector<From, Allocator>& vf)
{
    return { std::begin(vf), std::end(vf) };
}

template<class To, class ToA, class From, class FromA>
void implicit_overwrite(std::vector<To, ToA>& to, const std::vector<From, FromA>& from)
{
    to.clear();
    std::copy(begin(from), end(from), back_inserter(to));
}

int main(int argc, const char * argv[]) {
    using namespace std;
    std::vector<int> vi { 1, 2 , 3 };
    auto vd = implicit_convert<double>(vi);

    cout << "after conversion\n";
    for (const auto& i : vd) {
        cout << i << endl;
    }

    vi.push_back(4);
    implicit_overwrite(vd, vi);
    cout << "after copy\n";
    for (const auto& i : vd) {
        cout << i << endl;
    }


    return 0;
}

after conversion
1
2
3
after copy
1
2
3
4

template<class T, class A=std::allocator<T>>
struct magic_vector:std::vector<T,A> {
  using base=std::vector<T,A>;
  using base::base;
  magic_vector(magic_vector const&)=default;
  magic_vector(magic_vector &&)=default;
  magic_vector& operator=(magic_vector const&)=default;
  magic_vector& operator=(magic_vector &&)=default;
  magic_vector()=default;

  template<class U, class B,
    class=typename std::enable_if<std::is_convertible<U,T>::value>::type
  >
  magic_vector( magic_vector<U,B> const& o ):
    base( o.begin(), o.end() )
  {}
  template<class U, class B,
    class=typename std::enable_if<
      std::is_convertible<U,T>::value
      && noexcept( T(std::declval<U&&>()) )
    >::type
  >
  magic_vector( magic_vector<U,B>&& o ):
    base(
      std::make_move_iterator(o.begin()),
      std::make_move_iterator(o.end())
    )
  {}
};

#include <iostream>
#include <vector>
#include <utility>

using std::cout;
using std::endl;

class myclass
{
public:
    myclass(const std::pair<int, int>& p): first_(p.first), second_(p.second) {}
    int first() {return first_;}
    int second() {return second_;}
private:
    int first_;
    int second_;
};

template <class T>
class myvector : public std::vector<T> 
{
    using base = std::vector<T>;
    using base::base;
};

template<>
class myvector<myclass> : public std::vector<myclass>
{
public:
    myvector(const std::vector<std::pair<int, int>>& vp):
std::vector<myclass>(vp.begin(), vp.end()) {}

};

int main()
{
    std::vector<std::pair<int, int>> vp {{12,3}, {1, 7}};
    myvector<myclass> mm = vp;
    cout<<mm[0].first(); //prints 12

}