重载模板 Polynom 类的运算符[]

Question

我正在编写一个模板 Polynom 类，其中 T 是其系数的数字类型。

多项式的系数存储在 std::vector中。系数，其中coefficients[i] 对应于实数多项式中的x^i。 （因此 x 的幂按递增顺序排列）。

保证coefficients向量始终包含至少一个元素。 - 对于零多项式，它是T()。

我想重载operator[]来执行以下操作：

1. 传递给operator[]的索引对应于我们要修改/读取其系数的X的幂。
2. 如果用户只想读取系数，则应该抛出负索引，对于存储范围内的索引返回coefficients.at(i) - 并且合理 对于所有其他索引返回 0，而不是抛出。
3. 如果用户想要修改系数，则应该抛出负索引，但让用户自由修改所有其他索引，即使指定的索引大于或等于coefficients.size( ）。所以我们想以某种方式调整向量的大小。

我遇到的主要问题如下：

1.

如何区分读情况和写情况？一个人没有给我任何解释，但说写两个版本

const T& operator[] (int index) const;
T& operator[] (int index);

是不够的。但是，我认为编译器在读取情况下更喜欢 const 版本，不是吗？

2.

我想确保系数向量中不存储任何尾随零。因此，我必须以某种方式提前知道，“在我返回系数的可变 T& 之前”，用户想要分配什么值。我知道 operator[] 不会收到第二个参数。

显然，如果这个值不为零（不是 T()），那么我必须调整向量的大小并将适当的系数设置为传递的值。

但我不能提前这样做（在从 operator[] 返回 T& 之前），因为如果要分配的值是 T()，那么，只要我调整大小我提前输入系数向量，它最终会有很多尾随“零”。

当然，我可以检查该类的每个其他函数中是否有尾随零，并在这种情况下将其删除。对我来说这似乎是一个非常奇怪的决定，我希望每个函数都在假设向量的末尾没有零的情况下开始工作，如果它的大小> 1.

您能否建议我尽可能具体地解决这个问题？ 我听说过一些关于使用重载的 operator= 编写可隐式转换为 T& 的内部类，但我缺乏详细信息。

预先非常感谢您！

Answer 1

您可以尝试的一个选项（我尚未测试过）：

template<typename T>
class MyRef{
private:
   int index;
   Polynom<T>*p;
public:
    MyRef(int index, Polynom<T>*p) : index(index), p(p) { }

    MyRef<T>& operator=(T const&t); //and define these appropriately
    T operator T() const;         
};

并定义：

    MyRef<T> operator[](int index){
        return MyRef<T>(index, this);
    }

这样，当您为“引用”分配一个值时，它应该可以访问多项式中的所有所需数据，并采取适当的操作。

我对您的实现不够熟悉，因此我将给出一个非常简单的动态数组的示例，其工作原理如下：

• 您可以毫无顾虑地从任何int索引读取；先前未写入的元素应读取为 0；
• 当您写入超出当前分配数组末尾的元素时，该元素将被重新分配，并且新分配的元素将初始化为 0。

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

template<typename T>
class my_array{
private:
    T* _data;
    int _size;

    class my_ref{

        private:
            int index;
            T*& obj;
            int&size;
        public:
            my_ref(T*& obj, int&size, int index)
                : index(index), obj(obj), size(size){}

            my_ref& operator=(T const& t){

                if (index>=size){    
                    obj = (T*)realloc(obj, sizeof(T)*(index+1) );
                    while (size<=index)
                        obj[size++]=0;
                }
                obj[index] = t;

                return *this;
            }

            //edit:this one should allow writing, say, v[1]=v[2]=v[3]=4;
            my_ref& operator=(const my_ref&r){              
                operator=( (T) r);
                return *this;
            }

            operator T() const{
                return (index>=size)?0:obj[index];
            }

    };

public:
    my_array() : _data(NULL), _size(0) {}

    my_ref operator[](int index){
        return my_ref(_data,_size,index);
    }

    int size() const{ return _size; }

};

int main(){

    my_array<int> v;

    v[0] = 42;
    v[1] = 51;
    v[5] = 5; v[5]=6;
    v[30] = 18;

    v[2] = v[1]+v[5];
    v[4] = v[8]+v[1048576]+v[5]+1000;

    cout << "allocated elements: " <<  v.size() << endl;
    for (int i=0;i<31;i++)
        cout << v[i] << " " << endl;

    return 0;
}

这是一个非常简单的示例，目前的形式效率不高，但它应该证明这一点。

最终，您可能希望重载 operator& 以允许 *(&v[0] + 5) = 42; 等内容正常工作。对于此示例，您可以让 operator& 给出一个 my_pointer，它定义 operator+ 对其 index 进行算术运算字段并返回一个新的 my_pointer。最后，您可以重载 operator*() 以返回到 my_ref。

Answer 2

解决这个问题的办法是代理类（下面是未经测试的代码）：

template<typename T> class Polynom
{
public:
   class IndexProxy;
   friend class IndexProxy;
   IndexProxy operator[](int);
   T operator[](int) const;
   // ...
private:
   std::vector<T> coefficients;
};

template<typename T> class Polynom<T>::IndexProxy
{
public:
  friend class Polynom<T>;
  // contrary to convention this assignment does not return an lvalue,
  // in order to be able to avoid extending the vector on assignment of 0.0
  T operator=(T const& t)
  {
    if (theIndex >= thePolynom.coefficients.size())
      thePolynom.coefficients.resize(theIndex+1);
    thePolynom.coefficients[theIndex] = t;
    // the assignment might have made the polynom shorter
    // by assigning 0 to the top-most coefficient
    while (thePolynom.coefficients.back() == T())
      thePolynom.coefficients.pop_back();
    return t;
  }
  operator T() const
  {
    if (theIndex >= thePolynom.coefficients.size())
      return 0;
    return thePolynom.coefficients[theIndex];
  }
private:
  IndexProxy(Polynom<T>& p, int i): thePolynom(p), theIndex(i) {}
  Polynom<T>& thePolynom;
  int theIndex;
}

template<typename T>
  Polynom<T>::IndexProxy operator[](int i)
  {
    if (i < 0) throw whatever;
    return IndexProxy(*this, i);
  }

template<typename T>
  T operator[](int i)
{
  if (i<0) throw whatever;
  if (i >= coefficients.size()) return T();
  return coefficients[i];
}

显然上面的代码没有优化（尤其是赋值运算符显然有优化的空间）。

Answer 3

您无法通过运算符重载来区分读取和写入。您能做的最好的事情就是区分 const 设置和非 const 设置中的使用，这就是您的代码片段的作用。所以：

Polynomial &poly = ...;

poly[i] = 10;  // Calls non-const version
int x = poly[i];  // Calls non-const version

const Polynomial &poly = ...;

poly[i] = 10;   // Compiler error!
int x = poly[i]  // Calls const version

这听起来像是你两个问题的答案，因此，是有单独的 set 和 get 函数。

Answer 4

我看到您的问题有两种解决方案：

1. 不要将系数存储在 std::vector 中，而是将它们存储在 std::map< /代码>。这样您将只存储非零系数。您可以创建自己的基于 std::map 的容器，该容器将消耗存储在其中的零。这样，您还可以为具有较大 n 的 x^n 形式的多项式节省一些存储空间。

2. 添加一个内部类来存储索引（幂）和系数值。您将从 operator[] 返回对此内部类实例的引用。内部类将覆盖operator=。在重写的 operator= 中，您将获取存储在内部类实例中的索引（幂）和系数，并将它们刷新到存储系数的 std::vector 中。< /p>

Answer 5

这是不可能的。我能想到的唯一方法是提供一个特殊的成员函数来添加新系数。

编译器通过查看 Polynom 的类型来决定 const 和非 const 版本，而不是通过检查执行的操作类型关于返回值。