4

我正在尝试制作一个通用矢量类，既是为了我自己的代码片段库，也是为了练习模板类。本质上，Vector 类是模板化的，允许您选择它的精度是 float、double、long double 等。

我遇到的问题是为了缩放向量而重载 * 运算符。排除所有工作重载和成员函数后，类定义如下所示：

#pragma once

#include <math.h>   //  for sqrt function when normalizing

template <typename T> class Vector;
template <typename T> Vector<T> operator*(const Vector<T>& obj);

template <typename T> class Vector {
private:
    //  Attributes:
    static const int DIMS = 3;
    T component[DIMS];

public:
    enum { 
        X, Y, Z
    };

public:
    //  Constructors:
    Vector(void) {
        for (int i=0; i<DIMS; ++i) {
            component[i] = T();
        }
    }
    Vector(T x, T y, T z) {
        component[X] = x;
        component[Y] = y;
        component[Z] = z;
    }

    //  Destructor:
    ~Vector(void) { }

    //  Scaling:
    friend Vector<T> operator*(const Vector<T>& obj);
    Vector operator*(const T scale) {
        Vector<T> result = Vector<T>();

        for (int i=0; i<DIMS; ++i) {
            result.component[i] = component[i] * scale;
        }

        return result;
    }
};

template <typename T>
Vector<T> operator*(const Vector<T>& obj) {
    Vector<T> result = Vector<T>();

    for (int i=0; i<DIMS; ++i) {
        result.component[i] = obj.component[i] * this*;
    }

    return result;
}

在我的主要方法中，我有以下几行代码：

Vector<float> testVector1 = Vector<float>(1.0f, 0.0f, 0.0f);
Vector<float> testVector2 = Vector<float>(0.0f, 1.0f, 0.0f);
Vector<float> testVector3 = 10.0f * testVector1;
Vector<float> testVector4 = testVector2 * 10.0f;

除了一个错误之外，一切都编译得很好：虽然 main() 中的第四行工作正常（将向量乘以标量），但第三行（将标量乘以向量）给了我错误：

Error 1 error C2677: binary '*' : no global operator found which takes type 'Vector<T>' (or there is no acceptable conversion)

我对这个问题的最佳猜测是编译器不知道我试图重载哪个原语的 * 运算符，而且我不能直接告诉它，因为类在传递到模板之前不会知道类型。有没有办法完成我正在尝试做的事情，或者模板必须始终遵循运算符重载的类？

更新： 多亏了 jwismar 和其他人，我发现了左手超负荷的错误尝试。类中函数的定义现在是：

friend Vector<T> operator*(T scalar, const Vector<T>& obj);

它的实现是：

template <typename T> 
Vector<T> operator*(T scalar, const Vector<T>& obj) {
    Vector<T> result = Vector<T>();

    for (int i=0; i<DIMS; ++i) {
        result.component[i] = obj.component[i] * scalar;
    }

    return result;
}

类上方重载的初始声明是 now template <typename T> Vector<T> operator*(T scalar, const Vector<T>& obj);，但无论它是否被注释掉，我都会得到相同的错误。

现在我要讨论一个关于模板和运算符重载的更具体的问题。编译器现在停止编译，尽管错误现在是未解决的外部错误：

Error 1 error LNK2019: unresolved external symbol "class Vector<float> __cdecl operator*(float,class Vector<float> const &)" (??D@YA?AV?$Vector@M@@MABV0@@Z) referenced in function _main C:\Users\D03457489\Desktop\UVCTester\UVCTester\main.obj UVCTester

所以编译器告诉我它可以找到定义operator*(float, Vector<float>)但找不到实现。所以新的问题是：这是我的另一个基本疏忽的结果，还是不可能以这种方式使用模板来生成操作数左侧未知的运算符重载？

4

4 回答 4

1

operator*是一个二元运算符，它需要两个参数，这意味着您可以将其实现为应用于左侧并接受参数（右侧）的成员函数或作为接受两个参数的自由函数。通常最好将其实现为自由功能。当您希望能够实现时更是如此，double*Vector<T>因为左侧不是一个类。该重载的签名将是：

template <typename T>
Vector<T> operator*( T d, Vector<T> v );

您可能要添加的内容：

template <typename T>
Vector<T> operator*( Vector<T> v, T d );
于 2012-08-02T01:44:52.150 回答
1

不是第 4 行有错误，而是第 3 行。编译器正在寻找一个在左侧有一个浮点数的内置函数，但它找不到。您将需要定义一个自由函数，例如：

template <typename T> Vector<T> operator*(T scalar, const Vector<T>& obj);
于 2012-08-01T23:36:56.783 回答
0

试试这个函数签名（未测试）：

template <typename T, typename F>
Vector<T> operator*(const F &lhs, const Vector<T>& rhs);

它应该允许以下语句：

auto vec = f * other_vec;

对于任何F具有已定义运算符的类型：

template <typename F, typename T>
undetermined operator*(const F& lhs, const T &rhs);

whereT是用于 的类型Vector<T>，并且返回的类型可以隐式转换为T。

所以以下可能会起作用：

long l;
float f;
int i;
//.......

Vector<float> v1;
v2 = l * v1;
v3 = f * v2;
v4 = i * v3;
于 2012-08-01T23:37:45.770 回答
0

您需要定义一个函数，允许在*. 幸运的是，这相对容易实现：

template <typename T>
Vector<T> operator*(const T scale, const Vector<T> &v) {
    Vector<T> result = v;
    return result * scale;
}

您在两个 s 之间进行组件明智乘法的其他函数Vector未正确声明和实现。它不需要成为朋友：

/*friend*/ Vector<T> operator*(const Vector<T>& obj);

并将其作为类的方法实现：

template <typename T>
Vector<T> Vector<T>::operator*(const Vector<T>& obj) {
    Vector<T> result = Vector<T>();

    for (int i=0; i<DIMS; ++i) {
        result.component[i] = obj.component[i] * component[i];
    }

    return result;
}
于 2012-08-02T00:31:41.900 回答