向量和常量

Question

考虑一下

 void f(vector<const T*>& p)
 {
 }
 int main()
 { 
  vector<T*> nonConstVec;
  f(nonConstVec);
 }

以下内容无法编译。问题是 vector 无法转换为 vector ，这似乎不合逻辑对我来说，因为存在从 T* 到 const T* 的隐式转换。这是为什么？

vector 也无法转换为 vector，但这是预期的，因为 const T*无法隐式转换为 T*。

Answer 1

我已在您的代码中添加了几行。这足以清楚为什么这是不允许的：

void f(vector<const T*>& p)
 {
    static const T ct;
    p.push_back(&ct); // adds a const T* to nonConstVec !
 }
 int main()
 { 
  vector<T*> nonConstVec;
  f(nonConstVec);
  nonConstVec.back()->nonConstFunction();
 }

Answer 2

vector 和 vector 是不相关的类型。 T 可以转换为 const T 的事实在这里没有任何意义。

您必须从类型系统的角度来考虑它。实例化的 vector 与 vector 没有任何共同点。

Answer 3

可能值得说明为什么执行您想要的转换违反了 const 正确性：

#include <vector>
const int a = 1;

void addConst(std::vector<const int *> &v) {
    v.push_back(&a); // this is OK, adding a const int* to a vector of same
}

int main() {
    std::vector<int *> w;
    int b = 2;
    w.push_back(&b);  // this is OK, adding an int* to a vector of same
    *(w.back()) = 3;  // this is OK, assigning through an int*
    addConst(w);      // you want this to be OK, but it isn't...
    *(w.back()) = 3;  // ...because it would make this const-unsafe.
}

问题是 vector.push_back 采用指向非 const 的指针（其中从现在开始我将称之为“非常量指针”）。这意味着，它可能会修改其参数的指针。特别是在向量的情况下，它可能会将指针交还给修改它的其他人。因此，您不能将 const 指针传递给 w 的 push_back 函数，并且即使模板系统支持它（但它不支持），您想要的转换也是不安全的。 const 安全的目的是阻止您将 const 指针传递给采用非 const 指针的函数，这就是它的工作方式。 C++ 要求你明确说明是否想做一些不安全的事情，因此转换当然不能是隐式的。事实上，由于模板的工作方式，这是根本不可能的（见下文）。

我认为 C++ 原则上可以通过允许从 vector& 到 const vector& 的转换来保留 const 安全性，只是因为 int ** 到 const int *const * 是安全的。但这是因为向量的定义方式：对于其他模板来说它不一定是常量安全的。

同样，理论上它可以允许显式转换。事实上，它确实允许显式转换，但仅限于对象，而不是引用；-)

std::vector<const int*> x(w.begin(), w.end()); // conversion

它不能对引用执行此操作的原因是模板系统不支持它。如果允许转换，则会损坏另一个示例：

template<typename T> 
struct Foo {
    void Bar(T &);
};

template<>
struct Foo<const int *> {
    void Baz(int *);
};

现在，Foo 没有 Baz 函数。到底如何将 Foo 的指针或引用转换为 Foo 的指针或引用？

Foo<int *> f;
Foo<const int *> &g = f; // Not allowed, but suppose it was
int a;
g.Baz(&a); // Um. What happens? Calls Baz on the object f?

Answer 4

像这样思考：

您有两个这样的类：

class V  { T*       t;};
class VC { T const* t;};

您希望这两个类能够自动转换吗？
这基本上就是模板类。每个变体都是全新的类型。

因此向量 T* 是和向量是完全不同的类型。

我的第一个问题是你真的想存储指针吗？

如果是，我建议查看 boost::ptr_container。它保存指针并在向量被销毁时删除它们。但更重要的是，它对待包含的指针就像普通的 std:vector 对待其包含的对象一样。因此，通过将向量设置为 const，您只能将其成员作为 const 访问。

void function(boost::ptr_vector<T> const& x)
{
     x.push_back(new T);  // Fail x is const.
     x[4].plop();         // Will only work if plop() is a const member method.
}

如果不需要存储指针，则将对象（而不是指针）存储在容器中。

void function(std::vector<T> const& x)
{
     x.push_back(T());    // Fail x is const.
     x[4].plop();         // Will only work if plop() is a const member method.
}

Answer 5

其他人已经给出了您给出的代码无法编译的原因，但我对如何处理它有不同的答案。我不相信有任何方法可以教编译器如何自动转换两者（因为这将涉及更改 std::vector 的定义）。解决这个烦恼的唯一方法是进行显式转换。

转换为完全不同的向量是不令人满意的（浪费内存和周期来处理应该完全相同的东西）。我建议如下：

#include <vector>
#include <iostream>

using namespace std;

typedef int T;

T a = 1;
T b = 2;

void f(vector<const T*>& p)
{
    for (vector<const T*>::const_iterator iter = p.begin(); iter != p.end(); ++iter) {
        cout << **iter << endl;
    }
}
vector<const T*>& constify(vector<T*>& v)
{
  // Compiler doesn't know how to automatically convert
  // std::vector<T*> to std::vector<T const*> because the way
  // the template system works means that in theory the two may
  // be specialised differently.  This is an explicit conversion.
  return reinterpret_cast<vector<const T*>&>(v);
}
int main()
{
  vector<T*> nonConstVec;
  nonConstVec.push_back(&a);
  nonConstVec.push_back(&b);
  f(constify(nonConstVec));
}

我使用reinterpret_cast来声明这两件事是相同的。使用后你应该感觉很脏，但如果你把它单独放在一个函数中，并为关注你的人发表评论，那么就洗漱一下，然后问心无愧地继续你的路吧。你总是（正确地）会担心有人把你脚下的地面拔掉。

Answer 6

正如其他人所说，转换不适用于模板参数。换句话说，

vector<T>

...和：

vector<const T>

...是完全不同的类型。

如果您尝试实现关于 f() 的常量正确性而不修改向量的内容，这可能更符合您正在寻找的内容：

void f(vector<T>::const_iterator begin, vector<T>::const_iterator end)
{
  for( ; begin != end; ++begin )
  {
    // do something with *begin
  }
}

int main()
{
  vector<T> nonConstVec;
  f(nonConstVec.begin(), nonConstVec.end());
}

Answer 7

除了其他答案之外，值得阅读 C++ FQA Lite，其中从关键 POV 讨论了此功能（以及许多其他 C++ 功能）：
http://yosefk.com/c++fqa/const.html#fqa -18.1

Answer 8

这就是模板的工作方式 - 不对模板参数应用转换，因此两个向量具有完全不同的类型。

Answer 9

vector 和 vector 是完全不同的类型。即使您在 main() 中编写 const T*，您的代码也无法编译。您需要在 main 内部提供专业化。

编译如下：

 #include<vector>
 using namespace std;

 template<typename T>
 void f(vector<const T*>& p)
 {
 }
 int main()
 { 
     vector<const int*> nonConstVec;
     f(nonConstVec);
 }

Answer 10

模板在这方面有点奇怪。存在从 T 到 U 的隐式转换这一事实并不意味着存在从 XXX 到 XXX 的隐式转换。它可以实现，但需要在模板代码中进行大量额外的工作才能实现它，而且我怀疑在设计 std::vector 时这些技术是否都已为人所知（更准确地说，我很确定他们不为人所知）。

编辑：像这样的问题是使用迭代器背后的动机的一部分。即使X 容器 不能隐式转换为const X 容器，container::iterator 可以隐式转换为container::const_iterator。

如果你

void f(vector<const T*>& p) {}

用

template <class const_iter>
void f(const_iter b, const_iter e) {}

： 替换你的：那么：

int main() { 
    vector<T*> nonConstVec;
    f(nonConstVec.begin(), nonConstVec.end());
    return 0;
}

就可以了 - 所以也会：

vector<T const *> constVec;
f(constVec.begin(), constVec.end());