外部具有动态分配的嵌套类中的类

A class from a nested class outside with dynamic allocation

本文关键字：嵌套动态分配外部更新时间：2023-10-16

如何将嵌套类中的类放在c++外部？我想使用动态分配。

这是代码：

class LZWBinTree{
   public: 
      LZWBinTree():tree (&root){}    
      ~LZWBinTree(){   
         free(root.oneChild());     
         free(root.zeroChild());     
      }
      void operator<< (char b){     
         if (b=='0'){    
            if (!tree->zeroChild()){
               Node *uj=new Node('0');   
               tree->newZeroChild(uj);    
               tree=&root;     
            }
            else
               tree=tree->zeroChild();  
         }
         else{ 
            if (!tree->oneChild()){  
               Node *new=new Node('1');   
               tree->newOneChild(new);   
               tree=&root;     
            }
            else
               tree=tree->oneChild();  
         }
      }
      void write(void){  
         depth=0;  
         write(&root, std::cout);
      }
      int getDepth(void);        
      double getAverage(void);       
      double getDispersion(void);
      friend std::ostream &operator<< (std::ostream &os, LZWBinTree &bf){
         bf.write(os);
         return os;
      }
      void write(std::ostream &os){
         depth=0;
         write(&root, os);
      }
   private:
      class Node{ 
         public:
            Node(char b='/'):letter(b), leftZero(0), rightOne(0){};
            ~Node(){};
            Node *zeroChild() const{
               return leftZero;
            }
            Node *oneChild() const{ 
               return rightOne;
            }
            void newZeroChild(Node *gy){
               leftZero=gy;
            }
            void newOneChild(Node *gy){ 
               rightOne=gy;
            }
            char getLetter() const{
               return letter;
            }
         private: 
            char letter; 
            Node *leftZero;
            Node *rightOne;
            Node(const Node &); 
            Node &operator= (const Node &); 
      }; 
      Node *tree;
      int depth, averagesum, averagepiece;    
      double dispersionsum;      
      LZWBinTree (const LZWBinTree&);  
      LZWBinTree& operator= (const LZWBinTree&);    
      void write(Node *element, std::ostream & os){    
         if(element!=NULL){  
            ++depth;
            write(element->oneChild(), os);
            for(int i = 0; i<depth; ++i)
               os << "---";
            os << element->getLetter() << "(" << depth-1 << ")" <<  std::endl;
            write(element->zeroChild(), os);
            --depth;
         }
      }
      void free(Node *element){
         if(element!=NULL){ 
            free(element->oneChild());     
            free(element->zeroChild());    
            delete element;  
         }
      }
   protected:  
      Node root;
      int maxDepth;   
      double average, dispersion;
      void rdepth(Node *element);
      void raverage(Node *element);
      void rdispersion(Node *element);
};

我希望Node类在LZWBinTree类之外。仅仅复制和粘贴它就足够了吗？或者我如何使用动态分配？

您无法从外部访问Node类，因为它在LZWBinTree类别中被声明为私有。如果要使其可访问，请更改访问修饰符。发件人：

private:
    class Node{ ...

收件人：

public:
    class Node{ ...

一旦你这样做了，你就可以通过它所在的类访问它来创建节点类的实例，如下所示：

LZWBinTree::Node n;

在这种情况下，我不太确定动态分配如何帮助您。