在对象中传递函数和运算符

Question

I am wanting to make a class which allows me to lock an object from being modified. It would essentially be a template with a boolean specifying the lock state. Since it is a template, I won't know all the methods that can be called on the internal object, so I need a method to pass calls through...

template<class T>
class const_lock
{
  public:
  const_lock() : my_lock(false) {}
  void set_const_lock(bool state) {my_lock = state;}

  // HOW TO IMPLEMENT SOMETHING LIKE THESE????
  //
  template<typename...Args >
  auto operatorANY_OPERATOR (Args...args)
 {
    if(my_lock != false)
       throw std::exception("Objected locked to modification");
    return my_value.ANY_OPERATOR(args);
 }

  template<typename...Args >
  auto operatorANY_CONST_OPERATOR (Args...args) const
 {
    return my_value.ANY_CONST_OPERATOR(args);
 }

  template<typename...Args >
  auto ANY_METHOD(Args...args)
 {
    if(my_lock != false)
       throw std::exception("Objected locked to modification");
    return my_value.ANY_METHOD(args);
 }

  template<typename...Args >
  auto ANY_CONST_METHOD(Args...args) const
 {
    return my_value.ANY_CONST_METHOD(args);
 }

  private:
    bool my_lock;
    T my_value;
}

int main()
{
  const_lock<std::vector<int>> v;
  v.push_back(5);
  v.push_back(7);
  v.set_const_lock(true);
  v.push_back(9); // fails compilation
  std::cout << v.at(1) << std::endl; // ok
}

Any help would be appreciated. Thanks!

Edit: changed static assert to throw and exception

Answer 1

What you're trying to do looks rather difficult, but more importantly is over-complicated and unnecessary for what you're trying to do.

Essentially what you're trying to do (correct me if I'm wrong) is create a compile time check of whether you are supposed to able to modify an object at a given time. However, c++ already has a built in way of doing this. Simply declare or pass your object as const or const&, and the compiler will not allow you to modify non-mutable parts of the object. When you want to be able to modify it pass it without const. You can even cast it from const& to regular & when you want to go from code where you can't modify it directly to code where you can, though I don't recommend it.

edit: just saw a comment on the question about no reference arrays. Don't worry about that! The standard library has support for reference wrappers which allow you to essentially store references in arrays or anywhere else.

Answer 2

You can make a generic wrapper class that you can forward the function to using a lambda that captures a reference to the internal member. In this example I am just using an if statement to check if it is "locked" and if it is then we just modify a copy.

template<class T>
class const_lock
{
private:
    bool my_lock;
    mutable T my_value;
public:
    const_lock() : my_lock(false) {}
    void set_const_lock() { my_lock = true; }


    template<typename F>
    auto operator()(F f) const -> decltype(f(my_value))
    {
        if (my_lock)
        {
            T temp{my_value};  // make a copy
            return f(temp);
        }
        else 
            return f(my_value); // modify wrraped value
    }
};

int main()
{
    const_lock<std::string> cl;
    cl([](std::string& s) {
        s = "foobar";
    });
    cl([](std::string& s) {
        std::cout << s << std::endl;
    });
    cl.set_const_lock();
    cl([](std::string& s) {
        s = "we should still be foobar";
    });
    cl([](std::string& s) {
        std::cout << s;
    });
}

Answer 3

This is completely unimplementable. A trivial modification of your source code shows why this won't work.

int main()
{
  const_lock<std::vector<int>> v;
  v.push_back(5);
  v.push_back(7);
  if (rand() % 2)
      v.set_const_lock(true);
  v.push_back(9); // fails compilation
  std::cout << v.at(1) << std::endl; // ok
}

You need to completely rethink your approach.

Answer 4

Below is an example illustrating what I would be trying to protect against

  class Node
  {
    public:
      Node(int id) : my_id(id) {}
      // . . . 
      int id() {return my_id;}

    private:
      int my_id;
      // . . .
  };

  class Grid
  {
    public:
      Grid() {}
      // . . . 

      void associate(Node* n) { my_nodes.push_back(n); }

    private:
      // . . .
      std::vector<Node*> my_nodes;
  };

  Node* find(std::vector<Node>& Nodes, int ID)
  {
    for(auto i=Nodes.begin(); i!=Nodes.end(); ++i)
    {
      if (i->id() == ID)
      {
        return &*i;
      }
    }
  }

  main()
  {
    std::vector<Node> Nodes;
    // fill Nodes with data


    Grid Array;
    Array.associate( find(Nodes,14325) );
    Array.associate( find(Nodes,51384) );
    Array.associate( find(Nodes,321684) );

    // . . .
    Nodes.push_back(Node(21616)); // this can invalidate my pointers in Array

  }

If I was able to make my Nodes vairable be

 const_lock<std::vector<Node>> Nodes;

then call

 Nodes.set_const_lock(true);

after populating the data, I wouldn't need to worry about my pointers in Array getting messed up.