将 const node*& 类型的引用绑定到 node*const

Question

我正在尝试实现通用树，并且在 function getSizeRecursive line 1中为什么我不能使用const node* &root 。 同样，我在line 2遇到了同样的错误。编译器给出了一个我无法理解的错误。

graph.cpp: In function 'int getSizeRecursive(const node*&)':
graph.cpp:56:40: error: binding reference of type 'const node*&' to 'node* const' discards qualifiers
   56 |         for(const node* &child : root->children) // line 2
      |                                        ^~~~~~~~
graph.cpp: In function 'int main()':
graph.cpp:69:36: error: binding reference of type 'const node*&' to 'node*' discards qualifiers
   69 |         cout << getSizeRecursive(t.root) << endl;
      |                                  ~~^~~~
graph.cpp:51:35: note:   initializing argument 1 of 'int getSizeRecursive(const node*&)'
   51 | int getSizeRecursive(const node* &root){ // line 1
      |                      ~~~~~~~~~~~~~^~~~
[Finished in 2.9s]

#include <iostream>
#include <vector>
#include <stack>
using namespace std;
class node{
public:
    int data;
    vector<node*> children;

    node(int val){
        data = val; // this->data = data
    }
    ~node(){
        for(int i = 0 ;i<children.size();i++){
            if(!children[i])
                delete children[i];
        }
    }
};
class GenericTree{
public:
    node* root; // line 3
    int size;
    
    GenericTree(vector<int> nums){
        stack<node*> st;
        size = 0;
        for(int i = 0;i<nums.size();i++){
            node *n = new node(nums[i]);
            if(i == 0){
                root = n;
                st.push(n);
                ++size;
            }else{
                if(n->data == -1){
                    st.pop();
                }else{
                    // cout << "In me" << endl;
                    st.top()->children.push_back(n);
                    st.push(n);
                    ++size;
                }
            }
        }
    }
    // tells us the number of nodes
    int getSize(){
        return size;
    }
};
int getSizeRecursive(const node* &root){ // line 1
    if(root->children.size()==0)
        return 1;

    int size = 0;
    for(const node* &child : root->children) // line 2
        size  += getSizeRecursive(child);
    return size+1;
}
int main(){
    #ifndef ONLINE_JUDGE
        freopen("input.txt","r",stdin);
        freopen("output.txt","w",stdout);
        freopen("error.txt","w",stderr);
    #endif
    vector<int> v{10,20,-1,30,50,-1,60,-1,-1,40,-1,-1};
    GenericTree t(v); // node that tree has been created 
    cout << t.size << endl;
    cout << getSizeRecursive(t.root) << endl;
    return 0;
}

我可以从中理解的是，编译器无法将对reference to pointer to const node的const pointer to node但我的问题是为什么它将t.root作为const pointer to node而实际上它只是一个pointer to node （见第 3 行）。

我是 c++ 的新手。 任何帮助，将不胜感激。

编辑：我使用const* & root的原因是因为我不想将 root 的副本传递给getSizeRecursive但在此期间，由于我通过引用传递，我使用了const ，因此该引用仅读取根指针而不是修改它。

Answer 1

让我们逐案查看每个错误的原因。 此外，我将尝试逐步解释。

情况1

在这里，我们考虑由于语句引起的第一个错误：

for(const node* &child : root->children)

现在要了解为什么会由于上述语句而出错，让我们逐步了解每个术语的含义：

步骤1：

root是对指向const node的非常量指针的非常量左值引用。 这意味着我们可以更改root所指的指针（因为我们有一个非常量左值 ref），但我们不允许更改该指针指向的实际node object。

第2步

root->children是const vector<node*>因为我们不允许更改指针指向的node object，如上面步骤 1 中所述。 基本上，就好像指向 object 本身就是const ，这反过来意味着它的数据成员也被视为const 。 由于children是数据成员，因此它被视为const ，因此root->children是const vector<node*> 。

请注意，这一步的结论是我们有一个带有node*类型元素的 const 向量。

第 3 步

现在， const node* &child意味着child是对指向const node的非常量指针的非常量左值引用。 同样，这意味着我们可以更改位于向量内的指针。 但这是一个问题，因为我们从上面的步骤 2 中了解到，我们有一个const vector<node*>意味着我们不应该被允许更改驻留在向量内的指针。 因此你得到提到的错误。

案例1的解决方案

要解决此问题，您需要确保无法通过添加低级const 来更改驻留在const vector内的指针，如下所示：

//-------vvvvv--------------------------->const added here
for(node*const &child : root->children)

上述工作是因为现在child是对指向非常量节点 object 的 const 指针的左值引用。

案例2

在这里，我们考虑由于表达式引起的第二个错误：

getSizeRecursive(t.root)

这里传递的参数t.root是一个node*而参数是一个const node* & 。 现在，传递的参数可以隐式转换为const node*但该转换的结果将是一个右值。 但是由于参数root是对指向 const 节点的非常量指针的非常量左值引用，因此它不能绑定到右值。

这基本上与您将使用的错误相同：

node *ptr;
const node*& ref = ptr; //will produce the same error saying: error: cannot bind non-const lvalue reference of type ‘const int*&’ to an rvalue of type ‘const int*’

案例2的解决方案

基本上，给定类型T可以绑定到T&或T const&而给定类型const T可以绑定到T const& 。 在您的示例中，传递的参数是node* ，这意味着它可以绑定到node*&以及node*const& 。

要解决此问题，您可以将左值引用设为 const 左值引用，如下所示：

node *ptr;
//---vvvvv--------------->const added here
node*const& ref = ptr;

在您的示例中，这意味着：

//------------------------vvvvv--------->const added here
int getSizeRecursive(node*const &root){ // line 1

工作演示