将两个变量关联起来一起更改

Question

是否可以将两个要更改的变量关联在一起？

示例：

class foo{
public:
     std::vector<int> v1;
     std::vector<float> v2;
     //Imaginary Code here:
     void on_v2_change(){
          std::transform(begin(v2),end(v2),begin(v1),[](auto& item){ return std::round(item);});
     }
}
int main(){
    foo bar;
    bar.v2.push_back(5.7);
    //v2={5.4}
    //v1={5}
}

有没有一种简单的方法来实现前面的？比如Java或C#事件。

Answer 1

我不知道你是否可以使用这种语法，但你可以使用以下语法：

class foo {
    std::vector<int> v1;
    std::vector<float> v2;
    public:
    void push_back(float val) {
        v1.push_back(std::round(val));
        v2.push_back(val);
    }
    // ....

您还可以为其他功能添加类似的函数（如erase（））。据我所知，没有其他方法可以同时改变两个向量。

Answer 2

您可以编写一个包含事件的包装器，类似于：

template<typename V>
class vector_observer
{
    virtual ~vector_observer() = default;
    virtual void on_push_back(typename V::const_reference value) = 0;
    virtual void on_clear() = 0;
    // ...
};
template<typename T>
class observed_vector
{
private:
    std::vector<T> vec;
    vector_observer& obs;
public:
    explicit observed_vector(vector_observer& obs) : obs(obs) {}
    void push_back(const T& value) { vec.push_back(value); obs.on_push_back(value); }
    void clear() { vec.clear(); obs.on_clear(); }
    // ...
};

和

class to_int_vector_observer : public vector_observer<std::vector<float>>
{
public:
    explicit to_int_vector_observer(std::vector<int>&vec) : vec(vec) {}
    void on_push_back(float value) override{ vec.push_back(round(value)); }
    void on_clear() override { vec.clear(); }
private:
    std::vector<int>& vec;
}

Answer 3

使用模板类和函数，使输入成为泛型，并在作为参数传递时转换输入。

#include <iostream>
#include <vector>
template <class T1, class T2>
class Stack {
  private:
    std::vector<T1> v1;
    std::vector<T2> v2;
  public:
  template<typename T3, typename T4>
  void push (T3 v,  T4 flag) {
    if(flag)
        v1.push_back(v);
    else
        v2.push_back(v);
  }
};
int main() {
  Stack<int,float> stack;
  stack.push(7,0);
  stack.push((int)7.5,1);
}

也可以根据需要进行修改，如float -> int变换可以根据用途和设计在push方法中进行。

Answer 4

尽管运算符（）的转移不是一个非常符合C++的解决方案。。。

#include "stdafx.h"
#include <vector>
class vectorFloatAndInt : public std::vector<float>
{
public:
    inline int operator () (unsigned int paramPos)
    {
         return std::round((*this)[paramPos]);
    }
};
int main()
{
   vectorFloatAndInt bar;
   bar.push_back(5.4);
   float vf = bar[0];    // == 5.4
   int vi = bar(0);      // == 5
   return 0;
}