c++ 中的模板

[Sou2012]

刚看完一遍C++ primer， 后面的懂了，前面的又忘记了

不过我没怎么做练习， 我打算先快速的看一下，然后来复习，精读几次，结合练习，

以下是书上的例子，大家帮忙改进成一个

完善点的 队列？

#ifndef _QUEUE_H_
#define _QUEUE_H_

template <typename Type> class Queue;

template <typename Type> std::ostream& operator<<(std::ostream&, const Queue<Type>&);

template <typename Type> class QueueItem {
	friend class Queue<Type>;
	friend std::ostream& operator<< <Type> (std::ostream&, const Queue<Type>&);

	QueueItem(const Type &t): item(t), next(0) {}
    Type item;
	QueueItem *next;
};

template <typename Type> class Queue {
public:
	friend std::ostream& operator<< <Type> (std::ostream&, const Queue<Type>&);

    Queue(): head(0), tail(0) {}
	template <typename It> Queue(It beg, It end): head(0), tail(0) {}
	Queue(const Queue &q): head(0), tail(0)
			{ copy_element(q); }
	Queue& operator=(const Queue&);
	~Queue() { destroy(); }
	
	template <typename Iter> void assign(Iter, Iter);
	Type& front() { return head->item; }
	const Type& front() const { return head->item; }
	Type& back() { return tail->item; }
	void push(const Type &val);
	void pop();
	size_t length() const;
	bool empty() const { return head == 0; }
private:
	QueueItem<Type> *head;
	QueueItem<Type> *tail;
	void destroy();
	void copy_element(const Queue&);
	template <typename Iter> void copy_element(Iter, Iter);
};

template <typename Type> inline size_t Queue<Type>::length() const
{
    size_t size = 0;
    QueueItem<Type> *p = head;
    while (p)
    {
        ++size;
        p = p->next;
    }
    return size;
}

template <typename Type> 
Queue<Type>& Queue<Type>::operator=(const Queue &rhs)
{        
    if (this != &rhs) {
        destroy();
	    copy_element(rhs);
    }
    return *this;
}

template <typename Type> void Queue<Type>::destroy()
{
    while (!empty())
	{
	    pop();
	}
}

template <typename Type> void Queue<Type>::pop()
{
    QueueItem<Type> *p = head;
	head = head->next;
	delete p;
}

template <typename Type> void Queue<Type>::push(const Type &val)
{
    QueueItem<Type> *p = new QueueItem<Type>(val);
	if (empty()) 
	{
	    head = tail = p;
	}
	else
	{
	    tail->next = p;
		tail = p;
	}
}

template <typename Type> 
template <typename Iter> void Queue<Type>::assign(Iter beg, Iter end)
{
    destroy();
	copy_element(beg, end);
}

template <typename Type> 
void Queue<Type>::copy_element(const Queue<Type> &rhs)
{
    for (QueueItem<Type> *pt = rhs.head; pt; pt = pt->next)
	{
	    push(pt->item);
	}
}

template <typename Type>
template <typename Iter> void Queue<Type>::copy_element(Iter beg, Iter end)
{
    while (beg != end)
	{
		push(*beg);
	    ++beg;
	}
}

template <typename T> std::ostream& operator<<(std::ostream &os, const Queue<T> &q) 
{
	os << " < ";
	QueueItem<T> *pqi;
    for (pqi= q.head; pqi; pqi = pqi->next)
	{
	    os << pqi->item << " ";
	}
	os << " > ";
	os << " length: " << q.length() << std::endl;
	return os;
}

#endif

[冷月清晖]

这个队列有何问题？

[冷月清晖]

这个队列有何问题?

[yshuise]

、不要用friend关键字。这是一种强耦合。

[Sou2012]

[Quote=引用 3 楼 yshuise 的回复:]
、不要用friend关键字。这是一种强耦合。
[/Quote]

友元 有时候，是一种强耦合，

但是有时候，可以隐藏实现细节

应该要看情况吧，个人意见，多拍砖

[yshuise]

[Quote=引用 4 楼 ilysony 的回复:]
引用 3 楼 yshuise 的回复:
、不要用friend关键字。这是一种强耦合。


友元 有时候，是一种强耦合，

但是有时候，可以隐藏实现细节

应该要看情况吧，个人意见，多拍砖
[/Quote]
不存在“有时候”。

[Sou2012]

[Quote=引用 5 楼 yshuise 的回复:]
引用 4 楼 ilysony 的回复:
引用 3 楼 yshuise 的回复:
、不要用friend关键字。这是一种强耦合。


友元 有时候，是一种强耦合，

但是有时候，可以隐藏实现细节

应该要看情况吧，个人意见，多拍砖

不存在“有时候”。
[/Quote]

请仁兄说说 friend 怎么用，

应该适合出现在什么场合？

[yshuise]

第二：应该用迭代器来实现。这是一种流行的方式。

[taodm]

“完善”的定义是什么？

[yshuise]

用friend就没有完全了解c++, herb sutter 对这个已经有详细讨论了。
可以见《c++ 编程规范》

[yshuise]

第三：自己不可以定制内存分配器。
（当然这些要求比较高，按照库的要求，初学就算了）

[Sou2012]

[Quote=引用 9 楼 yshuise 的回复:]
用friend就没有完全了解c++, herb sutter 对这个已经有详细讨论了。
可以见《c++ 编程规范》
[/Quote]
多谢指点，我会学习的