这个模板程序有什么问题吗？

Question

我一直在尝试学习 C++ 中的模板，但我对我做错的事情感到有点困惑。有人告诉我如何在有关模板的常见问题解答中声明朋友模板，我必须使用重载的运算符来执行此操作，但这似乎给我带来了麻烦，告诉我数组中的参数数量无效（我应该有 2 个）。 cpp。有什么办法可以在保留我的操作员的同时解决这个问题。另外，简单的主文件是模板的正确语法吗？

谢谢。

Array.h：

#ifndef ARRAY_H
#define ARRAY_H
#include <stdexcept>
#include <iostream>
using namespace std;

template<typename T> class Array;
template<typename T> ostream &operator<<( ostream &, const Array<T> & );
template<typename T> istream &operator>>( istream &, Array<T> & );

template< typename T >
class Array
{


    friend ostream &operator<< <> ( ostream &, const Array<T> & );
    friend istream &operator>> <> ( istream &, Array<T> & );

 public:
    Array(  int = 10 ); 

    Array( const Array & ); 

    ~Array();

    int getSize() const; 

    const Array &operator=( const Array & ); 

    bool operator==( const Array & ) const; 


    bool operator!=( const Array &right ) const  
    { 
        return ! ( *this == right ); 
    }


    T &operator[]( T );              


    T operator[]( T ) const;  

 private:

    int size; 

    T *ptr;

};

#endif

Array.cpp

#include <iostream>
#include <iomanip>
#include <cstdlib> // exit function prototype
#include "Array.h" // Array class definition
using namespace std;

template< typename T >
Array<T>::Array( int arraySize )
{

    if ( arraySize > 0 )
        size = arraySize;
    else 
        throw invalid_argument( "Array size must be greater than 0" );

    ptr = new T[ size ]; 

    for ( int i = 0; i < size; ++i )
        ptr[ i ] = 0;

}

template< typename T >
Array<T>::Array( const Array &arrayToCopy ) 
   : size( arrayToCopy.size )
{
    ptr = new T[ size ];

    for ( int i = 0; i < size; ++i )
        ptr[ i ] = arrayToCopy.ptr[ i ];
}

template< typename T >
Array<T>::~Array()
{
    delete [] ptr; 
}

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

template< typename T >
const Array<T> &Array<T>::operator=( const Array &right )
{
    if ( &right != this )
        {

            if ( size != right.size )
                {
                    delete [] ptr;
                    size = right.size; 
                    ptr = new T[ size ]; 
                }

            for ( int i = 0; i < size; ++i )
                ptr[ i ] = right.ptr[ i ]; 
        }

    return *this;
}

template< typename T >
bool Array<T>::operator==( const Array &right ) const
{
    if ( size != right.size )
        return false;

    for ( int i = 0; i < size; ++i )
        if ( ptr[ i ] != right.ptr[ i ] )
            return false; 

   return true; 
}

template< typename T >
T &Array<T>::operator[]( T subscript )
{

    if ( subscript < 0 || subscript >= size )
        throw out_of_range( "Subscript out of range" );

    return ptr[ subscript ];
}

template< typename T >
T Array<T>::operator[]( T subscript ) const
{

    if ( subscript < 0 || subscript >= size )
        throw out_of_range( "Subscript out of range" );

    return ptr[ subscript ]; 
}

// overloaded input operator for class Array;
// inputs values for entire Array

template< typename T >
istream &Array<T>::operator>>( istream &input, Array &a )
{
    for ( int i = 0; i < a.size; ++i )
        input >> a.ptr[ i ];

    return input; // enables cin >> x >> y;
} // end function 

// overloaded output operator for class Array
template< typename T> 
ostream &Array<T>::operator<<( ostream &output, const Array &a )
{
    int i;

    // output private ptr-based array 
    for ( i = 0; i < a.size; ++i )
        {
            output << setw( 12 ) << a.ptr[ i ];

            if ( ( i + 1 ) % 4 == 0 ) // 4 numbers per row of output
                output << endl;
        } // end for

    if ( i % 4 != 0 ) // end last line of output
        output << endl;
    return output; // enables cout << x << y;
} // end function operator<<

我的主文件：

#include <iostream>

#include "Array.h"

using namespace std;


int main()

{

    Array<int> integers1( 7 ); // seven-element Array

    Array<int> integers2; // 10-element Array by default



    // print integers1 size and contents

    cout << "Size of Array integers1 is "

         << integers1.getSize()

         << "\nArray after initialization:\n" << integers1;

}

Answer 1

除了 MSN 指出的“模板源应该位于标头中”之外，源文件中重载流运算符的行还列出为：

template<typename T> istream &Array<T>::operator>>( istream &input, Array &a )
template<typename T>  ostream &Array<T>::operator<<( ostream &output, const Array &a ) 

然而，您尝试完成的操作的正确语法是使用的语法在头文件中：

template<typename T> istream &operator>>( istream &input, Array<T> &a )
template<typename T> ostream &operator<<( ostream &output, const Array<T> &a ) 

头文件中的声明通常称为非成员流运算符。但是，源文件中的定义了一个成员移位运算符，该运算符不能用于流式传输，并且必须只有 1 个参数。

如果您更改声明以匹配头文件，则应该可以消除编译器问题。也就是说，您还需要将源文件的所有内容放入头文件或包含在第一个文件末尾的单独头文件中。如果不这样做，当您尝试创建可执行文件时，您将收到链接器错误。

Answer 2

您将模板的实现放在单独的文件中，而不显式实例化您正在参数化的类型。

换句话说，您要么需要为您正在使用的类型显式实例化 Array 模板，要么需要通过模板声明使模板定义可用。即，将 .cpp 中的所有内容放入标头中。

Answer 3

声明：

template<typename T> istream &operator>>( istream &, Array<T> & );

定义：

istream &Array<T>::operator>>( istream &input, Array &a )
{

这些应该匹配。顺便说一句，声明是正确的。这也适用于 ostream 运算符

Answer 4

istream &Array::operator>>( istream &input, Array &a ) 不应位于 Array 类中。

这样，它需要一个隐式的 this 参数，但您在 &a 中显式传递所需的数组。

将该行（以及相应的operator<<）更改为istream &operator>>(istream &input, Array&a)它应该编译。由于函数重载，这不会与其他 istream 运算符混淆。