Question

我有一个类模板，它将输出存储在数组中的对象列表。我收到以下错误，我很困惑，因为错误是在.obj和.exe文件中导致错误。

1个未解析的外部（proj08.exe第1行）
未解析的外部符号“class std :: basic_ostream＆gt;＆amp; __cdecl operator＆lt;＆lt;（class std :: basic_ostream＆gt;＆amp;，class MyVector）”（?? 6 @ YAAAV？$ basic_ostream @ DU？$ char_traits @ D @ std @@@ std @@ AAV01 @ V？$ MyVector @ N @@@ Z）在函数_main（porj08.obj第1行）中引用

proj08.cpp

#include "stdafx.h"
#include <string>
#include "MyVector.h"

const double FRACTION = 0.5; 

int main()
{
    cout << "\nCreating a vector of doubles named Sam\n";
    MyVector<double> sam;

    cout << "\nPush 12 values into the vector.";
    for (int i = 0; i < 12; i++)
        sam.push_back(i + FRACTION);

    cout << "\nHere is sam: ";
    cout << sam;
    cout << "\n---------------\n";

    cout << "\nCreating an empty vector named joe";
    MyVector<double> joe;

    // test assignment
    joe = sam;

    cout << "\nHere is joe after doing an assignment:\n ";
    cout << joe;
    cout << "\n---------------\n";

    // test the copy constructor
    MyVector<double> bill = sam;

    cout << "\nHere is bill after creating it using the copy constructor:\n ";
    cout << bill;
    cout << "\n---------------\n";

    cout << endl;
    system("PAUSE");
    return 0;
}

MyVector.h

#pragma once
#include <iostream>
#include "stdafx.h"

using namespace std;

template <class T>
class MyVector
{

private:
    int vectorSize;
    int vectorCapacity;
    T *vectorArray;

public:
    MyVector() {
        vectorArray = new T[10];
    }
    T size();
    T capacity();
    void clear();
    void push_back(T n);
    T at(int n);

    friend ostream& operator<<(ostream& os, MyVector<T> vt);

    MyVector<T> operator=(MyVector<T>&);
};

/*
 * TEMPLATE FUNCTIONS
 */

//Return array size
template<class T>
T MyVector<T>::size()
{
    return vectorSize;
}

// Return array capacity
template<class T>
T MyVector<T>::capacity()
{
    return vectorCapacity;
}

// clear array values
template<class T>
void MyVector<T>::clear()
{
    for (int i = 0; i < vectorSize; i++)
    {
        vectorArray[i] = '\0';
    }

    vectorSize = 0;
    vectorCapacity = 2;
}


// Add number to array and double array size if needed
template<class T>
void MyVector<T>::push_back(T n)
{
    int test = 100;
    if (vectorCapacity > vectorSize)
    {
        vectorArray[vectorSize] = n;
        vectorSize++;

    }
    else {

        if (vectorCapacity == 0) {
            vectorArray = new T[4];
            vectorArray[0] = n;
            vectorCapacity = 4;
            vectorSize++;
        }
        else {

            int newCapacity = vectorCapacity * 2;

            // Dynamically allocate a new array of integers what is somewhat larger than the existing array.An algorithm that is often used is to double the size of the array.

            int *tempArray = new int[newCapacity];

            // Change capacity to be the capacity of the new array.

            vectorCapacity = newCapacity;

            // Copy all of the numbers from the first array into the second, in sequence.

            for (int i = 0; i < MyVector::size(); i++)
            {
                tempArray[i] = vectorArray[i];
            }

            delete[] vectorArray;
            vectorArray = new T[newCapacity];

            for (int i = 0; i < MyVector::size(); i++)
            {
                vectorArray[i] = tempArray[i];
            }

            delete[] tempArray;

            // Add the new element at the next open slot in the new array.

            vectorArray[vectorSize] = n;

            // Increment the size;

            vectorSize++;

        }
    }
}

// Return Value and given point in array
template<class T>
T MyVector<T>::at(int n)
{
    return vectorArray[n];
}

// Set one vector to equil another
template<class T>
MyVector<T> MyVector<T>::operator=(MyVector<T>& right) {

    if (vectorCapacity < right.vectorCapacity) {
        if (vectorCapacity != 0)
            delete[] vectorArray;
        vectorArray = new T[right.vectorCapacity];
        vectorCapacity = right.vectorCapacity;
    }
    vectorSize = right.size();

    // Assign values from left to right
    for (int i = 0; i < vectorSize; i++)
    {
        vectorArray[i] = right.at(i);
    }

    return *this;
}

// Cout Vector
template<class T>
ostream& operator << (ostream& os, MyVector<T> vt)
{
    T size = vt.size();

    for (T i = 0; i < size; i++) {

        os << "index " << i << " is " << vt.at(i) << endl;

    }

    return os;
}

Answer 1

如果要匹配您定义的模板，则必须将friend声明为函数模板：

template <typename U> // use U, so it doesn't clash with T
friend ostream& operator<<(ostream& os, MyVector<U> vt);

如果为类模板声明了friend函数，则不会使其成为函数模板。

Answer 2

@LogicStuff's answer is perfectly valid.我想澄清代码中究竟发生了什么，以及如何使用替代方法来避免它，因为我相信大多数C ++程序员至少在这个问题上遇到过一次。基本上，当模板被实例化时，比如说

MyVector<int> something;

然后自动将friend声明绑定到模板类型，在本例中为int，因此编译器生成

friend ostream& operator<<(ostream& os, MyVector<int> vt);

但是，这只是一个声明。你的后一个定义

template<class T>
ostream& operator << (ostream& os, MyVector<T> vt)

与int无关，因为前者是更好的匹配，无论何时尝试

cout << something;

编译器尝试调用int版本（没有定义）。所以你得到一个链接器错误。

另一种广泛使用的方法是定义您的运算符内联类，如

friend ostream& operator << (ostream& os, MyVector<T> vt)
{
    T size = vt.size();

    for (T i = 0; i < size; i++) {

        os << "index " << i << " is " << vt.at(i) << endl;

    }

    return os;
}

现在，MyVect的每个实例化都会生成与相应模板类型相关的operator<<的有效定义。请注意，运算符本身不是成员函数，并且只能通过Argument Dependent Lookup (ADL)在全局命名空间中显示。这个技巧被称为朋友名称注入，在the Barton–Nackman trick中广泛使用，你可以成功使用它，因为在像

这样的调用中

cout << something;

电话转换为

operator<< (std::cout, something)

并且something的类型为MyVector<int>，operator<<的定义可通过ADL找到。如果您operator<<需要， int作为第二个参数，它不会通过ADL找到，因为基本类型没有关联的命名空间。

C ++ - 如何为类模板

2 个答案: