c++ - 使用模板类重载友元运算符-6ren

c++ - 使用模板类重载友元运算符

转载作者：行者123 更新时间：2023-11-28 04:41:09

<分区>

我正在尝试创建一个链表模板类。然而，编译后，我得到了这个错误

undefined reference to `std::ostream& operator<< <int>(std::ostream&,
Link_List<int> const&)
undefined reference to `std::istream& operator<< <int>(std::istream&,
Link_List<int> &)

示例代码如下:

链接列表.h

#ifndef LINK_LIST
#define LINK_LIST

#include <iostream>
using namespace std;

template <typename T>
struct Int_Node
{
    T value;
    Int_Node<T> *pre, *next;
};

template <typename T>
class Link_List
{
    template <typename U>
    friend ostream &operator<<(ostream &, const Link_List<U> &);    // print all integers in the list
    template <typename U>
    friend istream &operator>>(istream &, Link_List<U> &);          // input a value at the back of the list, like insert_node(val);

public:
    Link_List();                                        // default constructor
    Link_List(const Link_List &);                       // copy constructor
    ~Link_List();
    int getSize() const;

    const Link_List &operator=(const Link_List &);      // assignment operator
    bool operator==(const Link_List &) const;           // equality operator
    bool operator!=(const Link_List &right) const       // inequality operator
    {
        return !(*this == right);
    }

    T &operator[](int index);                           // subscript operator for non-const objects
    T operator[](int index) const;                      // subscript operator for const objects

    bool insert_node(T value);                          // insert an integer at the back of link list
    bool delete_node();                                 // delete the last node
    bool insert_node(int index, T value);               // insert an integer after the i_th position
    bool delete_node(int index);                        // delete the i_th node

private:
    int size;
    Int_Node<T> *head, *tail;                               // pointer to the first and the last element of Link_List
};

#endif // LINK_LIST

实现.cpp

#include <iostream>
#include "Link_List.h"

using namespace std;

template <typename T>
Link_List<T>::Link_List()
{ 
    head = tail = NULL;
    size = 0;
}

template <typename T>
Link_List<T>::Link_List(const Link_List &LL)
{
    Int_Node<T> *ptr1, *ptr2, *ptrPre;

    if (LL.head == NULL)
    {
        head = tail = NULL;
        size = 0;
    }
    else
    {
        head = new Int_Node<T>;

        head -> value = LL.head -> value;

        ptr1 = ptrPre = head;
        ptr2 = LL.head -> next;

        while (ptr2 != NULL)
        {
            ptr1 -> next = new Int_Node<T>;
            ptr1 = ptr1 -> next; // ptr1 to next node
            ptr1 -> value = ptr2 -> value;
            ptr1 -> pre = ptrPre;
            ptrPre = ptrPre -> next; // ptrPre to next node
            ptr2 = ptr2 -> next;
        } // next
        ptr1 -> next = NULL;
        tail = ptr1; // tail to the last node
        size = LL.size;
    } // generate node
}

template <typename T>
Link_List<T>::~Link_List()
{
}

template <typename T>
ostream &operator<<(ostream &os, const Link_List<T> &LL)
{
    Int_Node<T> *ptr;
    ptr = LL.head;
    while (ptr != NULL)
    {
        os << ptr -> value << " ";
        ptr = ptr -> next;
    }
    os << endl;
    delete ptr;

    return os;
}

template <typename T>
istream &operator>>(istream &is, Link_List<T> &LL)
{
    Int_Node<T> *ptr;

    if (LL.head == NULL)
    {
        LL.head = LL.tail = new Int_Node<T>;

        is >> LL.head -> value;
        LL.size++;
    }
    else
    {
        ptr = LL.head;

        LL.tail -> next = new Int_Node<T>;
        LL.tail = LL.tail -> next;
        LL.tail -> pre = ptr;
        ptr = ptr -> next;
        LL.tail -> next = NULL;

        is >> LL.tail -> value;
        LL.size++;
    }

    return is;
}

template <typename T>
int Link_List<T>::getSize() const
{
    return size;
}

template <typename T>
const Link_List<T> &Link_List<T>::operator=(const Link_List<T> &LL)
{
    Int_Node<T> *ptr1, *ptr2, *ptrPre;

    if (LL.head == NULL)
    {
        head = tail = NULL;
        size = 0;
    }
    else
    {
        head = new Int_Node<T>;

        head -> value = LL.head -> value;

        ptr1 = ptrPre = head;
        ptr2 = LL.head -> next;

        while (ptr2 != NULL)
        {
            ptr1 -> next = new Int_Node<T>;
            ptr1 = ptr1 -> next; // ptr1 to next node
            ptr1 -> value = ptr2 -> value;
            ptr1 -> pre = ptrPre;
            ptrPre = ptrPre -> next; // ptrPre to next node
            ptr2 = ptr2 -> next;
        } // next
        ptr1 -> next = NULL;
        tail = ptr1; // tail to the last node
        size = LL.size;
    } // generate node

    return *this;
}

template <typename T>
bool Link_List<T>::operator==(const Link_List<T> &LL) const
{
    Int_Node<T> *ptr1, *ptr2;

    ptr1 = head;
    ptr2 = LL.head;
    while (ptr1 != NULL)
    {
        if (ptr1 -> value != ptr2 -> value)
            return false;
        ptr1 = ptr1 -> next;
        ptr2 = ptr2 -> next;
    }
    return true;
}

//template <typename T>
//bool Link_List<T>::operator!=(const Link_List<T> &right) const
//{
//  Int_Node<T> *ptr1, *ptr2;
//  
//  ptr1 = head;
//  ptr2 = right.head;
//  while (ptr1 != NULL)
//  {
//      if (ptr1 -> value != ptr2 -> value)
//          return true;
//      ptr1 = ptr1 -> next;
//      ptr2 = ptr2 -> next;
//  }
//  return false;
//}

template <typename T>
T &Link_List<T>::operator[](int index)
{
    int count = 0;
    Int_Node<T> *ptr;

    ptr = head;
    while (count < index - 1)
    {
        ptr = ptr -> next;
        count++;
    }

    return ptr -> value;
}

template <typename T>
T Link_List<T>::operator[](int index) const
{
    int count = 0;
    Int_Node<T> *ptr;

    ptr = head;
    while (count < index - 1)
    {
        ptr = ptr -> next;
        count++;
    }

    return ptr -> value;    
}

template <typename T>
bool Link_List<T>::insert_node(T value)
{
    Int_Node<T> *ptr;

    if (head == NULL)
    {
        head = tail = new Int_Node<T>;
        head -> pre = NULL;
        head -> value = value;
        head -> next = NULL; 
    } // if no node
    else
    {
        ptr = tail;
        tail -> next = new Int_Node<T>;
        tail = tail -> next; // to next
        tail -> value = value;
        tail -> pre = ptr;
        tail -> next = NULL;

        ptr = ptr -> next;
    }
    size++;
    return true;
}

template <typename T>
bool Link_List<T>::delete_node()
{
    if (head != NULL)
    {
        if (tail -> pre != NULL)
        {
            tail = tail -> pre;
            tail -> next = NULL;
        }
        else
        {
            head = tail = NULL;
        }
        size--;
        return true;
    }
    else
    {
        size--;
        return false;
    }
}

template <typename T>
bool Link_List<T>::insert_node(int index, T value)
{
    if (index > size)
        return false;

    int count = 0;
    Int_Node<T> *ptr, *node;

    ptr = head;
    while (count < index - 1)
    {
        ptr = ptr -> next;
        count++;
    }

    if (ptr -> next != NULL)
    {
        node = new Int_Node<T>;
        node -> pre = ptr;
        node -> value = value;
        node -> next = ptr -> next;
        ptr -> next = node;
    } // not the last node
    else
    {
        node = new Int_Node<T>;
        node -> pre = tail;
        node -> value = value;
        node -> next = NULL;
        tail = node;
    } // last node
    return true;
}

template <typename T>
bool Link_List<T>::delete_node(int index)
{
    if (index > size)
        return false;

    int count = 0;
    Int_Node<T> *ptr;

    ptr = head;
    while (count < index - 1)
    {
        ptr = ptr -> next;
        count++;
    }
    ptr -> next = ptr -> next -> next; // skip the next node

    return true;
}    
template class Int_Node<char>;
template class Int_Node<float>;
template class Int_Node<int>;

template class Link_List<char>;
template class Link_List<float>;
template class Link_List<int>;

主要.cpp

#include <iostream>

#include "Link_List.h"

using namespace std;

int main()
{

    // test default constructor
    Link_List<int> linkList1;

    // test copy constructor
    Link_List<int> linkList2(linkList1);

    // test getSize()
    cout << "linkList2 Size: " << linkList2.getSize() << endl;

    // test insert_node(value), delete_node(), operator<<, operator>>

    Link_List<int> linkList3;
    cout << "Enter a integer: ";
    cin >> linkList3;
    cout << "linkList3: "<< linkList3 << endl;

    linkList3.insert_node(11);
    linkList3.insert_node(12);
    linkList3.insert_node(13);
    linkList3.insert_node(14);
    linkList3.insert_node(15);
    cout << "Insert Boolean: " << linkList3.insert_node(16) << endl;
    cout << "linkList3: " << linkList3 << endl;

    cout << "Delete Boolean: " << linkList3.delete_node() << endl;
    cout << "linkList3: " << linkList3 << endl;

    // test assignment operator, equality operator, insert_node(index, value), delete_node(index)
    Link_List<int> linkList4 = linkList3;
    cout << "linkList4: " << linkList4 << endl;

    cout << "Insert Boolean: " << linkList4.insert_node(3, 17) << endl;
    cout << "linkList4: " << linkList4 << endl;

    cout << "Delete Boolean: " << linkList4.delete_node(4) << endl;
    cout << "Equality Boolean: " << (linkList4==linkList3) << endl;
    cout << "linkList4: " << linkList4 << endl;

    // test subscript operator []
    const Link_List<int> linkList5 = linkList4;
    cout << "linkList4[1]: " << linkList4[1] << endl;
    cout << "linkList5[1]: " << linkList5[1] << endl;

    return 0;
}

我不确定错误是来自编译器还是我的代码。

根据这篇文章overloading friend operator<< for template class，我已经尝试了外向和内向的方法。但他们都没有工作。我应该怎么做才能使其适用于我的情况？

编辑:将显式实例移到 implementation.cpp 的末尾

编辑:它在我添加以下实例时起作用

template ostream& operator<<(ostream &, const Link_List<char> &);
template ostream& operator<<(ostream &, const Link_List<float> &);
template ostream& operator<<(ostream &, const Link_List<int> &);

template istream &operator>>(istream &, Link_List<char> &);
template istream &operator>>(istream &, Link_List<float> &);
template istream &operator>>(istream &, Link_List<int> &);

文章推荐： c# - Alt 标签在 IE 中显示不正确

文章推荐： javascript - 我如何添加另一条线以使其成为多线图？

文章推荐： html - 需要有关悬停的 css 规则的帮助

文章推荐： javascript - 调用 Angular 资源后， Angular 页面未加载

C++:重载 != When == 重载
假设我有一个类，我在其中重载了运算符 == : Class A { ... public: bool operator== (const A &rhs) const; ... };
c++ - 为什么 std::map 没有 find/lower_bound 重载，std::list 没有 sort 重载？
我知道你不应该使用 std::find(some_map.begin(), some_map.end()) 或 std::lower_bound，因为它会采用线性时间而不是 some_map.lowe
haskell - 重载(+)
我正在尝试在 Haskell 中定义 Vector3 数据类型，并允许在其上使用 (+) 运算符。我尝试了以下方法: data Vector3 = Vector3 Double Double Doub
C++ 重载 `-`
我已经为我的类图将运算符重载为“-”。它的用途并不完全直观(糟糕的编码 - 我知道)但是如果我做 graph3 = graph2-graph1 那么图 3 是应该只接收图 2 和图 1 中的那些顶点。
C++重载
这个问题在这里已经有了答案: 关闭 11 年前。 Possible Duplicate: Operator overloading 我想重载以按字母顺序排列字符串，但我不确定该怎么做。如何再次
C++重载
下面的代码给我一个编译错误。谁能告诉我为什么？ class mytype { public: int value; mytype(int a) { value = a;
Ruby += 重载
这有什么问题吗？ class Vec2 attr_accessor :x, :y # ... def += (v) @x += v.x @y += v.y retu
c++ - 运算符 [][] 重载
是否可以重载 [] 运算符两次？允许这样的事情:function[3][3](就像在二维数组中一样)。如果可能的话，我想看看一些示例代码。最佳答案您可以重载 operator[] 以返回一个对象
lua 重载 : possibilities?
我的团队目前正在与 Lua 合作，创建一个 android 游戏。我们遇到的一件事是表面上无法创建重载构造函数。我习惯于使用默认值设置一个对象，然后在需要时使其过载。前任: apples() {
CSS 样式继承/重载
我有一个网页，在某个时候显示一个导航栏，它只不过是一个 a 元素的列表 (ul)。所述 a 元素的大多数样式规则都是通用的。唯一应该改变的部分是要显示的图像，可以从列表中每个 li 元素的 id 标签
F# (.. ..) 运算符使用/重载
我对使用/重载“范围步长”运算符(.. ..)很感兴趣，但我终其一生都无法了解如何使用它。在文档中它说 // Usage: start .. step .. finish 但是在 F# shell
Java静态多态(重载)和泛型之间的继承
Java 11(可能无关紧要): public static String toString(Object obj) { return ReflectionToStringBuilder.to
.net - 重载、覆盖和隐藏？
就目前而言，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引起辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the he
java - 无法理解java中的继承和覆盖/重载
我无法理解以下代码(针对行号进行注释) class Base { void m1(Object o) { } void m2(String o) { } } publi
c++ - 关于运算符+重载
我有以下代码片段: #include using namespace std; struct Integer{ int x; Integer(const int val) : x(v
c++ - 重载=运算符时如何获取数组的长度
class myclass{ //definitions here }; myclass e; int myarray[10]; /* Do something... */ e = myarray;
c++ - 使用好友功能进行Operator []重载
为什么不能将下标运算符(operator [])作为 friend 函数重载？最佳答案正如Bjarne Stroustrup在D&E book中所说: However, even in the o
c++ - 关于运算符+重载
我有以下代码片段: #include using namespace std; struct Integer{ int x; Integer(const int val) : x(v
c++ - 重载<<运算符导致其模棱两可
因此，我有一个问题是我最近尝试重载 namespace Eng { /** * A structure to represent pixels */ typedef
java - 重载 onResume()
如何重载onResume()以正确的方式工作？我想从 activity 返回到 MainActivity ，我希望在其中具有与应用程序启动后相同的状态。我想使用 recreate() 但它循环了或者类

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - 使用模板类重载友元运算符