问题描述
我创建了一个自定义迭代器,我无法满足创建一个 const
迭代器的场景,并使用非 const
begin()
。根据STL,这是合法的,可以用std :: string来演示:
I'm creating a custom iterator and I'm having trouble satisfying the scenario where I create a const
iterator and initialize it with a non-const
begin()
. This is legal according to the STL and can be demonstrated with std::string:
#include <string>
using namespace std;
int main() {
string::iterator a;
string::const_iterator b = a;
return 0;
}
我不知道如何使它工作:
I can't figure out how to make it work:
template<typename T>
class some_class {
};
int main() {
some_class<int> a;
// Works OK!
const some_class<int> const_b = a;
// error: conversion from 'some_class<int>' to non-scalar type 'const some_class<const int>'
const some_class<const int> const_c = a;
return 0;
}
UPDATE
提供了一个解决方案,但它不能满足所有可能的STL测试用例。我接下来要测试的建议。将构造函数更改为 const some_class< U>&其他
将允许它编译,但是迭代器a = const_iterator b
也会错误地成立。
@ALEXANDER KONSTANTINOV provided a solution but it does not satisfy all possible STL test cases. I'm testing @Bo Persson's suggestion next. Changing the constructor to const some_class<U>& other
will allow it to compile but then iterator a = const_iterator b
would also erroneously be true.
#include <string>
using namespace std;
template<typename T>
class some_class {
public:
some_class() {
}
template<typename U>
some_class(some_class<U>& other) {
}
};
namespace name {
typedef some_class<int> iterator;
typedef const some_class<const int> const_iterator;
}
int main() {
string::iterator a;
string::const_iterator b = a;
const string::iterator c;
string::iterator d = c;
string::const_iterator e = c;
name::iterator f;
name::const_iterator g = f;
const name::iterator h;
name::iterator i = h;
name::const_iterator j = h; // <- Error
return 0;
}
UPDATE
似乎有一些混淆关于添加 const
到构造函数。这里是一个测试用例:
There seems to be some confusion regarding adding const
to the constructor. Here is a test case:
// This is not allowed by the STL
//string::const_iterator _a;
//string::iterator _b = _a; // <- Error!
// This should NOT compile!
name::const_iterator _a;
name::iterator _b = _a;
推荐答案
首先 - 你不能假设 std :: string :: const_iterator
只是常规迭代器的const version - 像这样 const std :: string :: iterator
。
First of all - you cannot assume that std::string::const_iterator
is just "const version" of regular iterator - like this const std::string::iterator
.
当你查看你的STL库实现(这只是来自gcc4.9.2 STL header for basic_string的例子):
When you look at your STL library implementation (this is just example from gcc4.9.2 STL header for basic_string):
typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
const_iterator;
正如你所看到的 - 两个迭代器都有不同的是返回指针值 - 指针
vs const_pointer
- 就是这样 - const iterator不是不能改变的东西,而是返回const指针/引用的东西你不能修改迭代器迭代的值。
As you can see - what differs both iterators is the return pointer value - pointer
vs const_pointer
- and that is the case - "const iterator" is not something that cannot change - but something that returns const pointer/references so you cannot modify the values the iterator iterates over.
所以 - 我们可以进一步调查,看看如何从非const到const版本的复制:
So - we can investigate further and see how the desired copying from non const to const version was achieved:
// Allow iterator to const_iterator conversion
template<typename _Iter>
__normal_iterator(const __normal_iterator<_Iter,
typename __enable_if<
(std::__are_same<_Iter, typename _Container::pointer>::__value),
_Container>::__type>& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i.base()) { }
所以,基本上 - 这个构造函数接受相同模板的任何实例( __ normal_iterator
) - 但它有 enable_if
只有const指针的实例。
So, basically - this constructor accepts any instance of the same template (__normal_iterator
) - but it has enable_if
closure to allow only instance of const pointer.
我相信你会在你的情况下做同样的事情
I believe you shall do the same in your case
- 有真正的const_iterator - 不只是常量迭代器的const版本
- 并且有来自const_iterator的模板构造函数和enable_if限制,以禁止从任何东西构造(我的意思是迭代器over ints从迭代器over std :: strings)
根据您的示例:
As per your example:
#include <type_traits>
template<typename T>
class some_class {
public:
some_class() {
}
template <typename U>
using allowed_conversion_from_non_const_version = std::enable_if_t<std::is_same<std::remove_cv_t<T>,U>::value>;
template<typename U, typename EnableIf = allowed_conversion_from_non_const_version<U>>
some_class(const some_class<U>&) {
}
template<typename U, typename EnableIf = allowed_conversion_from_non_const_version<U>>
some_class& operator = (const some_class<U>&) {
}
};
从这个例子中读取两件事:
Two things to read from this example:
- 还需要赋值运算符
- 只能从非const到const版本启用 - 这可以通过
enable_if
/remove_cv
(remove_const
也可以 - 但为什么不构造volatile版本 -cv
短于const
)
- Assignment operator is also needed
- You shall enable only from non-const to const version - and this is achieved by combination of
enable_if
/remove_cv
(remove_const
also works - but why not construct also volatile version - anywaycv
is shorter thanconst
)
这篇关于如何为一个const模板参数定义一个复制构造函数?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持!