C++11 是/会是c++；11/14支持向量之类的东西<；汽车>；

我想知道c++11/c++14是否会/已经支持类似于

vector

？

---

如果没有，有什么原因吗？

它不受直接支持，也不立即明确您希望它做什么

评论已经提到了创建异构集合的几种可能性（例如Boost

any

和

variant

类）。我希望这不是你所追求的，因为异构的集合与C++的匹配很差，所以使用它们是丑陋和笨拙的。我想在某些情况下，这些确实是最好的选择，但至少以我的经验来看，这些情况相当罕见

另一种可能的解释是，一个向量（如通常的

auto

）正好包含一种类型，但该类型是从初始值设定项推导出来的，因此如果您从一些

int

初始化向量，您将得到一个

向量，如果您从一些字符串初始化它，你会得到一个
向量
，依此类推。尽管该语言不直接支持这一点，但至少在某种程度上模拟它是相当容易的。模板类不能/永远不能推断模板参数，但模板函数可以/可以。因此，我们可以创建一个微小的函数模板来获取一些初始值设定项，推断它们的类型，并返回该类型的向量。例如：

template <class T>
std::vector<T> make_vector(std::initializer_list<T> init) {
    return std::vector<T>(init);
}

最后一个需要一个用户定义的文本运算符，这是C++14中新增的（许多编译器还不支持）。使用C++11，其余的应该可以

也有一些讨论（和中的一个建议）添加了一个功能（可能是C++17），在这个功能中，您可以定义类似于上面的
make_vector
，但类似于类的模板构造函数。这将允许您在构造函数上使用参数推断来推断整个类的模板参数，因此您可以执行以下操作：

X x(1);     // deduces as X<int>
X x(2.0)    // deduces as X<double>

X（1）；//推断为X
X（2.0）//推断为X

但警告：这已被提议，但未被接受。它可能（很容易）永远不会被接受——即使它被接受了，也可能在它发生之前被大幅修改。
不，不是在已经完成并发布的C++11或C++14中

但是，作为概念工作的一部分，
vector
和类似的东西，如
tuple
可能会出现在C++17中

这是很自然的，因为
std:：vector
可以用于函数模板和类模板部分专门化，其中
T
是模板参数，并且多态lambda允许
auto
作为函数参数类型（这是带有推导参数的函数模板的缩写）

概念TS允许声明“通用函数”，如下所示：

auto func(auto arg);

由于您可以使用如下函数模板：

template<typename T>
  auto func(std::vector<T> v);

模板
自动函数（标准：：向量v）；

扩展通用函数语法以允许：

auto func(std::vector<auto> v);

autofunc（标准：：向量v）；

一旦在函数声明中允许，也可以在变量声明中允许：

std::vector<auto> v = function_returning_vector_of_something();

std:：vector v=返回某物的函数；

它不在C++11中的原因是，
auto
是新的，它太雄心勃勃了，不想让它做太多。在C++14中，多态lambda是新的，再次强调，进一步扩展
auto
的使用将是雄心勃勃的

对于C++17，我们在实际代码中使用
auto
方面有更多的经验，编译器编写人员熟悉如何实现它，并且知道不需要太多努力就可以实现什么。
A
boost:：any
可以存储可以复制的任何类型的实例，这些类型很多

为了从
any
中获取数据，您必须知道存储在其中的确切类型

编写一个简单的
any
并不难：

#include <memory>
#include <utility>

struct any_internal {
  virtual any_internal* clone() const = 0;
  virtual ~any_internal() {};
};
template<class T>
struct any_details;
class any {
  std::unique_ptr<any_internal> internal;
public:
  any() = default;

  any( any && ) = default;
  any( any const&& o):any(o) {}
  any( any & o ):any( const_cast<any const&>(o) ) {}

  any& operator=( any && ) = default;
  any& operator=( any const&& o ) { return this->operator=( o ); };
  any& operator=( any & o ) { return this->operator=( const_cast<any const&>(o) ); };

  any( any const& o ):internal( o.internal?o.internal->clone():nullptr ) {}
  any& operator=( any const& o ) {
    any tmp(o);
    using std::swap;
    swap( internal, tmp.internal );
    return *this;
  }

  template<class U>
  void reset( U&& o );
  template<class U, class... Args>
  void emplace( Args&&... args );
  template<class U>
  any( U&& o );
  template<class U>
  any& operator=(U&& o);
  template<class T> T* get();
  template<class T> T const* get() const;
  template<class T> T* fast_get();
  template<class T> T const* fast_get() const;
  explicit operator bool() const { return internal!=nullptr; }
};
template<class T>
struct any_details : any_internal {
  T t;
  template<class...Args>
  any_details( Args&&... args ):t(std::forward<Args>(args)...) {}
  any_internal* clone() const override { return new any_details<T>{t}; }
};
template<class U, class... Args>
void any::emplace( Args&&... args ) {
  internal.reset( new any_details<U>( std::forward<Args>(args)... ) );
}
template<class U>
void any::reset( U&& o ) {
  emplace<typename std::decay<U>::type>( std::forward<U>(o) );
}
template<class U>
any::any( U&& o ) {
  reset( std::forward<U>(o) );
}
template<class U>
any& any::operator=(U&& o) {
  reset( std::forward<U>(o) );
  return *this;
}
template<class T> T* any::get() {
  auto* r = dynamic_cast< any_details<T>* >( internal.get() );
  if (r) return &r->t;
  return nullptr;
}
template<class T> T const* any::get() const {
  auto* r = dynamic_cast< any_details<T>* >( internal.get() );
  if (r) return &r->t;
  return nullptr;
}
template<class T> T* any::fast_get() {
  auto* r = static_cast< any_details<T>* >( internal.get() );
  if (r) return &r->t;
  return nullptr;
}
template<class T> T const* any::fast_get() const {
  auto* r = static_cast< any_details<T>* >( internal.get() );
  if (r) return &r->t;
  return nullptr;
}

#包括
#包括
构造任何内部{
虚拟任意内部*克隆（）常量=0；
虚~any_internal（）{}；
};
模板
构造任何_细节；
任何类别{
std：：唯一的ptr内部；
公众：
any（）=默认值；
任何（任何&&）=默认值；
any（any const&&o）：any（o）{
any（any&o）：any（const_cast（o））{}
any&运算符=（any&&）=默认值；
any&operator=（any const&&o）{返回this->operator=（o）；}；
any&operator=（any&o）{返回this->operator=（const_cast（o））；}；
any（any const&o）：内部（o.internal？o.internal->clone（）：nullptr）{
any&运算符=（any const&o）{
任何tmp（o）；
使用std：：swap；
掉期（内部，tmp.internal）；
归还*这个；
}
模板
无效重置（U&o）；
模板
空洞侵位（Args&…Args）；
模板
任何（U&o）；
模板
任意运算符=（U&&o）；
模板T*get（）；
模板T常量*get（）常量；
模板T*fast_get（）；
模板T常量*fast_get（）常量；
显式运算符bool（）const{return internal！=nullptr；}
};
模板
结构任意_详细信息：任意_内部{
T；
模板
任何_详细信息（Args&&…Args）：t（std:：forward（Args）…{}
any_internal*clone（）const override{return new any_details{t}；}
};
模板
void any:：emplace（Args&&…Args）{
内部重置（新的任何_细节（标准：：转发（args）…）；
}
模板
作废任何：：重置（U&&o）{
炮位（标准：前方（o））；
}
模板
任意：：任意（U&&o）{
复位（标准：正向（o））；
}
模板
any&any:：operator=（U&&o）{
复位（标准：正向（o））；
归还*这个；
}
模板T*any:：get（）{
auto*r=dynamic_cast（internal.get（））；
如果（r）返回&r->t；
返回空ptr；
}
模板T常量*any:：get（）常量{
auto*r=dynamic_cast（internal.get（））；
如果（r）返回&r->t；
返回空ptr；
}
模板T*any:：fast_get（）{
auto*r=static_cast（internal.get（））；
如果（r）retur
#include <memory>
#include <utility>

struct any_internal {
  virtual any_internal* clone() const = 0;
  virtual ~any_internal() {};
};
template<class T>
struct any_details;
class any {
  std::unique_ptr<any_internal> internal;
public:
  any() = default;

  any( any && ) = default;
  any( any const&& o):any(o) {}
  any( any & o ):any( const_cast<any const&>(o) ) {}

  any& operator=( any && ) = default;
  any& operator=( any const&& o ) { return this->operator=( o ); };
  any& operator=( any & o ) { return this->operator=( const_cast<any const&>(o) ); };

  any( any const& o ):internal( o.internal?o.internal->clone():nullptr ) {}
  any& operator=( any const& o ) {
    any tmp(o);
    using std::swap;
    swap( internal, tmp.internal );
    return *this;
  }

  template<class U>
  void reset( U&& o );
  template<class U, class... Args>
  void emplace( Args&&... args );
  template<class U>
  any( U&& o );
  template<class U>
  any& operator=(U&& o);
  template<class T> T* get();
  template<class T> T const* get() const;
  template<class T> T* fast_get();
  template<class T> T const* fast_get() const;
  explicit operator bool() const { return internal!=nullptr; }
};
template<class T>
struct any_details : any_internal {
  T t;
  template<class...Args>
  any_details( Args&&... args ):t(std::forward<Args>(args)...) {}
  any_internal* clone() const override { return new any_details<T>{t}; }
};
template<class U, class... Args>
void any::emplace( Args&&... args ) {
  internal.reset( new any_details<U>( std::forward<Args>(args)... ) );
}
template<class U>
void any::reset( U&& o ) {
  emplace<typename std::decay<U>::type>( std::forward<U>(o) );
}
template<class U>
any::any( U&& o ) {
  reset( std::forward<U>(o) );
}
template<class U>
any& any::operator=(U&& o) {
  reset( std::forward<U>(o) );
  return *this;
}
template<class T> T* any::get() {
  auto* r = dynamic_cast< any_details<T>* >( internal.get() );
  if (r) return &r->t;
  return nullptr;
}
template<class T> T const* any::get() const {
  auto* r = dynamic_cast< any_details<T>* >( internal.get() );
  if (r) return &r->t;
  return nullptr;
}
template<class T> T* any::fast_get() {
  auto* r = static_cast< any_details<T>* >( internal.get() );
  if (r) return &r->t;
  return nullptr;
}
template<class T> T const* any::fast_get() const {
  auto* r = static_cast< any_details<T>* >( internal.get() );
  if (r) return &r->t;
  return nullptr;
}