C++ 如何在C+中声明指向具有不同数据类型的类模板指针的指针+；

我有一个用模板设计的程序来实现哈夫曼树。我的HuffmanNode类有两种不同的数据类型。下面是类的实现

#pragma once

template <typename T, typename U> class HuffmanNode 
{
private:
    int frequency;
    T value;
    U code;
    HuffmanNode<T, U>* left, *right;
public:
    HuffmanNode<T, U>() :
        value(' '), frequency(0), left(nullptr), right(nullptr) {}
    HuffmanNode<T, U>(T v, U i) :
        value(v), frequency(i), left(nullptr), right(nullptr) {}
    HuffmanNode<T, U>(HuffmanNode<T, U>* left, HuffmanNode<T, U>* right)
    {
        this->left = left;
        this->right = right;
        frequency = left->getFrequency() + right->getFrequency();
        value = NULL;
    }
};

#pragma一次
模板类HuffmanNode
{
私人：
整数频率；
T值；
U代码；
赫夫曼诺德*左，*右；
公众：
赫夫曼诺德（）：
值（“”），频率（0），左（nullptr），右（nullptr）{
赫夫曼诺德（T v，U i）：
值（v）、频率（i）、左（空PTR）、右（空PTR）{
哈夫曼诺德（哈夫曼诺德*左，哈夫曼诺德*右）
{
这个->左=左；
这个->右=右；
频率=左->获取频率（）+右->获取频率（）；
值=空；
}
};

在我的HuffTree类中，我有一个指向HuffmanNode指针的指针。我尝试用两种不同的方式将指针声明为HuffManode指针，但无论哪种方式，我都会得到一个错误

我是这样宣布的：

HuffmanNode<T>** storage;   // Error: 'HuffmanNode': too few template arguments

template <class T, class U> 
HuffmanNode<T, U>** storage;   // Error: 'HuffTree<T>::storage': only static data member templates are allowed

HuffmanNode**storage；//错误：“HuffmanNode”：模板参数太少

然后我尝试了两种数据类型，如下所示：

HuffmanNode<T>** storage;   // Error: 'HuffmanNode': too few template arguments

template <class T, class U> 
HuffmanNode<T, U>** storage;   // Error: 'HuffTree<T>::storage': only static data member templates are allowed

模板
赫夫曼节点**存储；//错误：“HuffTree:：storage”：只允许使用静态数据成员模板

如何声明这样的指针

Edit:我更新了HuffTree类，使其在HuffmanNode指针中同时包含这两种数据类型，但现在我在包含HuffTree类的HuffmanCode类中出现错误。以下是HuffTree类的更新代码：

#pragma once
#include "HuffmanNode.h"
using namespace std;

template <typename T, typename U> class HuffTree 
{
private:
    HuffmanNode<T, U>** storage;
    int treeSize;
    int capacity;

public:
HuffTree<T, U>(int size)
{
    capacity = size;
    treeSize = 0;
    storage = new HuffmanNode<T, U>*[capacity];
    for (int i = 0; i < capacity; i++)
    {
        storage[i] = NULL;
    }
}
// I get an error in the HuffmanCode class when calling this function
void insert(HuffmanNode<T, U>* rhs)
{
    treeSize++;
    storage[treeSize - 1] = rhs;
    percUp(treeSize - 1);
}
};

#pragma一次
#包括“HuffmanNode.h”
使用名称空间std；
模板类HuffTree
{
私人：
哈夫曼节点**存储；
内特树；
国际能力；
公众：
赫夫特里（整数大小）
{
容量=大小；
treeSize=0；
存储=新的HuffmanNode*[容量]；
对于（int i=0；i

以下是HuffmanCode类的代码，在我修复了指针问题后，该类给了我一个错误：

#pragma once
#include <string>
#include <map>
#include"HuffmanTree.h"
using std::string;
using std::map;
template <typename T, typename U> class HuffmanCode 
{
private:
    string data;
    string encodedData;
    HuffTree<T, U>* tree;
    map<T, U> frequencyTable;
    map<T, U> huffmanTable;
    void buildTree()
    {
        for (map<T, U>::iterator it = frequencyTable.begin();
            it != frequencyTable.end(); ++it)
        {
            /* 
            this line gives me an error: 'HuffmanNode<char,std::string>::
            HuffmanNode(const HuffmanNode<char,std::string> &)': 
            cannot convert argument 1 from 'const std::string' to 'char'
            */
            tree->insert(new HuffmanNode<char, string>(it->first, it->second));
        }
    }
public:
    HuffmanCode<T, U>(T input)
    {
        data = input;
        encodedData = "";
        // create tree to be large enough for worst case
        tree = new HuffTree<T, U>(data.length());
        buildTable();
        buildTree();
    }
    };

#pragma一次
#包括
#包括
#包括“HuffmanTree.h”
使用std:：string；
使用std：：map；
模板类HuffmanCode
{
私人：
字符串数据；
字符串编码数据；
哈夫特树；
地图频率表；
地图易怒；
void buildTree（）
{
for（map:：iterator it=frequencyTable.begin（）；
it！=frequencyTable.end（）；+it）
{
/* 
这行给了我一个错误：“HuffmanNode:”
霍夫曼诺德（常数霍夫曼诺德&）'：
无法将参数1从“const std:：string”转换为“char”
*/
树->插入（新HuffmanNode（它->第一个，它->第二个））；
}
}
公众：
赫夫曼码（T输入）
{
数据=输入；
encodedData=“”；
//创建足够大的树以应对最坏的情况
tree=新的HuffTree（data.length（））；
buildTable（）；
buildTree（）；
}
};

下面是测试这些函数的源文件：

#include <iostream>
#include <string>
#include "HuffmanCode.h"
using namespace std;

int main()
{
    string text;
    cout << "Enter some text:\n";
    getline(cin, text);
    HuffmanCode<string, string>* huffText = new HuffmanCode<string, string>(text);

    huffText->displayTable();
    huffText->displayHuffmanTable();

    string code = huffText->getEncodedString();
    cout << "Encoded string: " << code << endl << endl;
    cout << "Decoded string: " << huffText->decodeString(code) << endl << endl;

    delete huffText;

    return 0;
}

#包括
#包括
#包括“HuffmanCode.h”
使用名称空间std；
int main（）
{
字符串文本；
cout displayTable（）；
huffText->displayHuffmanTable（）；
字符串代码=huffText->getEncodedString（）；
cout如果无法定义其他模板参数类型，请在
HuffTree
类中自己指定它。其中之一应该适合您：

HuffmanNode**存储；

或

HuffmanNode**存储；

（或您认为合适的任何其他数据类型）
没有“双指针”这样的东西。您可以不使用模板来编写树吗？如果不能，请不要尝试使用模板来编写树。创建模板很难（起初，斯科特·迈尔斯、赫伯·萨特、肖恩·帕伦特可能不同意我的观点）.Neil Butterworth的建议真的很好。从创建没有模板的类开始。一旦你让它们工作，然后从细节中“抽象”出模板。我编辑了我的帖子，将“双指针”改为“指针到指针”我需要使用模板为作业编写树。@Eljay我这样做了-我让类在没有模板的情况下工作，这是我需要“抽象”的最后一部分out.除非可以通过
HuffTree
的模板参数确定
huffmanode
的模板参数，否则您想要的没有意义。我们需要更多的上下文。我编辑了我的帖子以包含指向此程序所有代码的链接。存储声明将是相同的。我添加了“完成”类声明的完整性。你可以复制这一行。我尝试了，但我得到了更多的错误。HuffTree被用于另一个类，它也需要类T和类U作为参数，但这不起作用。我在github上发布了一个完整程序的链接，以便你可以看到我的所有代码。