#include "stdafx.h"
#include<iostream>
using namespace std;
//---------------------
class TNode
{
    friend class TList;
    friend ostream& operator<<(ostream& os,TNode& node);
public:
    TNode(int data=0);
   
private:
    int m_data;
    TNode* next;
};
ostream& operator<<(ostream& os,TNode& node)
{
    os<<node.m_data;
    return os;
}
TNode::TNode(int data)
{
    m_data = data;
    next = NULL;
}

//----------------------
class TList
{
public:
    void InsertFirst(int data);
    void InsertLast(int data);
public:
    void Show();
private:
    TNode* Tail();
private:
    TNode head;
};
void TList::Show()
{
    TNode* p = this->head.next;
    while(p != NULL)
    {
        cout<<(*p)<<" ";
        //
        p = p->next;
    }
    cout<<endl;
   
}
TNode* TList::Tail()
{
    //节点的next==NULL
    TNode* p = &head;
    while(p->next != NULL)
         p = p->next;
    return p;
}
void TList::InsertLast(int data)
{
    //找到最后一个节点
    TNode* last = Tail();
    //创建一个新节点：构造函数中赋值
    TNode* pNode = new TNode(data);
    //插入链表：位置
    last->next = pNode;

}
void TList::InsertFirst(int data)
{
    //创建一个新节点：构造函数中赋值
    TNode* pNode = new TNode(data);
    //插入链表：位置
    pNode->next = this->head.next;
    this->head.next = pNode;
}
//=========================================
//
template<class T>
T Add(T x,T y)
{
    return x+y;
}
//----------------------------------------
int main(int argc, char* argv[])
{
    TList lst;
    lst.InsertFirst(1);
    lst.InsertFirst(10);
    lst.InsertFirst(19);
    lst.InsertLast(29);
    lst.InsertLast(129);

    lst.Show();

    int n = Add(1,10);
    double fn = Add<double>(1.0,2.3);
    //------------------------
    return 0;
}

error C2248: 'm_data' : cannot access private member declared in class 'TNode'
        list\list.cpp(16) : see declaration of 'm_data'
list\list.cpp(48) : error C2593: 'operator <<' is ambiguous

什么意思啊这错误

ostream& operator<<(ostream& os,TNode& node)
{
    os<<node.m_data;
    return os;
}

m_data是私有的,你怎么可能能调用得到?

你把错误翻译过来就可以基本知道是什么意思了，多思考

不能访问私有成员cannot access private member

m_data是私有的,你要明白变量的权限，只有弄清楚这后，才能真确调用

直接在node里把data设置为公有成员就行了，在TList里设置成公有成员函数就行了具体不太好说，我也做过一个，跟你的不太一样，意思差不多，你看看懂不
#include <iostream>
#include <cassert>
using namespace std;

template <class T>
class Node {
public:
    Node<T> *next;    //指向后继结点的指针
    T data;    //数据域
    Node (const T &data, Node<T> *next = 0);    //构造函数
    void insertAfter(Node<T> *p);    //在本结点之后插入一个同类结点p
    Node<T> *deleteAfter();    //删除本结点的后继结点，并返回其地址
    Node<T> *nextNode();            //获取后继结点的地址
};
//类的实现部分
//构造函数，初始化数据和指针成员
template <class T>
Node<T>::Node(const T& data, Node<T> *next/* = 0 */) : data(data), next(next) { }
  
//返回后继结点的指针
template <class T>
Node<T> *Node<T>::nextNode() {
    return next;
}

//在当前结点之后插入一个结点p
template <class T>
void Node<T>::insertAfter(Node<T> *p) {
    p->next = next; //p结点指针域指向当前结点的后继结点
    next = p;     //当前结点的指针域指向p
}
//删除当前结点的后继结点，并返回其地址
template <class T>
Node<T> *Node<T>::deleteAfter() {
    Node<T> *tempPtr = next;    //将欲删除的结点地址存储到tempPtr中
    if (next == 0)    //如果当前结点没有后继结点，则返回空指针
        return 0;
    next = tempPtr->next;    //使当前结点的指针域指向tempPtr的后继结点
    return tempPtr;            //返回被删除的结点的地址
}


template <class T>
class LinkedList {
   
private:
    //数据成员：
    Node<T> *front;//头指针
    Node<T> *currPtr; //当前指针
    int size;

public:
    LinkedList();   
    bool isEmpty() const;
    void reset();//初始化指针位置
    bool next();//指向下一给节点
    bool endOfList() const;
    void insertFront(const T &item);
    void insertRear(const T &item);
    bool insertAt(const T &item);
    bool insertAfter(const T &item);
    T& data();

};

template <class T>
LinkedList<T>::LinkedList()
{
    front=NULL;
    currPtr=NULL;
    size=0;
}

template <class T>
void LinkedList<T>::reset()
{
    if(front!=NULL)
    {
    currPtr=front;
    }
}

template <class T>
bool LinkedList<T>::next()
{
    if(currPtr==NULL)
        return false;
    if(currPtr->next==NULL)
        return false;
    currPtr=currPtr->next;
    return true;
}                                   

template <class T>
T &LinkedList<T>::data()
{
    assert(currPtr!=NULL);
    return currPtr->data;

}

template <class T>
void LinkedList<T>::insertFront(const T &item)
{
    Node<T> *p = new Node<T>(item);
    p->next = front;
    front = p;
    size++;
    if(size == 1)
    {
        currPtr = front;

    }
   
}

template <class T>
void LinkedList<T>::insertRear(const T &item)
{

    while(currPtr->next!=NULL)
            currPtr=currPtr->next;
    Node<T>*  pNewNode=new Node<T>(item);
            currPtr->insertAfter(pNewNode);
    size++;
   
}

template <class T>
bool  LinkedList<T>::insertAt(const T &item)
{
    if(currPtr==NULL)
    {
        return false;
    }
    if(currPtr==front)
    {
        insertFront(item);
        return true;
    }
        Node<T>*p=front;
        while(p->next!=currPtr)
            p=p->next;
        Node<T>*pNewNode=new Node<T>(item);
            p->insertAfter(pNewNode);
        size++;
        
        return true;
}

template <class T>
bool  LinkedList<T>::insertAfter(const T &item)
{
    if(currPtr==NULL)
    {
        return false;
    }
    if(currPtr->next==NULL)
    {
        insertRear(item);
        return true;
    }
        Node<T>*p=front;
        while(p->next!=currPtr->next)
            p=p->next;
        Node<T>*pNewNode=new Node<T>(item);
        p->insertAfter(pNewNode);
        size++;
        
        return true;
}


template <class T>
bool LinkedList<T>::isEmpty() const
{
    if(front==NULL)
    {
        cout<<"The list is empty."<<endl;
        return true;
    }
}

template <class T>
bool LinkedList<T>::endOfList() const
{
    if(currPtr->next==NULL)
    {
        cout<<"The list is end."<<endl;
        return true;
    }
}

int main()
{
    LinkedList<int> A;
    A.insertFront(12);
    A.insertAt(13);
    A.reset();
    A.insertAfter(15);
    A.next();
    cout<<A.data()<<endl;

return 0;
}

不是已经定义友元了吗，那个是友元函数

恩  那个运算符重载的怎么回事啊