为什么出现：不可识别的模板声明/定义。请帮忙找一下错误(程序是在vs2015上编译)

IL_Programmer 2016-11-23 12:47:49

#pragma once

#ifndef HUFFMAN_H

#define HUFFMAN_H

#include <iostream>

using namespace std;

//节点类（抽象类）
template <typename E>
class HuffNode<E>
{
public:
virtual ~HuffNode() {}
virtual int weight() = 0;
virtual bool isLeaf() = 0;
};

//叶节点类（继承自节点类）
template<typename E>
class LeafNode :pulic HuffNode<E>
{
private:
E it;
int wgt;
public:

//构造叶节点
LeafNode(const E& val, int freq)
{
it = val;
wgt = freq;
}

//返回该叶节点的权值
int weight()
{
return wgt;
}

//返回节点的值
E val()
{
return it;
}

//判断是否是叶节点
bool isLeaf()
{
return true;
}
};

//内部节点类（继承自节点类）
template <typename E>
class IntlNode :public HuffNode<E>
{
private:
HuffNode<E>* lc;
HuffNode<E>* rc;
int wgt;
public:
//构造内部节点
IntlNode(HuffNode<E>* l, HuffNode<E>* r)
{
wgt l->weight() + r->weight();
lc = l;
rc = r;
}

//返回节点的权值
int weight()
{
return wgt;
}

//判断节点是不是叶子节点
bool isLeaf()
{
return false;
}

//返回左子树
HuffNode<E>* left() const
{
return lc;
}

//设置左子树
void setLeft(HuffNode<E>* b)
{
lc = (HuffNode<E>*)b;
}

//返回右子树
HuffNode<E>* right() const
{
return rc;
}

//设置右子树
void setRight(HuffNode<E>* b)
{
rc = (HuffNode<E>*)b;
}
};


//Huffman树
template <typename E>
class HuffTree {
private:
HuffNode<E>* Root;
public:

//构建Huffman数(叶节点构造)
HuffTree(E& val, int freq)
{
Root = new LeafNode<E>(val, freq);
}

//构建Huffman数(内部节点构造)
HuffTree(HuffTree<E>* l, HuffTree<E>* r)
{
Root = new IntlNode<E>(l->root(), r->root());
}

//析构，释放空间?
~HuffTree()
{
if (root == NULL)
{
return;
}
else if (root->isLeaf())
{
delete root;
}
else {
IntlNode<E>* rt = (IntlNode<E>*)root;
Traverse(rt->left());
Traverse(rt->right());
delete root;
}
}

//返回根节点
HuffNode<E>* root()
{
return Root;
}

//返回根节点的权值
int weight()
{
return root->weight();
}

//遍历Huffman节点（中序遍历）
void Traverse(HuffNode<E>* root)
{
if (root == NULL)
{
return;
}
else if (root->isLeaf())
{
cout << "Leaf:"root->weight() << endl;
}
else {
IntlNode<E>* rt = (IntlNode<E>*)root;
Traverse(rt->left());
cout << "Internal:" << rt->weight() << endl;
Traverse(rt->right());
}
}
};

//最小堆的实现
template<typename E>
class heap {
private:
HuffTree<E>** Heap;
int maxsize;
int n;

//将左右子树是堆的二叉树变成堆
void siftdown(int pos)
{
while (!isLeaf(pos))
{
int j = leftchild(pos);
int rc = rightchild(pos);
if ((rc < n) && (Heap[j]->weight() > Heap[rc]->weight()))
{
j = rc;
}
if (Heap[j]->weight() > Heap[pos]->weight())
{
return;
}
swap(Heap, pos, j);
}
}
public:
//交换堆中处于frist和second位置的元素
void swap(HuffTree<E>** array, int first, int second)
{
HuffTree* Temp = array[first];
array[first] = array[second];
array[second] = temp;
}

//建堆
void buildHeap()
{
for (int i = n / 2 - 1; i >= 0; i--)
siftdown(i);
}

//堆得构造函数
heap(HuffTree<E>** h, int max, int num)
{
Heap = h;
maxsize = max;
n = num;
buildHeap();
}

//返回堆得大小
int size() const
{
return n;
}

//判断该位置的堆是不是叶节点
bool isLeaf(int pos) const
{
return (pos >= n / 2) && (pos < n);
}

//返回堆的左子孩子（传入位置）
int leftchild(int pos) const
{
return pos * 2 + 1;
}

//返回堆的右子孩子（传入位置）
int rightchild(int pos) const
{
return pos * 2 + 2;
}

//返回堆得父孩子（传入位置）
int parent(int pos) const
{
return (pos - 1) / 2;
}


//将it插入堆中
void insert(HuffTree* it)
{
int curr = n++;
Heap[curr] = it;

while ((curr！ = 0) && (Heap[parent(curr)]->weight() > Heap[curr]->weight()))
{
swap(Heap, curr, parent(curr));
curr = parent(curr);
}
}

//移除堆中的第一个元素，返回该元素值
HuffTree<E>* removefirst()
{
Assert(n > 0, "Heap is empty");
swap(Heap, 0, --n);
if (n != 0)
{
siftdown(0);
}
return Heap[n];
}

//移除指定位置的元素
E remove(int pos)
{
Assert((pos > 0) && (pos < n), "Bad position");

if (pos == (n - 1))
{
n--;
}
else
{
swap(Heap, pos, --n);

while ((pos != 0) && (Heap[parent(pos)]->weight() > Heap[pos]->weight()))
{
swap(Heap, pos, parent(pos));
pos = parent(pos);
}

if (n != 0)
siftdown(pos);
}

return Heap[n];
}

};

//建树
template<typename E>HuffTree<E>*
buildHuff(HuffTree<E>** TreeArray, int count)
{
//用给定的数组建堆
heap<HuffTree<E>*, minTreeComp>*forest =
new heap<HuffTree<E>*, minTreeComp>(TreeArray, count, count);

HuffTree<char>* temp1, *temp2, *temp3 = NULL;

//利用堆建树
while (forest->size() > 1)
{
temp1 = forest->removefirst();
temp2 = forest->removefirst();
temp3 = new HuffTree<E>(temp1, temp2);

forest->insert(temp3); //put new tree back on list

delete temp1;
delete temp2;
}
return temp3;
}

#endif
...全文
1665 10 打赏 收藏 转发到动态 举报
写回复
用AI写文章
10 条回复
切换为时间正序
请发表友善的回复…
发表回复
CodingStart 2019-09-02
  • 打赏
  • 举报
 回复
子类如果不是模板，name父类的模板在继承的时候必须实例化
www_adintr_com 2016-11-23
  • 打赏
  • 举报
 回复
class LeafNode :pulic HuffNode<E> 拼写错误
xskxzr 2016-11-23
  • 打赏
  • 举报
 回复
template <typename E> class HuffNode 最后不要加<E>。
IL_Programmer 2016-11-23
  • 打赏
  • 举报
 回复
1>------ 已启动生成: 项目: Huffman编码, 配置: Debug Win32 ------ 1> main.cpp 1>c:\users\asus\desktop\huffman编码\huffman编码\huffman.h(14): error C2988: 不可识别的模板声明/定义 1>c:\users\asus\desktop\huffman编码\huffman编码\huffman.h(14): error C2143: 语法错误: 缺少“;”(在“<”的前面) 1>c:\users\asus\desktop\huffman编码\huffman编码\huffman.h(14): error C2059: 语法错误:“<” 1>c:\users\asus\desktop\huffman编码\huffman编码\huffman.h(15): error C2143: 语法错误: 缺少“;”(在“{”的前面) 1>c:\users\asus\desktop\huffman编码\huffman编码\huffman.h(15): error C2447: “{”: 缺少函数标题(是否是老式的形式表?) 1>c:\users\asus\desktop\huffman编码\huffman编码\huffman.h(24): error C2143: 语法错误: 缺少“,”(在“<template-id>”的前面) 1> c:\users\asus\desktop\huffman编码\huffman编码\huffman.h(55): note: 参见对正在编译的类 模板 实例化“LeafNode<E>”的引用 ========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========
IL_Programmer 2016-11-23
  • 打赏
  • 举报
 回复
非常感谢，我是新手。感谢大家的帮助
paschen 版主 2016-11-23
  • 打赏
  • 举报
 回复
template <typename E> class HuffNode<E> 改成 template <typename E> class HuffNode template<typename E> class LeafNode :pulic HuffNode<E> 改成 template<typename E> class LeafNode :public HuffNode<E>
IL_Programmer 2016-11-23
  • 打赏
  • 举报
 回复
引用 6 楼 yshuise的回复:
需要有主模板呢
主模板是什么呢？
yshuise 2016-11-23
  • 打赏
  • 举报
 回复
需要有主模板呢
IL_Programmer 2016-11-23
  • 打赏
  • 举报
 回复
能帮我更正以后发出来一下吗？谢谢大家
小灸舞 2016-11-23
  • 打赏
  • 举报
 回复 

#pragma once

#ifndef HUFFMAN_H

#define HUFFMAN_H

#include <iostream>

using namespace std;

//节点类（抽象类）
template <typename E>
class HuffNode
{
public:
	virtual ~HuffNode() {}
	virtual int weight() = 0;
	virtual bool isLeaf() = 0;
};

//叶节点类（继承自节点类）
template<typename E>
class LeafNode :public HuffNode<E>
{
private:
	E it;
	int wgt;
public:

	//构造叶节点
	LeafNode(const E& val, int freq)
	{
		it = val;
		wgt = freq;
	}

	//返回该叶节点的权值
	int weight()
	{
		return wgt;
	}

	//返回节点的值
	E val()
	{
		return it;
	}

	//判断是否是叶节点
	bool isLeaf()
	{
		return true;
	}
};

//内部节点类（继承自节点类）
template <typename E>
class IntlNode :public HuffNode<E>
{
private:
	HuffNode<E>* lc;
	HuffNode<E>* rc;
	int wgt;
public:
	//构造内部节点
	IntlNode(HuffNode<E>* l, HuffNode<E>* r)
	{
		wgt l->weight() + r->weight();
		lc = l;
		rc = r;
	}

	//返回节点的权值
	int weight()
	{
		return wgt;
	}

	//判断节点是不是叶子节点
	bool isLeaf()
	{
		return false;
	}

	//返回左子树
	HuffNode<E>* left() const
	{
		return lc;
	}

	//设置左子树
	void setLeft(HuffNode<E>* b)
	{
		lc = (HuffNode<E>*)b;
	}

	//返回右子树
	HuffNode<E>* right() const
	{
		return rc;
	}

	//设置右子树
	void setRight(HuffNode<E>* b)
	{
		rc = (HuffNode<E>*)b;
	}
};


//Huffman树
template <typename E>
class HuffTree {
private:
	HuffNode<E>* Root;
public:

	//构建Huffman数(叶节点构造)
	HuffTree(E& val, int freq)
	{
		Root = new LeafNode<E>(val, freq);
	}

	//构建Huffman数(内部节点构造)
	HuffTree(HuffTree<E>* l, HuffTree<E>* r)
	{
		Root = new IntlNode<E>(l->root(), r->root());
	}

	//析构，释放空间?
	~HuffTree()
	{
		if (root == NULL)
		{
			return;
		}
		else if (root->isLeaf())
		{
			delete root;
		}
		else {
			IntlNode<E>* rt = (IntlNode<E>*)root;
			Traverse(rt->left());
			Traverse(rt->right());
			delete root;
		}
	}

	//返回根节点
	HuffNode<E>* root()
	{
		return Root;
	}

	//返回根节点的权值
	int weight()
	{
		return root->weight();
	}

	//遍历Huffman节点（中序遍历）
	void Traverse(HuffNode<E>* root)
	{
		if (root == NULL)
		{
			return;
		}
		else if (root->isLeaf())
		{
			cout << "Leaf:"root->weight() << endl;
		}
		else {
			IntlNode<E>* rt = (IntlNode<E>*)root;
			Traverse(rt->left());
			cout << "Internal:" << rt->weight() << endl;
			Traverse(rt->right());
		}
	}
};

//最小堆的实现
template<typename E>
class heap {
private:
	HuffTree<E>** Heap;
	int maxsize;
	int n;

	//将左右子树是堆的二叉树变成堆	
	void siftdown(int pos)
	{
		while (!isLeaf(pos))
		{
			int j = leftchild(pos);
			int rc = rightchild(pos);
			if ((rc < n) && (Heap[j]->weight() > Heap[rc]->weight()))
			{
				j = rc;
			}
			if (Heap[j]->weight() > Heap[pos]->weight())
			{
				return;
			}
			swap(Heap, pos, j);
		}
	}
public:
	//交换堆中处于frist和second位置的元素
	void swap(HuffTree<E>** array, int first, int second)
	{
		HuffTree* Temp = array[first];
		array[first] = array[second];
		array[second] = temp;
	}

	//建堆
	void buildHeap()
	{
		for (int i = n / 2 - 1; i >= 0; i--)
			siftdown(i);
	}

	//堆得构造函数
	heap(HuffTree<E>** h, int max, int num)
	{
		Heap = h;
		maxsize = max;
		n = num;
		buildHeap();
	}

	//返回堆得大小
	int size() const
	{
		return n;
	}

	//判断该位置的堆是不是叶节点
	bool isLeaf(int pos) const
	{
		return (pos >= n / 2) && (pos < n);
	}

	//返回堆的左子孩子（传入位置）
	int leftchild(int pos) const
	{
		return pos * 2 + 1;
	}

	//返回堆的右子孩子（传入位置）
	int rightchild(int pos) const
	{
		return pos * 2 + 2;
	}

	//返回堆得父孩子（传入位置）
	int parent(int pos) const
	{
		return (pos - 1) / 2;
	}


	//将it插入堆中
	void insert(HuffTree* it)
	{
		int curr = n++;
		Heap[curr] = it;

		while ((curr！ = 0) && (Heap[parent(curr)]->weight() > Heap[curr]->weight()))
		{
			swap(Heap, curr, parent(curr));
			curr = parent(curr);
		}
	}

	//移除堆中的第一个元素，返回该元素值
	HuffTree<E>* removefirst()
	{
		Assert(n > 0, "Heap is empty");
		swap(Heap, 0, --n);
		if (n != 0)
		{
			siftdown(0);
		}
		return Heap[n];
	}

	//移除指定位置的元素
	E remove(int pos)
	{
		Assert((pos > 0) && (pos < n), "Bad position");

		if (pos == (n - 1))
		{
			n--;
		}
		else
		{
			swap(Heap, pos, --n);

			while ((pos != 0) && (Heap[parent(pos)]->weight() > Heap[pos]->weight()))
			{
				swap(Heap, pos, parent(pos));
				pos = parent(pos);
			}

			if (n != 0)
				siftdown(pos);
		}

		return Heap[n];
	}

};

//建树
template<typename E>HuffTree<E>*
buildHuff(HuffTree<E>** TreeArray, int count)
{
	//用给定的数组建堆
	heap<HuffTree<E>*, minTreeComp>*forest =
		new heap<HuffTree<E>*, minTreeComp>(TreeArray, count, count);

	HuffTree<char>* temp1, *temp2, *temp3 = NULL;

	//利用堆建树
	while (forest->size() > 1)
	{
		temp1 = forest->removefirst();
		temp2 = forest->removefirst();
		temp3 = new HuffTree<E>(temp1, temp2);

		forest->insert(temp3);	//put new tree back on list

		delete temp1;
		delete temp2;
	}
	return temp3;
}

#endif
pcl1.8.1编译报“不可识别的模板声明/定义”
环境： VS2017 + pcl1.8.1 报错内容： 不可识别的模板声明/定义 解决方法： 点击此错误后，会打开一个
VS2019社区版——不可识别的声明模板/定义
请问，这个问题该如何处理？？？
点云库PCL从入门到精通常见的编译错误
（1）error c4996: 'fopen': This function or variable may be unsafe 解决方法：项目->属性->配置属性->C/C++ -> 预处理器 -> 预处理器定义，增加：_CRT_SECURE_NO_DEPRECATE。 参考博文：https://blog.csdn.net/wang...
【win10+pcl181+ vs2017】 常见问题与解决方法
1、vs2017 + win10+ pcl181 参考博文https://www.cnblogs.com/li-yao7758258/p/8066352.html进行的配置，但是编译无法通过。       解决方法：将vtk和pcl的lib文件名到出到记事本0.txt中，然后全部添加到“输入”依赖列表中。 --------------------------------------------...
C++ Bug解决: 模板函数或模板类的定义在.cpp文件实现，编译报错：无法解析的外部符号
项目场景： 最近实现一个单链表，使用模板类声明与定义。 问题描述： 单链表模板类声明实现在.h 文件中，该模板类定义实现在.cpp文件，发现VS2019编译失败，错误信息如下所示： 原因分析： 以前写模板函数或者模板类，定义与实现都在.h文件中实现，所以没有出现过这个问题，现在出现这种无法解析的外部符号错误，一时没想到是模板函数或模板类的声明与定义不能分离，即都要在.h文件中实现声明与定义，这里的分离指的就是分别在.h文件和.cpp文件实现声明与定义。 至于为什么模板函数或模板类的声明与实现不能分离，必
C++ 语言

64,656

社区成员

250,507

社区内容

发帖
与我相关
我的任务
社区描述
C++ 语言相关问题讨论，技术干货分享，前沿动态等
c++ 技术论坛（原bbs）
社区管理员
  • C++ 语言社区
  • encoderlee
  • paschen
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
  1. 请不要发布与C++技术无关的贴子
  2. 请不要发布与技术无关的招聘、广告的帖子
  3. 请尽可能的描述清楚你的问题，如果涉及到代码请尽可能的格式化一下

试试用AI创作助手写篇文章吧

+ 用AI写文章