C++ 类c的iota增量向量++；

我最近一直在利用

iota

语句来增加

int

类型的向量。但是现在我尝试使用该语句来增加一个包含2个成员的显式类

下面是整数向量的用法：

vector<int> n(6);
iota(n.begin(), n.end(), 1);

我尝试过使类增量重载有点像这样：

Obj& operator ++() {
    *this.m++;
    return *this;
}

---

但我认为要么我的构造函数不是为这种重载设计的，要么反之亦然。我如何修改构造函数和重载以增加具有iota的对象成员？提前谢谢

我不太明白你的问题。以下代码是否与您想要的匹配

#include <algorithm>
#include <iostream>
#include <vector>

class Object {
 public:
  Object(int value = 0)
      : m_value(value) { }
  Object& operator++() {
    m_value++;
    return *this;
  }
  int value() const {
    return m_value;
  }
 private:
  int m_value;
};

int main() {
  std::vector<Object> os(10);
  std::iota(os.begin(), os.end(), 0);
  for(const auto & o : os) {
    std::cout << o.value() << std::endl;
  }
}

---

我不确定我是否理解你的问题。以下代码是否与您想要的匹配

#include <algorithm>
#include <iostream>
#include <vector>

class Object {
 public:
  Object(int value = 0)
      : m_value(value) { }
  Object& operator++() {
    m_value++;
    return *this;
  }
  int value() const {
    return m_value;
  }
 private:
  int m_value;
};

int main() {
  std::vector<Object> os(10);
  std::iota(os.begin(), os.end(), 0);
  for(const auto & o : os) {
    std::cout << o.value() << std::endl;
  }
}

更新：我更改了答案以提供注释中要求的功能：即，能够更新多个字段

按照与以下类似的方式设置类的格式。您将需要重载

++

运算符以同时递增

\u m

和

\u c

class Obj {
    private:
        int _m;
        char _c;

    public:
        Obj(int m, char c) : _m(m), _c(c)
        {
        }

        MyClass operator++()
        {
            _m++;
            _n++;

            return *this;
        }
};

以下代码将使用6个对象初始化向量

o

，每个对象包含从1开始的

\u m

和

\u c

的升序值

vector<Obj> o(6);
iota(o.begin(), o.end(), Obj(1, 1));

向量o（6）； iota（o.begin（）、o.end（）、Obj（1,1））； 更新：我更改了答案以提供注释中要求的功能：即，能够更新多个字段

按照与以下类似的方式设置类的格式。您将需要重载

++

运算符以同时递增

\u m

和

\u c

class Obj {
    private:
        int _m;
        char _c;

    public:
        Obj(int m, char c) : _m(m), _c(c)
        {
        }

        MyClass operator++()
        {
            _m++;
            _n++;

            return *this;
        }
};

以下代码将使用6个对象初始化向量

o

，每个对象包含从1开始的

\u m

和

\u c

的升序值

vector<Obj> o(6);
iota(o.begin(), o.end(), Obj(1, 1));

向量o（6）； iota（o.begin（）、o.end（）、Obj（1,1））；

#包括//标准：：物联网
#包括
使用名称空间std；
Obj类
{
私人：
int m_；
公众：
auto value（）const->int{return m_；}
Obj（int m=0）：m_Um（m）{}
};
auto main（）->int
{
向量v（6）；
iota（v.开始（），v.结束（），1）；
}

#包括//标准：：物联网
#包括
使用名称空间std；
Obj类
{
私人：
int m_；
公众：
auto value（）const->int{return m_；}
Obj（int m=0）：m_Um（m）{}
};
auto main（）->int
{
向量v（6）；
iota（v.开始（），v.结束（），1）；
}

我对您的描述有点困惑：

iota

增加您传递给它的值（第三个参数），而不是它修改/遍历的范围的元素。您想通过递增来修改这些元素，还是用递增值覆盖它们？@dyp我想用递增值覆盖它们，因为我的构造函数已经将它们的值设置为0。这可能吗？

iota（o.begin（）、o.end（）、Obj（1））是的，您需要重载，因为iota将调用它（否则它将如何“增加”对象？）。您也可以使用递增的值生成它们；）使用适当的迭代器，
vector n（make_iota_iterator（6，Obj（1）），iota_iterator（）
或类似的东西（使用自定义的
make_iota_iterator
函数）。我对您的描述有点困惑：
iota
增加您传递的值（第三个参数），而不是它修改/遍历的范围的元素。您想通过递增来修改这些元素，还是用递增值覆盖它们？@dyp我想用递增值覆盖它们，因为我的构造函数已经将它们的值设置为0。这可能吗？
iota（o.begin（）、o.end（）、Obj（1））是的，您需要重载，因为iota将调用它（否则它将如何“增加”对象？）。您也可以使用递增的值生成它们；）使用适当的迭代器，
vector n（make_iota_iterator（6，Obj（1）），iota_iterator（）
或类似的东西（使用自定义的
make_iota_iterator
函数）。谢谢，由于解释太长，我给了你一个被接受的答案。布雷特的看起来也不错。谢谢大家！如果没有Object:：operator++（），这将很好地工作。它之所以有效，是因为构造函数没有标记为显式的。
。谢谢，因为解释太长，我给了你一个被接受的答案。布雷特的看起来也不错。谢谢大家！如果没有Object:：operator++（），这将很好地工作。它之所以有效是因为构造函数没有标记为
explicit
@Brett\u-Wolfington谢谢，这在没有
++
重载的情况下有效吗？是的。不需要++重载。通过同时增加2个成员，这是否也有效；如果有第二个成员，比如说类型为
char
？@Jim22150，我建议您提出一个新问题，其中包含您的问题的更多细节。最好是一个完整的（可编译的）示例，其中包含除表达式之外的所有内容，以创建/修改向量的元素。新代码确实会同时增加2个成员，但需要重载
++
@Brett_-Wolfington谢谢，这在没有
++
重载的情况下有效吗？是的。不需要++重载。通过同时增加2个成员，这是否也有效；如果有第二个成员，比如说类型为
char
？@Jim22150，我建议您提出一个新问题，其中包含您的问题的更多细节。最好是一个完整的（可编译的）示例，其中包含除表达式之外的所有内容，以创建/修改向量的元素。新代码确实会同时增加2个成员，但需要重载
++
；我喜欢v.11的汽车。不过我已经接受了一个答案。我要玩这个！这可能是我最喜欢的答案；我喜欢v.11的汽车。我已经接受了一个答案