用数组 C++ 重载运算符 +=

Question

我正在做一个 c++ 程序。这就是我要做的：我创建一个我想要的大小的数组。数组自动填充0。

使用operator += i 必须在i 选择的位置插入1。 示例：

array += 2; 
will insert 1 at the index 2 of my array.

但是我该怎么做呢？

我的 .h 文件

#ifndef BITARRAY_H
#define BITARRAY_H
#include <ostream>

class bitArray
{
public:
    bitArray(int n);
    virtual ~bitArray();

    bitArray& operator+=(const bitArray&); //this operator
    bitArray& operator-=(const bitArray&);
    int& operator[] (int x) {
      return sortie[x];
  }
protected:
private:
    int sortie[];
    int n;
};

//ostream& operator<<(ostream&, const bitArray&);
#endif // BITARRAY_H

我在cpp文件中的方法：

bitArray& bitArray::operator+=(const bitArray& i)
{
    this ->sortie[i] = 1;
    return *this;
}

但它不起作用。我做对了吗？

我的错误是：

no match for 'operator[]' (operand types are 'int [0]' and 'const bitArray')|

提前谢谢你！

Answer 1

operator[] 不匹配（操作数类型为 'int [0]' 和 'const 位数组')|

错误很清楚，operator[] 期望一个整数类型，而你传递了一个 bitArray 类类型。简单的解决方法是将其更改为整数。

但是，这里：

private:
    int sortie[];
    int n;

强烈推荐使用std::vector，它给出一个连续的动态数组，而sortie[]是静态分配。像这样的：

See live here

#include <iostream>
#include <vector>
#include <cstddef>

class bitArray
{
private:
   std::vector<int> sortie;
public:
   explicit bitArray(int size): sortie(size) {}
   bitArray& operator+=(const std::size_t i)
   {
      if (0 <= i && i < sortie.size()) // check for (0 <= index < size) of the array
      {
            this ->sortie[i] = 1;
            return *this;
      }
      else
      {
         // do your logic! for instance, I have done something like follows:
         std::cout << "out of bound" << std::endl;
         if(sortie.size() == 0) sortie.resize(1,0); // if the size of array == 0            
      }
      return *this;
   }
   int operator[] (const std::size_t index)
   {
      return (0 <= index && index < sortie.size()) ? sortie[index] : -1;
   }
};
int main ()
{
   bitArray obj(3);
   obj += 0;  std::cout << obj[0] << std::endl;
   obj += -2; std::cout << obj[-2] << std::endl;
   obj += 22; std::cout << obj[22] << std::endl; 
   return 0;
}

---

更新：使用 C++17 特性std::optional，将上述解决方案修改为可选返回类型，应该更具可读性。

See output in wandbox

#include <iostream>
#include <vector>
#include <cstddef>
#include <optional>

class bitArray
{
private:
   std::vector<int> sortie;
public:
   explicit bitArray(int size): sortie(size) {}
   // optional is used as the return type
   std::optional<bitArray> operator+=(const std::size_t i)
   {
      if (i < sortie.size()) // check for (0 <= index < size) of the array
      {
            this -> sortie[i] = 1;
            return std::optional<bitArray>{*this};
      }
      std::cout << "out of bound operation+= \t";
      return std::nullopt;    // std::nullopt to create any (empty) std::optional
   }
   std::optional<int> operator[] (const std::size_t index)
   {
      if(index < sortie.size())   return std::optional<int>{sortie[index]};
      else
      {
         std::cout << "out of bound operator[]: ";
         return std::nullopt;
      }
   }
};
int main ()
{
   bitArray obj(3);
   obj += 0;  std::cout << obj[0].value_or(-1) << std::endl;
   obj += -2; std::cout << obj[-2].value_or(-1) << std::endl;
   bitArray obj1(0);
   obj1 += 22; std::cout << obj1[22].value_or(-1) << std::endl;
   return 0;
}

Answer 2

您的operator+= 采用bitArray 作为参数，但它应该采用设置1 的索引，这基本上就是错误消息试图告诉您的内容：您的参数没有过载尝试使用它。

请注意，要获得这样的运算符，您不需要编写自己的数组类，但可以为std::vector 提供重载：

#include <iostream>
#include <vector>

template <typename T> 
std::vector<T>& operator+=(std::vector<T>& v,size_t index) {
    v[index] = 1;
    return v;
}     

int main() {
    auto vec = std::vector<int>(10,0);
    vec += 5;
    std::cout << vec[5];
    return 0;
}

请注意，这是实现+= 的一种相当不常见的方式（它实际上并没有添加任何东西）。我认为这是对运算符重载的滥用，它会导致代码混淆。考虑一下：

vec[5] = 1;

对比

vec += 5;

在第一行中，熟悉std::vector 的每个人都会知道它的作用，而对于第二行，90% 的期望将被取消。我猜你这样做是作为作业或家庭作业的一部分，但对于其他任何事情，我建议你不要使用操作符重载，因为它们做的事情不仅仅是显而易见的事情。