C++ 为>&燃气轮机；及<&书信电报；模板类中的运算符

我正在尝试编写重载运算符“>>”和“>（class std:：basic_istream&，class MyClass&）”的函数定义（？？）？？5@YAAAV？$basic_istream@DU？$char_traits@D@std@@@std@@AAV01@AAV?$MyClass@H@@@Z） 在函数_main中引用 1> Source.obj:错误LNK2019:未解析的外部符号“class std:：basic_ostream&__cdecloperator>（class std:：basic_istream&，class MyClass&）”（？？5@YAAAV？$basic_istream@DU？$char_traits@D@std@@@std@@AAV01@AAV?$MyClass@V？$basic_string@DU？$char_traits@D@性病病毒$allocator@D@2@@std@@@@@Z）在函数\u main中引用

---

1> Source.obj:错误LNK2019:未解析的外部符号“class std:：basic_ostream&__cdecloperator在您的代码中，

MyClass

中友元运算符的声明应如下所示：

template<typename T> friend istream& operator>>(istream&, MyClass<T>&);
template<typename T> friend ostream& operator<<(ostream&, MyClass<T>);

---

打开编译器的警告级别会有所帮助。通过将

-Wall

与

g++

一起使用，我在链接器错误之前收到以下警告

socc.cc:13:58: warning: friend declaration ‘std::istream& operator>>(std::istream&, MyClass<MYTYPE>&                    )’ declares a non-template function [-Wnon-template-friend]
     friend istream& operator>>(istream&, MyClass<MYTYPE>&);
                                                          ^
socc.cc:13:58: note: (if this is not what you intended, make sure the function template has already                     been declared and add <> after the function name here)
socc.cc:14:57: warning: friend declaration ‘std::ostream& operator<<(std::ostream&, MyClass<MYTYPE>                     ’ declares a non-template function [-Wnon-template-friend]
     friend ostream& operator<<(ostream&, MyClass<MYTYPE>);

然后，您必须使用带有适当模板参数的

friend

声明

// This makes sure that operator>><int> is not a friend of MyClass<double>
// Only operator>><double> is a friend of MyClass<double>
friend std::istream& operator>><MYTYPE>(std::istream&, MyClass<MYTYPE>&);
friend std::ostream& operator<<<MYTYPE>(std::ostream&, MyClass<MYTYPE>);

//这确保操作符>>不是MyClass的朋友
//只有操作员>>是MyClass的朋友
friend std:：istream&operator>>（std:：istream&，MyClass&）；
friend std:：ostream&operator（std:：istream&，MyClass&）；
模板
std:：ostream&运算符（std:：istream&，MyClass&）；
friend std:：ostream&operator（std:：istream&X，MyClass&a）{
cout这有点复杂。实际上，有两种方法可以让一个类模板拥有一个函数友元

举个例子：

template <typename T>
void fun();

template <typename T>
class A
{
};

如果您想要的是选项1，则不需要高级声明。只需：

template <typename T>
class A
{
    //A<T> is friend to fun<X>, T and X may be different
    template <class X>
    friend void fun();
};

这里我可能错了，但我认为您不需要包含
MyClass a
参数，因为您正在重载作用于该对象的运算符。只需将其称为
this
。但要使其工作，它需要是类的一部分，我认为这是另一个问题。应该是类的一部分吗？@EastonBornemeier否，因为
MyClass
是一个右键argument@alexeykuzmin0这就是我用一种我很久没有使用过的语言来解决一个问题的结果；）它的可能的副本确实解决了这个问题。奇怪的是，我仍然明白：这个程序运行得很好，但仍然存在这个问题。
MyClass
中的friend函数声明不起作用不需要显式的
MYTYPE
模板参数：
friend std:：istream&operator>>（std:：istream&，MyClass&）
@isanae，我不知道。谢谢你的LOTD。谢谢你花时间写这篇文章！但是，它仍然拒绝为我做这件事。@Marek这样做。由于你代码的另一部分，有一个警告，但这种方法至少解决了操作符的问题。是的！谢谢你的解决方案！为误解道歉我知道你的意思。没有注意到我有那个奇怪的缩进。非常感谢你也使用了一个抽象的例子！
// Forward the class template.
template <class MYTYPE> class MyClass;

// Declare the function templates.
template <class MYTYPE> 
std::istream& operator>>(std::istream&, MyClass<MYTYPE>&);

template <class MYTYPE> 
std::ostream& operator<<(st::ostream&, MyClass<MYTYPE>);

// This makes sure that operator>><int> is not a friend of MyClass<double>
// Only operator>><double> is a friend of MyClass<double>
friend std::istream& operator>><MYTYPE>(std::istream&, MyClass<MYTYPE>&);
friend std::ostream& operator<<<MYTYPE>(std::ostream&, MyClass<MYTYPE>);

#include <iostream>
#include <string>
using namespace std;

template <class MYTYPE> class MyClass;

template <class MYTYPE> 
std::istream& operator>>(std::istream&, MyClass<MYTYPE>&);

template <class MYTYPE> 
std::ostream& operator<<(std::ostream&, MyClass<MYTYPE>);

template <class MYTYPE>
class MyClass {
    MYTYPE *myVector;
    int dim;
    string name;
public:
    MyClass(int, string);
    MyClass() {};

    friend std::istream& operator>><MYTYPE>(std::istream&, MyClass<MYTYPE>&);
    friend std::ostream& operator<<<MYTYPE>(std::ostream&, MyClass<MYTYPE>);
};

template <class MYTYPE>
MyClass<MYTYPE>::MyClass(int x, string y) {
    dim = x;
    name = y;
    myVector = new MYTYPE[dim];
}


template <class MYTYPE>
std::istream& operator>>(std::istream& X, MyClass<MYTYPE>& a){
    cout<<"Reading vector: "<<a.name<<endl;
    for(int indice = 0; indice < a.dim; indice++){
        cout<<a.name<<'['<<indice<<"]= ";
        X >> a.myVector[indice];
    }
    return X;
}

template <class MYTYPE>
std::ostream& operator<<(std::ostream& X, MyClass<MYTYPE> a){
    X<<"Vector: "<<a.name<<endl;
    for(int indice = 0; indice < a.dim; indice++)
        X<<a.myVector[indice]<<' ';
        X<<endl;
    return X;
}


int main() {
    MyClass<int> object(4, "Ints vector");
    MyClass<string> object2(5, "String vector");
    cin >> object;
    cin >> object2;
    cout << object;
    cout << object2;
    system("pause");
    return 0;
}

template <typename T>
void fun();

template <typename T>
class A
{
};

//first declare both function and class
template <typename T>
class A;
template <typename T>
void fun();

//Then define the class
template <typename T>
class A
{
    //A<T> is friend to fun<T>, the specializations must match.
    friend void fun<T>();
};

//And define the function
template <typename T>
void fun()
{
}

template <typename T>
class A
{
    //A<T> is friend to fun<X>, T and X may be different
    template <class X>
    friend void fun();
};

template <class MYTYPE>
class MyClass;

template <class MYTYPE>
istream& operator>>(istream& X, MyClass<MYTYPE>& a);

template <class MYTYPE>
ostream& operator<<(ostream&, MyClass<MYTYPE>);

template <class MYTYPE>
class MyClass {
    // ....
    friend istream& operator>> <MYTYPE>(istream&, MyClass<MYTYPE>&);
    friend ostream& operator<< <MYTYPE>(ostream&, MyClass<MYTYPE>);
};