所以这是我的第一个问题。我已经搜索了该站点，找到了一些东西并应用了其中给出的建议，但我仍然不确定我是否以正确的方式完成了它。
我正在开发一个模板库，这是我对BST类模板的实现：
template <class T>
class bstree
{
private:
struct bstnode
{
bstnode* pRight; //node to the right (greater)
bstnode* pLeft; //node to the left (lesser)
bstnode* pParent; //parent node
T mValue; //contents
};
class bstnodeiterator : public _iterator_base<T, bstree<T>>
{
public:
bstnodeiterator(bstnode* pNode = nullptr, bstree<T> pCont = nullptr)
: _mpNodePtr(pNode), _mpCont(pCont) {}
//functions from _iterator_base<>
bool is_null() const { return (_mpNodePtr == nullptr); }
const bstree<T>* get_container() const { return this->_mpCont; }
//get_pointer() is intentionally not defined.
//operators (e.g. increment, decrement, advance by, dereference, etc)
//go here!
//...
private:
friend class bstree<T>;
//member elements:
bstree<T>* _mpCont; //the container that the iterator is created by
bstnode* _mpNodePtr; //the actual pointer pointing to the bst-node of '_mpCont'
};
public:
using val = T;
using val_ref = T&;
using val_ptr = T*;
using iter = bstnodeiterator;
public:
iter begin() const;
iter end() const;
//other public member functions (e.g. insert(), remove(), etc.) go here!
//...
private:
bstnode* _mpRoot; //The root node of the BST
size_t _mSize; //The number of elements in the container (guaranteed O(1))
};
bstnodeiterator::get_container()并且bstnodeiterator::is_null()派生自iterator_base<>它是所有其他容器（例如vector<>、fixed_list<>、map<>等）的迭代器的基类：
template <class T, class Cont>
struct _iterator_base
{
virtual bool is_null() const = 0;
virtual const Cont* get_container() const = 0;
/*virtual*/ const T* get_pointer() const /* = 0*/;
};
//is_null() and get_container() should be defined in derived classes
//because they are used everywhere in the library!
- 需要定义上述所有三个函数，因为它们在整个库中的其他任何地方都使用（例如，在算法中，在
iterator_helper类中等）。
由于 BST 是已排序元素的容器，因此不应动态更改节点的内容。因为这会破坏树的排序结构。因此，我想阻止程序员使用get_pointer(). 即使它返回一个指向内容的 const 指针，它仍然可以通过成员函数进行更改T（例如，如果T是 astd::string那么内容可以通过 更改std::string::assign()），我不希望这样。
所以，我_iterator_base<*,*>::get_pointer()在基类中使函数非虚拟。而且它没有在派生类中定义，bstnodeiterator. 所以，如果程序员从派生类中调用它......
bstree<std::string> strTree = { "a string", "another string", "yet another string", "test string" };
//inserted some other elements
bstree<std::string>::iterator it = strTree.begin();
//*it = "something else"; --> this won't work, because read-only dereferencing is allowed in the class.
it.get_pointer()->assign("something else"); //this will break the tree.
...然后编译器将给出链接错误：unresolved external symbol " ... ::get_pointer()".
这是正确的方法吗？你怎么看？
编辑：
我刚刚尝试取消引用和修改：
bstree<std::string> strTree =
{
"a string",
"another string",
"yet another string",
"test string"
};
bstree<std::string>::iter it = strTree.begin();
(*it).assign("modified string"); // ----> error!
std::string pB0 = strTree.begin(); // ----> error
const std::string pB = strTree.begin();
pB->assign("modified string"); // ----> error!
...它没有编译。但是，如果我将最后一行更改为：
it.get_pointer()->assign("modified string");
...它编译没有错误，运行和工作！
编辑2：
我终于找到了问题的根源：typedefs。
我没有typedef在原始问题中显示 s 以使其看起来更简单，更易于阅读。在原始代码中，有一个using val_ptr = T*;在范围内bstree<>，我在typedef以下范围内使用它bstnodeiterator：
template <class T>
class bstree
{
public:
using val = T;
using val_ref = T&;
using val_ptr = T*;
private:
class bstnodeiterator : public _iterator_base<T, bstree<T>>
{
//c'tor comes here!
const val_ptr get_pointer() { return (_mPtr ? &_mPtr->_mVal : nullptr); }
//...
};
//...
};
如果我定义了上面给出的函数，那么我可以std::string::assign()从get_pointer(). 但是，如果我将函数的返回类型更改为const val*然后我不能调用string::assign().
我终于意识到这两种类型是不同的。可能编译器将其const放在其他地方。